Make testsuite compatible with multifusion categories (#71)

* make testsuite compatible with multifusion cats

* add unitarity test

* change test to assert

* clean up additional multifusion tests

* typo

* fix timereversed product sector values iteration

* edit deligne product test

* isingbimodule is not in base

* fix `sectorscalartype` of product sector + bring back relevant test

* remove `allunits` condition

* edit iterating over time-reversed product scetor

* make `smallset` type-stable

* `random_fusion` vector output

* relax default size for smallset

* check colorings where relevant

* rename unitarity test

* fusiontensor edit

* `eval_module` function for parse-show tests

* format

* remove commented code

* remove eval_module

* `can_fuse` for readability

* value iterator suggestion

* export `can_fuse` and remove unused import

* bump version

---------

Co-authored-by: Lukas Devos <ldevos98@gmail.com>

Author: borisdevos

Project.toml

@@ -1,7 +1,7 @@
 name = "TensorKitSectors"
 uuid = "13a9c161-d5da-41f0-bcbd-e1a08ae0647f"
 authors = ["Lukas Devos", "Jutho Haegeman"]
-version = "0.3.6"
+version = "0.3.7"
 
 [deps]
 HalfIntegers = "f0d1745a-41c9-11e9-1dd9-e5d34d218721"

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

@@ -23,6 +23,8 @@ const sectorlist = (
     ZNElement{6, 0}, ZNElement{6, 1}, ZNElement{6, 3},
     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},
@@ -85,8 +87,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,20 +3,27 @@ using LinearAlgebra
 using TensorKitSectors: TensorKitSectors as TKS
 
 @testsuite "Basic properties" I -> begin
-    s = (randsector(I), randsector(I), randsector(I))
-    @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...)
+    s = random_fusion(I, 2)
+    sc = @testinferred(first(⊗(s...)))
+    @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, 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)
@@ -30,8 +37,6 @@ using TensorKitSectors: TensorKitSectors as TKS
             @test eltype(F) <: @testinferred sectorscalartype(I)
         end
     end
-    @testinferred(s[1] ⊗ s[2])
-    @testinferred(⊗(s..., s...))
 end
 
 @testsuite "Show and parse" I -> begin
@@ -48,24 +53,25 @@ end
 
 @testsuite "Value iterator" I -> begin
     @test eltype(values(I)) == I
-    sprev = unit(I)
-    for (i, s) in enumerate(values(I))
+    sprev, rest = Iterators.peel(values(I))
+    i = 1
+    @test (@testinferred findindex(values(I), sprev)) == i
+    for s in rest
+        i += 1
         @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
     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)
+        can_fuse(a, b) || continue
         da = dim(a)
         db = dim(b)
         dc = sum(c -> dim(c) * Nsymbol(a, b, c), a ⊗ b)
@@ -178,8 +184,12 @@ end
 end
 
 @testsuite "Unitarity of F-move" I -> begin
-    for a in smallset(I), b in smallset(I), c in smallset(I)
-        @test F_unitarity_test(a, b, c; atol = 1.0e-12, rtol = 1.0e-12)
+    for a in smallset(I), b in smallset(I)
+        can_fuse(a, b) || continue
+        for c in smallset(I)
+            can_fuse(b, c) || continue
+            @test F_unitarity_test(a, b, c; atol = 1.0e-12, rtol = 1.0e-12)
+        end
     end
 end
 
@@ -192,13 +202,21 @@ end
 
 @testsuite "Triangle equation" I -> begin
     for a in smallset(I), b in smallset(I)
+        can_fuse(a, b) || continue
         @test triangle_equation(a, b; atol = 1.0e-12, rtol = 1.0e-12)
     end
 end
 
 @testsuite "Pentagon equation" I -> begin
-    for a in smallset(I), b in smallset(I), c in smallset(I), d in smallset(I)
-        @test pentagon_equation(a, b, c, d; atol = 1.0e-12, rtol = 1.0e-12)
+    for a in smallset(I), b in smallset(I)
+        can_fuse(a, b) || continue
+        for c in smallset(I)
+            can_fuse(b, c) || continue
+            for d in smallset(I)
+                can_fuse(c, d) || continue
+                @test pentagon_equation(a, b, c, d; atol = 1.0e-12, rtol = 1.0e-12)
+            end
+        end
     end
 end
 

test/testsuite.jl

@@ -20,19 +20,23 @@ SectorTestSuite.test_sector(MySectorType)
 Additionally, this test suite exports the following convenience testing utilities:
 * [`smallset`](@ref)
 * [`randsector`](@ref)
+* [`random_fusion`](@ref)
 * [`hasfusiontensor`](@ref)
+* [`F_unitarity_test`](@ref)
 * [`R_unitarity_test`](@ref)
+* [`can_fuse`](@ref)
 """
 module SectorTestSuite
 
-export smallset, randsector, hasfusiontensor, F_unitarity_test, R_unitarity_test
+export smallset, randsector, random_fusion, hasfusiontensor, can_fuse
+export F_unitarity_test, R_unitarity_test
 
 using Test
 using TestExtras
 using TensorKitSectors
 using TensorKitSectors: type_repr
 using Random
-using Base.Iterators: take, product
+using Base.Iterators: take
 
 const tests = Dict()
 
@@ -86,9 +90,41 @@ function randsector(::Type{I}) where {I <: Sector}
 end
 randsector(::Type{I}) where {I <: Union{Trivial, PlanarTrivial}} = unit(I)
 
+"""
+    can_fuse(a::I, b::I) where {I <: Sector}
+
+Returns a boolean indicating whether the fusion of `a` and `b` is allowed,
+i.e. whether there exists a sector `c` such that `c ∈ ⊗(a, b)`.
+"""
+can_fuse(a::I, b::I) where {I <: Sector} = !isempty(⊗(a, b))
+
+"""
+    random_fusion(I::Type, N::Int)
+
+Returns a vector of `N` random 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}, N::Int)
+    vec = Vector{I}(undef, N)
+    vec[1] = randsector(I)
+    N == 1 && return vec
+    for i in 2:N
+        s = randsector(I)
+        sprev = vec[i - 1]
+        counter = 0
+        while !can_fuse(sprev, s) && counter < 20
+            counter += 1
+            s = (counter < 20) ? randsector(I) : rightunit(sprev)
+        end
+        vec[i] = s
+    end
+    return vec
+end
+
 function hasfusiontensor(I::Type{<:Sector})
     try
-        fusiontensor(unit(I), unit(I), unit(I))
+        u = first(allunits(I))
+        fusiontensor(u, u, u)
         return true
     catch e
         if e isa MethodError