[Breaking] UnitStyle, allunits and a bunch of renaming

src/TensorKitSectors.jl

@@ -11,9 +11,11 @@ export dim, sqrtdim, invsqrtdim, frobeniusschur, twist, fusiontensor, dual
 export otimes, deligneproduct, times
 export FusionStyle, UniqueFusion, MultipleFusion, SimpleFusion, GenericFusion,
     MultiplicityFreeFusion
+export MultiFusionStyle, UniqueMultiFusion, SimpleMultiFusion, GenericMultiFusion,
+    MultiplicityFreeMultiFusion
 export BraidingStyle, NoBraiding, HasBraiding, SymmetricBraiding, Bosonic, Fermionic, Anyonic
 export SectorSet, SectorValues, findindex
-export rightone, leftone
+export rightone, leftone, allones
 
 export triangle_equation, pentagon_equation, hexagon_equation
 

src/multifusion.jl

@@ -54,7 +54,7 @@ function Base.convert(::Type{IsingAnyon}, a::IsingBimodule) # identify RepZ2 ⊕
     return IsingAnyon(a.label == 0 ? :I : :ψ)
 end
 
-FusionStyle(::Type{IsingBimodule}) = SimpleFusion() # no multiplicities
+MultiFusionStyle(::Type{IsingBimodule}) = SimpleMultiFusion() # no multiplicities
 BraidingStyle(::Type{IsingBimodule}) = NoBraiding() # because of module categories
 
 function Nsymbol(a::IsingBimodule, b::IsingBimodule, c::IsingBimodule)
@@ -91,6 +91,8 @@ function Base.one(::Type{IsingBimodule})
     throw(ArgumentError("one of Type IsingBimodule doesn't exist"))
 end
 
+allones(::Type{IsingBimodule}) = (IsingBimodule(1, 1, 0), IsingBimodule(2, 2, 0))
+
 function Base.isless(a::IsingBimodule, b::IsingBimodule)
     return isless((a.col, a.row, a.label), (b.col, b.row, b.label))
 end

src/sectors.jl

@@ -109,6 +109,14 @@ See also [`leftone`](@ref) and [`Base.one`](@ref).
 """
 rightone(a::Sector) = one(a)
 
+"""
+    allones(I::Type{<:Sector}) -> Tuple{I}
+
+Return a tuple with all unit elements of the sector type `I`.
+For fusion categories, this will contain only one element.
+"""
+allones(I::Type{<:Sector}) = (one(I),)
+
 """
     dual(a::Sector) -> Sector
 
@@ -220,6 +228,55 @@ Base.:&(::SimpleFusion, ::UniqueFusion) = SimpleFusion()
 Base.:&(::GenericFusion, ::UniqueFusion) = GenericFusion()
 Base.:&(::GenericFusion, ::SimpleFusion) = GenericFusion()
 
+# similar, but for multifusion categories
+"""
+    MultiFusionStyle(::Sector)
+    MultiFusionStyle(I::Type{<:Sector})
+
+Trait to describe the fusion behavior of multifusion sectors of type `I`,
+which is based on the most general fusion behavior of the subcategories in
+the multifusion category. For all allowed fusions, the following types are possible:
+*   `UniqueMultiFusion()`: single fusion output;
+*   `SimpleMultiFusion()`: multiple outputs, but every output occurs at most once;
+*   `GenericMultiFusion()`: multiple outputs that can occur more than once.
+
+There is a type alias `MultiplicityFreeMultiFusion`
+for those fusion types which do not require muliplicity labels, i.e.
+`MultiplicityFreeMultiFusion = Union{UniqueMultiFusion,SimpleMultiFusion}`.
+"""
+abstract type MultiFusionStyle end
+MultiFusionStyle(a::Sector) = MultiFusionStyle(typeof(a))
+
+struct UniqueMultiFusion <: MultiFusionStyle end
+struct SimpleMultiFusion <: MultiFusionStyle end
+struct GenericMultiFusion <: MultiFusionStyle end
+const MultiplicityFreeMultiFusion = Union{UniqueMultiFusion, SimpleMultiFusion}
+
+# combine fusion properties of tensor products of multifusion sectors
+Base.:&(f::F, ::F) where {F <: MultiFusionStyle} = f
+Base.:&(f₁::MultiFusionStyle, f₂::MultiFusionStyle) = f₂ & f₁
+
+Base.:&(::SimpleMultiFusion, ::UniqueMultiFusion) = SimpleMultiFusion()
+Base.:&(::GenericMultiFusion, ::UniqueMultiFusion) = GenericMultiFusion()
+Base.:&(::GenericMultiFusion, ::SimpleMultiFusion) = GenericMultiFusion()
+
+# combine fusion properties of tensor products between fusion and multifusion sectors
+# lift FusionStyle to MultiFusionStyle
+
+Base.:&(g::G, f::F) where {F <: MultiFusionStyle, G <: FusionStyle} = f & g
+
+function Base.:&(f::F, g::G) where {F <: MultiFusionStyle, G <: FusionStyle}
+    if f isa GenericMultiFusion || g isa GenericFusion
+        return GenericMultiFusion()
+    elseif f isa SimpleMultiFusion # g isa MultiplicityFreeFusion
+        return SimpleMultiFusion()
+    elseif g isa SimpleFusion # f isa UniqueMultiFusion
+        return SimpleMultiFusion()
+    else
+        return UniqueMultiFusion()
+    end
+end
+
 """
     Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {I<:Sector}
 

test/multifusion.jl

@@ -4,6 +4,10 @@ Istr = TensorKitSectors.type_repr(I)
     @testset "Basic type properties" begin
         @test eval(Meta.parse(sprint(show, I))) == I
         @test eval(Meta.parse(TensorKitSectors.type_repr(I))) == I
+
+        @test MultiFusionStyle(I) isa MultiplicityFreeMultiFusion
+        @test MultiFusionStyle(I) & GenericFusion() isa GenericMultiFusion
+        @test MultiFusionStyle(I) & SimpleFusion() == SimpleFusion() & MultiFusionStyle(I)
     end
 
     M = IsingBimodule(1, 2, 0)
@@ -27,6 +31,9 @@ Istr = TensorKitSectors.type_repr(I)
         @test isone(D0)
         @test !isone(C1) && !isone(D1) && !isone(M) && !isone(Mop)
 
+        @test length(allones(I)) == 2
+        @test allones(I) == (C0, D0)
+
         @test eval(Meta.parse(sprint(show, s))) == s
         @test @constinferred(hash(s)) == hash(deepcopy(s))
         @constinferred dual(s)

test/sectors.jl

@@ -40,6 +40,7 @@ end
         i >= 10 && break
     end
     @test one(I) == first(values(I))
+    @test length(allones(I)) == 1
     @test (@constinferred findindex(values(I), one(I))) == 1
     for s in smallset(I)
         @test (@constinferred values(I)[findindex(values(I), s)]) == s