IsingBimodule for testing multifusion category within TensorKit

Project.toml

@@ -49,11 +49,10 @@ ChainRulesTestUtils = "cdddcdb0-9152-4a09-a978-84456f9df70a"
 Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
 FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-TensorKitSectors = "13a9c161-d5da-41f0-bcbd-e1a08ae0647f"
 TensorOperations = "6aa20fa7-93e2-5fca-9bc0-fbd0db3c71a2"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 TestExtras = "5ed8adda-3752-4e41-b88a-e8b09835ee3a"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [targets]
-test = ["Aqua", "Combinatorics", "LinearAlgebra", "TensorKitSectors", "TensorOperations", "Test", "TestExtras", "ChainRulesCore", "ChainRulesTestUtils", "FiniteDifferences", "Zygote"]
+test = ["Aqua", "Combinatorics", "LinearAlgebra", "TensorOperations", "Test", "TestExtras", "ChainRulesCore", "ChainRulesTestUtils", "FiniteDifferences", "Zygote"]

src/TensorKit.jl

@@ -15,7 +15,8 @@ export BraidingStyle, SymmetricBraiding, Bosonic, Fermionic, Anyonic, NoBraiding
 export Trivial, Z2Irrep, Z3Irrep, Z4Irrep, ZNIrrep, U1Irrep, SU2Irrep, CU1Irrep
 export ProductSector
 export FermionParity, FermionNumber, FermionSpin
-export FibonacciAnyon, IsingAnyon, IsingBimod
+export FibonacciAnyon, IsingAnyon, IsingBimodule
+export leftone, rightone
 
 export VectorSpace, Field, ElementarySpace # abstract vector spaces
 export InnerProductStyle, NoInnerProduct, HasInnerProduct, EuclideanInnerProduct
@@ -228,7 +229,7 @@ include("planar/planaroperations.jl")
 # deprecations: to be removed in version 1.0 or sooner
 include("auxiliary/deprecate.jl")
 
-# Additional methods for IsingBimod Sector
+# Additional methods for IsingBimodule Sector
 # ----------------------------------------
 include("spaces/multifusionspace.jl")
 

src/fusiontrees/manipulations.jl

@@ -835,15 +835,13 @@ function artin_braid(f::FusionTree{I,N}, i; inv::Bool=false) where {I<:Sector,N}
     vertices = f.vertices
     oneT = one(sectorscalartype(I))
 
-    diaga = a == leftone(a) == rightone(a) # might be excessive because multifusion doesn't support braiding currently
-    diagb = b == leftone(b) == rightone(b)
-    if diaga || diagb
+    if isone(a) || isone(b)
         # braiding with trivial sector: simple and always possible
         inner′ = inner
         vertices′ = vertices
         if i > 1 # we also need to alter innerlines and vertices
             inner′ = TupleTools.setindex(inner,
-                                         inner_extended[diaga ? (i + 1) : (i - 1)],
+                                         inner_extended[isone(a) ? (i + 1) : (i - 1)],
                                          i - 1)
             vertices′ = TupleTools.setindex(vertices′, vertices[i], i - 1)
             vertices′ = TupleTools.setindex(vertices′, vertices[i - 1], i)

src/spaces/gradedspace.jl

