Make testsuite compatible with multifusion categories

src/product.jl

@@ -34,6 +34,17 @@ function Base.size(::SectorValues{ProductSector{T}}) where {T <: SectorTuple}
 end
 Base.length(P::SectorValues{<:ProductSector}) = *(size(P)...)
 
+# time reversed
+function Base.IteratorSize(::Type{SectorValues{TimeReversed{ProductSector{T}}}}) where {T <: SectorTuple}
+    return Base.IteratorSize(SectorValues{ProductSector{T}})
+end
+function Base.size(::SectorValues{TimeReversed{ProductSector{T}}}) where {T <: SectorTuple}
+    return size(SectorValues{ProductSector{T}}())
+end
+function Base.length(::SectorValues{TimeReversed{ProductSector{T}}}) where {T <: SectorTuple}
+    return length(SectorValues{ProductSector{T}}())
+end
+
 function _length(iter::SectorValues{I}) where {I <: Sector}
     return Base.IteratorSize(iter) === Base.IsInfinite() ? typemax(Int) : length(iter)
 end

test/multifusion.jl

@@ -2,9 +2,6 @@ I = IsingBimodule
 Istr = TensorKitSectors.type_repr(I)
 @testset "$Istr sector" begin
     @testset "Basic type properties" begin
-        @test eval(Meta.parse(sprint(show, I))) == I
-        @test eval(Meta.parse(TensorKitSectors.type_repr(I))) == I
-
         prodsec = I ⊠ Z2Irrep
         @test UnitStyle(prodsec) isa GenericUnit
         @test FusionStyle(prodsec) isa SimpleFusion
@@ -23,13 +20,13 @@ Istr = TensorKitSectors.type_repr(I)
     s = rand((M, Mop, C, D))
 
     @testset "Basic properties" begin
-        @test @constinferred(unit(C1)) == @constinferred(leftunit(C1)) ==
-            @constinferred(rightunit(C1))
+        @test @testinferred(unit(C1)) == @testinferred(leftunit(C1)) ==
+            @testinferred(rightunit(C1))
         @test unit(D1) == leftunit(D1) == rightunit(D1)
         @test unit(C1) == leftunit(M) == rightunit(Mop)
         @test unit(D1) == rightunit(M) == leftunit(Mop)
 
-        @test @constinferred(isunit(C0))
+        @test @testinferred(isunit(C0))
         @test isunit(D0)
         @test !isunit(C1) && !isunit(D1) && !isunit(M) && !isunit(Mop)
 
@@ -44,35 +41,7 @@ Istr = TensorKitSectors.type_repr(I)
         @test length(allunits(I ⊠ I)) == 4
 
         @test leftunit(M ⊠ Mop) == C0 ⊠ D0 == rightunit(Mop ⊠ M)
-
-        @test eval(Meta.parse(sprint(show, s))) == s
-        @test @constinferred(hash(s)) == hash(deepcopy(s))
-        @constinferred dual(s)
-        @test dual(dual(s)) == s
-        @constinferred dim(s)
-        @constinferred frobenius_schur_phase(s)
-        @constinferred convert(IsingAnyon, s)
-
-        @constinferred Bsymbol(C, C, C)
-        @constinferred Fsymbol(D, D, D, D, D, D)
-    end
-
-    @testset "$Istr: Value iterator" begin
-        @test eltype(values(I)) == I
-        @test_throws ArgumentError unit(I)
-        sprev = C0 # first in SectorValues
-        for (i, s) in enumerate(values(I))
-            @test !isless(s, sprev) # confirm compatibility with sort order
-            @test s == @constinferred (values(I)[i])
-            @test findindex(values(I), s) == i
-            sprev = s
-            i >= 10 && break
-        end
-        @test C0 == first(values(I))
-        @test (@constinferred findindex(values(I), C0)) == 1
-        for s in collect(values(I))
-            @test (@constinferred values(I)[findindex(values(I), s)]) == s
-        end
+        @testinferred convert(IsingAnyon, s)
     end
 
     @testset "$Istr: Printing and errors" begin
@@ -122,31 +91,4 @@ Istr = TensorKitSectors.type_repr(I)
 
         @test_throws argerr Fsymbol(M, Mop, M, Mop, C, D)
     end