@@ -139,21 +139,15 @@ Base.oneunit(S::Type{<:GradedSpace{I}}) where {I<:Sector} = S(one(I) => 1)
 Return the corresponding vector space of type `GradedSpace{I}` that represents the trivial
 one-dimensional space consisting of the left unit of the objects in  `Sector` `I`.
 """
-function leftoneunit(S::GradedSpace{I}) where {I<:Sector}
-    sector = leftone(first(sectors(S)))
-    return spacetype(S)(sector => 1)
-end
+leftoneunit(S::GradedSpace{I}) where {I<:Sector} = oneunit(typeof(S))
 
 """
     rightoneunit(S::GradedSpace{I}) where {I<:Sector} -> GradedSpace{I}
 
 Return the corresponding vector space of type `GradedSpace{I}` that represents the trivial
 one-dimensional space consisting of the right unit of the objects in `Sector` `I`.
 """
-function rightoneunit(S::GradedSpace{I}) where {I<:Sector}
-    sector = rightone(first(sectors(S)))
-    return spacetype(S)(sector => 1)
-end
+rightoneunit(S::GradedSpace{I}) where {I<:Sector} = oneunit(typeof(S))
 
 Base.zero(S::Type{<:GradedSpace{I}}) where {I<:Sector} = S(one(I) => 0)
 

src/spaces/multifusionspace.jl

@@ -1,22 +1,23 @@
-# additional interface to deal with IsingBimod Sector
+# additional interface to deal with IsingBimodule Sector
 #------------------------------------------------------------------------------
 
-# make this a separate module?
-
-function dim(V::Vect[IsingBimod])
+function dim(V::Vect[IsingBimodule])
     T = Base.promote_op(*, Int, real(sectorscalartype(sectortype(V))))
     return reduce(+, dim(V, c) * dim(c) for c in sectors(V);
                   init=zero(T))
 end
 
-function scalar(t::AbstractTensorMap{T,Vect[IsingBimod],0,0}) where {T}
+function scalar(t::AbstractTensorMap{T,Vect[IsingBimodule],0,0}) where {T}
     Bs = collect(blocks(t))
     inds = findall(!iszero ∘ last, Bs)
     isempty(inds) && return zero(scalartype(t))
     return only(last(Bs[only(inds)]))
 end
 
-function Base.oneunit(S::Vect[IsingBimod])
+# no custom fuse: we choose to return empty graded space when fusion is forbidden
+
+function Base.oneunit(S::Vect[IsingBimodule])
+    !isempty(sectors(S)) || throw(ArgumentError("Cannot determine type of empty space"))
     allequal(a.row for a in sectors(S)) && allequal(a.col for a in sectors(S)) ||
         throw(ArgumentError("sectors of $S are not all equal"))
     first(sectors(S)).row == first(sectors(S)).col ||
@@ -25,43 +26,45 @@ function Base.oneunit(S::Vect[IsingBimod])
     return spacetype(S)(sector => 1)
 end
 
-Base.zero(S::Type{Vect[IsingBimod]}) = Vect[IsingBimod]()
+Base.zero(S::Type{Vect[IsingBimodule]}) = Vect[IsingBimodule]()
 
-function blocksectors(W::TensorMapSpace{Vect[IsingBimod],N₁,N₂}) where {N₁,N₂}
+function blocksectors(W::TensorMapSpace{Vect[IsingBimodule],N₁,N₂}) where {N₁,N₂}
     codom = codomain(W)
     dom = domain(W)
     if N₁ == 0 && N₂ == 0
-        return (IsingBimod(1, 1, 0), IsingBimod(2, 2, 0))
+        return [IsingBimodule(1, 1, 0), IsingBimodule(2, 2, 0)]
     elseif N₁ == 0
-        @assert N₂ != 0 "one of Type IsingBimod doesn't exist"
-        return filter!(c -> c == leftone(c) == rightone(c), collect(blocksectors(dom))) # is this what we want? doesn't allow M/Mop to end at empty space
+        @assert N₂ != 0 "one of Type IsingBimodule doesn't exist"
+        return filter!(isone, collect(blocksectors(dom))) # is this what we want? doesn't allow M/Mop to end at empty space
     elseif N₂ == 0
-        @assert N₁ != 0 "one of Type IsingBimod doesn't exist"
-        return filter!(c -> c == leftone(c) == rightone(c), collect(blocksectors(codom)))
+        @assert N₁ != 0 "one of Type IsingBimodule doesn't exist"
+        return filter!(isone, collect(blocksectors(codom)))
     elseif N₂ <= N₁ # keep intersection
         return filter!(c -> hasblock(codom, c), collect(blocksectors(dom)))
     else
         return filter!(c -> hasblock(dom, c), collect(blocksectors(codom)))
     end
 end
 
-function rightoneunit(S::Vect[IsingBimod])
+function rightoneunit(S::Vect[IsingBimodule])
+    !isempty(sectors(S)) || throw(ArgumentError("Cannot determine type of empty space"))
     allequal(a.col for a in sectors(S)) ||
         throw(ArgumentError("sectors of $S do not have the same rightone"))
 
     sector = rightone(first(sectors(S)))
     return spacetype(S)(sector => 1)
 end
 
-function leftoneunit(S::Vect[IsingBimod])
+function leftoneunit(S::Vect[IsingBimodule])
+    !isempty(sectors(S)) || throw(ArgumentError("Cannot determine type of empty space"))
     allequal(a.row for a in sectors(S)) ||
         throw(ArgumentError("sectors of $S do not have the same leftone"))
 
     sector = leftone(first(sectors(S)))
     return spacetype(S)(sector => 1)
 end
 
-function insertrightunit(P::ProductSpace{Vect[IsingBimod],N}, ::Val{i};
+function insertrightunit(P::ProductSpace{Vect[IsingBimodule],N}, ::Val{i};
                          conj::Bool=false,
                          dual::Bool=false) where {i,N}
     i > N && error("cannot insert a sensible right unit onto $P at index $(i+1)")
@@ -77,7 +80,7 @@ function insertrightunit(P::ProductSpace{Vect[IsingBimod],N}, ::Val{i};
 end
 
 # TODO?: overwrite defaults at level of HomSpace and TensorMap?
-function insertleftunit(P::ProductSpace{Vect[IsingBimod],N}, ::Val{i}; # want no defaults?
+function insertleftunit(P::ProductSpace{Vect[IsingBimodule],N}, ::Val{i}; # want no defaults?
                         conj::Bool=false,
                         dual::Bool=false) where {i,N}
     i > N && error("cannot insert a sensible left unit onto $P at index $i") # do we want this to error in the diagonal case?
@@ -91,9 +94,9 @@ function insertleftunit(P::ProductSpace{Vect[IsingBimod],N}, ::Val{i}; # want no
     return ProductSpace(TupleTools.insertafter(P.spaces, i - 1, (u,)))
 end
 
-# is this even necessary? can let it error at fusiontrees.jl:93 from the one(IsingBimod) call
+# is this even necessary? can let it error at fusiontrees.jl:93 from the one(IsingBimodule) call
 # but these errors are maybe more informative
-function FusionTree(uncoupled::Tuple{IsingBimod,Vararg{IsingBimod}})
+function FusionTree(uncoupled::Tuple{IsingBimodule,Vararg{IsingBimodule}})
     coupled = collect(⊗(uncoupled...))
     if length(coupled) == 0 # illegal fusion somewhere
         throw(ArgumentError("Forbidden fusion with uncoupled sectors $uncoupled"))
@@ -103,6 +106,6 @@ function FusionTree(uncoupled::Tuple{IsingBimod,Vararg{IsingBimod}})
 end
 
 # this one might also be overkill, since `FusionTreeIterator`s don't check whether the fusion is allowed
-function fusiontrees(uncoupled::Tuple{IsingBimod,Vararg{IsingBimod}})
-    return throw(ArgumentError("coupled sector must be provided for IsingBimod fusion"))
+function fusiontrees(uncoupled::Tuple{IsingBimodule,Vararg{IsingBimodule}})
+    return throw(ArgumentError("coupled sector must be provided for IsingBimodule fusion"))
 end

test/multifusion.jl

@@ -1,4 +1,4 @@
-I = IsingBimod
+I = IsingBimodule
 Istr = TK.type_repr(I)
 
 println("------------------------------------")
@@ -85,9 +85,16 @@ VIBMop2 = (Vect[I](D0 => 1, D1 => 1),
         @test @constinferred(rightoneunit(⊕(Wright, WM))) == oneunit(Wright)
         @test @constinferred(rightoneunit(⊕(Wleft, WMop))) == oneunit(Wleft)
 
-        @test_throws ArgumentError oneunit(I)
-        @test_throws ArgumentError oneunit(WM)
-        @test_throws ArgumentError oneunit(WMop)
+        @test_throws ArgumentError("one of Type IsingBimodule doesn't exist") oneunit(I)
+        @test_throws ArgumentError("sectors of $WM are non-diagonal") oneunit(WM)
+        @test_throws ArgumentError("sectors of $WMop are non-diagonal") oneunit(WMop)
+
+        # empty space
+        Wempty = Vect[I]()
+        @test @constinferred(zero(V)) == Wempty
+        for f in (oneunit, leftoneunit, rightoneunit)
+            @test_throws ArgumentError("Cannot determine type of empty space") f(Wempty)
+        end
 
         @test isa(V, VectorSpace)
         @test isa(V, ElementarySpace)
@@ -671,9 +678,9 @@ for V in (VIBC, VIBD)
     @assert V3 * V4 ≾ V1' * V2' * V5' # necessary for rightorth tests -> this condition makes it hard to test non-diagonal sectors
 end
 
-@timedtestset "Tensors with symmetry: $Istr" verbose = true for V in
-                                                                (VIBC, VIBD, VIBM1, VIBM2,
-                                                                 VIBMop1, VIBMop2)
+@timedtestset "Tensors with symmetry: $Istr $i" verbose = true for (i, V) in
+                                                                enumerate((VIBC, VIBD, VIBM1, VIBM2,
+                                                                 VIBMop1, VIBMop2))
     V1, V2, V3, V4, V5 = V
     @timedtestset "Basic tensor properties" begin
         W = V1 ⊗ V2 ⊗ V3 ⊗ V4 ⊗ V5 # fusion matters

test/runtests.jl

@@ -4,8 +4,6 @@ using Random
 using TensorKit
 using Combinatorics
 using TensorKit: ProductSector, fusiontensor
-using TensorKitSectors
-using TensorKitSectors: leftone, rightone
 using TensorOperations
 using Base.Iterators: take, product
 # using SUNRepresentations: SUNIrrep
@@ -31,7 +29,7 @@ end
 function randsector(::Type{I}) where {I<:Sector}
     s = collect(smallset(I))
     a = rand(s)
-    while a == leftone(a) == rightone(a) # don't use trivial label
+    while isone(a) # don't use trivial label
         a = rand(s)
     end
     return a

test/spaces.jl

@@ -211,6 +211,8 @@ println("------------------------------------")
         @test @constinferred(oneunit(V)) == W == oneunit(typeof(V))
         @test @constinferred(leftoneunit(V)) == oneunit(V) ==
               @constinferred(rightoneunit(V))
+        Vempty = @constinferred zero(V)
+        @test oneunit(Vempty) == leftoneunit(Vempty) == rightoneunit(Vempty) == W
         @test @constinferred(zero(V)) == GradedSpace(one(I) => 0)
         # randsector never returns trivial sector, so this cannot error
         @test_throws ArgumentError GradedSpace(one(I) => 1, randsector(I) => 0, one(I) => 3)