-
-    @testset "$Istr: Unitarity of F-move" begin
-        objects = collect(values(I))
-        for a in objects, b in objects, c in objects
-            for d in ⊗(a, b, c)
-                es = collect(intersect(⊗(a, b), map(dual, ⊗(c, dual(d)))))
-                fs = collect(intersect(⊗(b, c), map(dual, ⊗(dual(d), a))))
-                @test length(es) == length(fs)
-                F = [Fsymbol(a, b, c, d, e, f) for e in es, f in fs]
-                @test isapprox(F' * F, one(F); atol = 1.0e-12, rtol = 1.0e-12)
-            end
-        end
-    end
-
-    @testset "$Istr: Triangle equation" begin
-        for a in smallset(I), b in smallset(I)
-            @test triangle_equation(a, b; atol = 1.0e-12, rtol = 1.0e-12)
-        end
-    end
-
-    @testset "$Istr: Pentagon equation" begin
-        objects = collect(values(I))
-        for a in objects, b in objects, c in objects, d in objects
-            # compatibility checks built in Fsymbol
-            @test pentagon_equation(a, b, c, d; atol = 1.0e-12, rtol = 1.0e-12)
-        end
-    end
 end

test/runtests.jl

@@ -11,7 +11,7 @@ const sectorlist = (
     DNIrrep{3}, DNIrrep{4}, DNIrrep{5}, CU1Irrep,
     A4Irrep, SU2Irrep, NewSU2Irrep,
     FibonacciAnyon, IsingAnyon, FermionParity,
-    FermionParity ⊠ FermionParity,
+    FermionParity ⊠ FermionParity, PlanarTrivial ⊠ FibonacciAnyon,
     Z3Irrep ⊠ Z4Irrep, FermionParity ⊠ U1Irrep ⊠ SU2Irrep,
     FermionParity ⊠ SU2Irrep ⊠ SU2Irrep, NewSU2Irrep ⊠ NewSU2Irrep,
     NewSU2Irrep ⊠ SU2Irrep, FermionParity ⊠ SU2Irrep ⊠ NewSU2Irrep,
@@ -22,6 +22,8 @@ const sectorlist = (
     Z4Element{0}, Z4Element{1}, Z4Element{2},
     Z3Element{1} ⊠ SU2Irrep,
     FibonacciAnyon ⊠ Z4Element{3},
+    IsingBimodule, IsingBimodule ⊠ IsingBimodule, IsingBimodule ⊠ Z2Irrep,
+    IsingBimodule ⊠ SU2Irrep, IsingBimodule ⊠ FibonacciAnyon,
     TimeReversed{Z2Irrep},
     TimeReversed{Z3Irrep}, TimeReversed{Z4Irrep}, TimeReversed{A4Irrep},
     TimeReversed{U1Irrep}, TimeReversed{CU1Irrep}, TimeReversed{SU2Irrep},
@@ -81,8 +83,10 @@ end
         @testinferred I1 ⊠ I2
         @test typeof(a ⊠ b) == I1 ⊠ I2
 
-        @test @testinferred(length(allunits(I1 ⊠ I2))) == 1
-        @test @testinferred(unit(I1 ⊠ I2)) == leftunit(a ⊠ b) == rightunit(a ⊠ b)
+        if UnitStyle(I1 ⊠ I2) isa SimpleUnit
+            @test @testinferred(length(allunits(I1 ⊠ I2))) == 1
+            @test @testinferred(unit(I1 ⊠ I2)) == leftunit(a ⊠ b) == rightunit(a ⊠ b)
+        end
     end
     @test @testinferred(Tuple(SU2Irrep(1) ⊠ U1Irrep(0))) == (SU2Irrep(1), U1Irrep(0))
     @test @testinferred(length(FermionParity(1) ⊠ SU2Irrep(1 // 2) ⊠ U1Irrep(1))) == 3

test/sectors.jl

@@ -3,60 +3,60 @@ using LinearAlgebra
 using TensorKitSectors: TensorKitSectors as TKS
 
 @testsuite "Basic properties" I -> begin
-    s = (randsector(I), randsector(I), randsector(I))
+    s = random_fusion(I, Val(2))
+    sc = @testinferred(first(⊗(s...)))
     @test Base.eval(Main, Meta.parse(sprint(show, I))) == I
     @test Base.eval(Main, Meta.parse(TensorKitSectors.type_repr(I))) == I
-    @test Base.eval(Main, Meta.parse(sprint(show, s[1]))) == s[1]
-    @test @testinferred(hash(s[1])) == hash(deepcopy(s[1]))
-    @test @testinferred(unit(s[1])) == @testinferred(unit(I))
-    @testinferred dual(s[1])
-    @testinferred dim(s[1])
-    @testinferred frobenius_schur_phase(s[1])
-    @testinferred frobenius_schur_indicator(s[1])
-    @testinferred Nsymbol(s...)
-    @testinferred Asymbol(s...)
-    B = @testinferred Bsymbol(s...)
-    F = @testinferred Fsymbol(s..., s...)
+    @test Base.eval(Main, Meta.parse(sprint(show, sc))) == sc
+    @test @testinferred(hash(sc)) == hash(deepcopy(sc))
+    if UnitStyle(I) isa SimpleUnit
+        @test @testinferred(unit(sc)) == @testinferred(unit(I))
+    end
+    @testinferred dual(sc)
+    @testinferred dim(sc)
+    @testinferred frobenius_schur_phase(sc)
+    @testinferred frobenius_schur_indicator(sc)
+    @testinferred(⊗(s..., s...))
+    @testinferred Nsymbol(s..., sc)
+    @testinferred Asymbol(s..., sc)
+    B = @testinferred Bsymbol(s..., sc)
+    s2 = random_fusion(I, Val(3))
+    s2c = first(⊗(s2...))
+    e, f = first(⊗(s2[1], s2[2])), first(⊗(s2[2], s2[3]))
+    F = @testinferred Fsymbol(s2..., s2c, e, f)
     @test eltype(F) === @testinferred fusionscalartype(I)
     if BraidingStyle(I) isa HasBraiding
-        R = @testinferred Rsymbol(s...)
+        R = @testinferred Rsymbol(s..., sc)
         @test eltype(R) === @testinferred braidingscalartype(I)
         if FusionStyle(I) === SimpleFusion()
             @test typeof(R * F) <: @testinferred sectorscalartype(I)
         else
             @test Base.promote_op(*, eltype(R), eltype(F)) <: @testinferred sectorscalartype(I)
         end
-    else
-        if FusionStyle(I) === SimpleFusion()
-            @test typeof(F) <: @testinferred sectorscalartype(I)
-        else
-            @test eltype(F) <: @testinferred sectorscalartype(I)
-        end
     end
-    @testinferred(s[1] ⊗ s[2])
-    @testinferred(⊗(s..., s...))
 end
 
 @testsuite "Value iterator" I -> begin
     @test eltype(values(I)) == I
-    sprev = unit(I)
+    simple = UnitStyle(I) isa SimpleUnit
+    sprev = simple ? unit(I) : first(values(I))
+    @test (@testinferred findindex(values(I), sprev)) == 1
     for (i, s) in enumerate(values(I))
         @test !isless(s, sprev)
         @test s == @testinferred(values(I)[i])
         @test findindex(values(I), s) == i
         sprev = s
         i >= 10 && break
     end
-    @test unit(I) == first(values(I))
-    @test length(allunits(I)) == 1
-    @test (@testinferred findindex(values(I), unit(I))) == 1
+    @test simple ? length(allunits(I)) == 1 : length(allunits(I)) > 1
     for s in smallset(I)
         @test (@testinferred values(I)[findindex(values(I), s)]) == s
     end
 end
 
 @testsuite "Fusion and dimensions" I -> begin
     for a in smallset(I), b in smallset(I)
+        isempty(⊗(a, b)) && continue
         da = dim(a)
         db = dim(b)
         dc = sum(c -> dim(c) * Nsymbol(a, b, c), a ⊗ b)
@@ -170,22 +170,7 @@ end
 
 @testsuite "Unitarity of F-move" I -> begin
     for a in smallset(I), b in smallset(I), c in smallset(I)
-        for d in ⊗(a, b, c)
-            es = collect(intersect(⊗(a, b), map(dual, ⊗(c, dual(d)))))
-            fs = collect(intersect(⊗(b, c), map(dual, ⊗(dual(d), a))))
-            if FusionStyle(I) isa MultiplicityFreeFusion
-                @test length(es) == length(fs)
-                F = [Fsymbol(a, b, c, d, e, f) for e in es, f in fs]
-            else
-                Fblocks = Vector{Any}()
-                for e in es, f in fs
-                    Fs = Fsymbol(a, b, c, d, e, f)
-                    push!(Fblocks, reshape(Fs, (size(Fs, 1) * size(Fs, 2), size(Fs, 3) * size(Fs, 4))))
-                end
-                F = hvcat(length(fs), Fblocks...)
-            end
-            @test isapprox(F' * F, one(F); atol = 1.0e-12, rtol = 1.0e-12)
-        end
+        @test unitarity_test(a, b, c)
     end
 end
 

test/testsuite.jl

@@ -20,11 +20,12 @@ SectorTestSuite.test_sector(MySectorType)
 Additionally, this test suite exports the following convenience testing utilities:
 * [`smallset`](@ref)
 * [`randsector`](@ref)
+* [`random_fusion`](@ref)
 * [`hasfusiontensor`](@ref)
 """
 module SectorTestSuite
 
-export smallset, randsector, hasfusiontensor
+export smallset, randsector, random_fusion, hasfusiontensor, unitarity_test
 
 using Test
 using TestExtras
@@ -69,7 +70,15 @@ function test_sector(I::Type)
     end
 end
 
-smallset(::Type{I}) where {I <: Sector} = take(values(I), 5)
+function smallset(::Type{I}, size::Int = 5) where {I <: Sector}
+    vals = values(I)
+    Base.IteratorSize(vals) === Base.IsInfinite() && return take(vals, size)
+    return if length(vals) > size
+        Random.shuffle(collect(vals))[1:size] # take random size of elements
+    else
+        vals # take all
+    end
+end
 function smallset(::Type{ProductSector{Tuple{I1, I2}}}) where {I1, I2}
     iter = product(smallset(I1), smallset(I2))
     s = collect(i ⊠ j for (i, j) in iter if dim(i) * dim(j) <= 6)
@@ -91,7 +100,26 @@ function randsector(::Type{I}) where {I <: Sector}
 end
 randsector(::Type{I}) where {I <: Union{Trivial, PlanarTrivial}} = unit(I)
 
+"""
+    random_fusion(I::Type, ::Val{N})
+
+Returns a random tuple of `N` sectors from `I` that have a non-empty coupled sector.
+Compatible with any `Sector` type, including those with `UnitStyle(I) == GenericUnit()`.
+"""
+function random_fusion(I::Type{<:Sector}, ::Val{N}) where {N}
+    N == 1 && return (randsector(I),)
+    tail = random_fusion(I, Val(N - 1))
+    s = randsector(I)
+    counter = 0
+    while isempty(⊗(s, first(tail))) && counter < 20
+        counter += 1
+        s = (counter < 20) ? randsector(I) : leftunit(first(tail))
+    end
+    return (s, tail...)
+end
+
 function hasfusiontensor(I::Type{<:Sector})
+    UnitStyle(I) isa SimpleUnit || return false
     try
         fusiontensor(unit(I), unit(I), unit(I))
         return true
@@ -104,6 +132,32 @@ function hasfusiontensor(I::Type{<:Sector})
     end
 end
 
+"""
+    unitarity_test(a::I, b::I, c::I) where {I <: Sector}
+
+Tests the unitarity of the F-symbols for the fusion of `a`, `b`, and `c`.
+Returns `true` if the F-symbols are unitary, and `false` otherwise.
+"""
+function unitarity_test(a::I, b::I, c::I) where {I <: Sector}
+    for d in ⊗(a, b, c)
+        es = collect(intersect(⊗(a, b), map(dual, ⊗(c, dual(d)))))
+        fs = collect(intersect(⊗(b, c), map(dual, ⊗(dual(d), a))))
+        if FusionStyle(I) isa MultiplicityFreeFusion
+            @assert length(es) == length(fs)
+            F = [Fsymbol(a, b, c, d, e, f) for e in es, f in fs]
+        else
+            Fblocks = Vector{Any}()
+            for e in es, f in fs
+                Fs = Fsymbol(a, b, c, d, e, f)
+                push!(Fblocks, reshape(Fs, (size(Fs, 1) * size(Fs, 2), size(Fs, 3) * size(Fs, 4))))
+            end
+            F = hvcat(length(fs), Fblocks...)
+        end
+        isapprox(F' * F, one(F); atol = 1.0e-12, rtol = 1.0e-12) || return false
+    end
+    return true
+end
+
 include("sectors.jl")
 
 end # module SectorTestSuite