define TrivialSector

Author: ogauthe

NDTensors/src/lib/Sectors/src/Sectors.jl

@@ -5,6 +5,7 @@ include("abstractcategory.jl")
 include("category_definitions/fib.jl")
 include("category_definitions/ising.jl")
 include("category_definitions/o2.jl")
+include("category_definitions/trivial.jl")
 include("category_definitions/su.jl")
 include("category_definitions/su2k.jl")
 include("category_definitions/u1.jl")

NDTensors/src/lib/Sectors/src/category_definitions/trivial.jl

@@ -0,0 +1,34 @@
+#
+# Trivial sector
+#
+
+using ...GradedAxes: GradedAxes
+
+# Trivial is special as it does not have a label
+struct TrivialSector <: AbstractCategory end
+
+SymmetryStyle(::Type{TrivialSector}) = AbelianStyle()
+
+trivial(::Type{TrivialSector}) = TrivialSector()
+
+GradedAxes.dual(::TrivialSector) = TrivialSector()
+
+Base.isless(::TrivialSector, ::TrivialSector) = false  # bypass default that calls label
+
+# TrivialSector acts as trivial on any AbstractCategory
+function fusion_rule(::NotAbelianStyle, ::TrivialSector, c::AbstractCategory)
+  return to_gradedrange(c)
+end
+function fusion_rule(::NotAbelianStyle, c::AbstractCategory, ::TrivialSector)
+  return to_gradedrange(c)
+end
+
+# abelian case: return Category
+fusion_rule(::AbelianStyle, c::AbstractCategory, ::TrivialSector) = c
+fusion_rule(::AbelianStyle, ::TrivialSector, c::AbstractCategory) = c
+fusion_rule(::AbelianStyle, ::TrivialSector, ::TrivialSector) = TrivialSector()
+
+# any trivial sector equals TrivialSector
+Base.:(==)(c::AbstractCategory, ::TrivialSector) = istrivial(c)
+Base.:(==)(::TrivialSector, c::AbstractCategory) = istrivial(c)
+Base.:(==)(::TrivialSector, ::TrivialSector) = true

NDTensors/src/lib/Sectors/src/category_product.jl

@@ -15,9 +15,6 @@ CategoryProduct(c::CategoryProduct) = _CategoryProduct(categories(c))
 
 categories(s::CategoryProduct) = s.cats
 
-const TrivialSector{Categories<:Union{Tuple{},NamedTuple{()}}} = CategoryProduct{Categories}
-TrivialSector() = CategoryProduct(())
-
 # =================================  Sectors interface  ====================================
 SymmetryStyle(T::Type{<:CategoryProduct}) = categories_symmetrystyle(categories_type(T))
 
@@ -99,6 +96,12 @@ function categories_fusion_rule(cats1, cats2)
   return shared_cat × diff_cat
 end
 
+# edge case with empty categories
+categories_fusion_rule(cats::Tuple, ::NamedTuple{()}) = CategoryProduct(cats)
+categories_fusion_rule(::NamedTuple{()}, cats::Tuple) = CategoryProduct(cats)
+categories_fusion_rule(cats::NamedTuple, ::Tuple{}) = CategoryProduct(cats)
+categories_fusion_rule(::Tuple{}, cats::NamedTuple) = CategoryProduct(cats)
+
 function recover_style(T::Type, fused)
   style = categories_symmetrystyle(T)
   return recover_category_product_type(style, T, fused)
@@ -166,6 +169,14 @@ function ×(g1::AbstractUnitRange, g2::AbstractUnitRange)
 end
 
 # ====================================  Fusion rules  ======================================
+# cast AbstractCategory to CategoryProduct
+function fusion_rule(style::SymmetryStyle, c1::CategoryProduct, c2::AbstractCategory)
+  return fusion_rule(style, c1, CategoryProduct(c2))
+end
+function fusion_rule(style::SymmetryStyle, c1::AbstractCategory, c2::CategoryProduct)
+  return fusion_rule(style, CategoryProduct(c1), c2)
+end
+
 # generic case: fusion returns a GradedAxes, even for fusion with Empty
 function fusion_rule(::NotAbelianStyle, s1::CategoryProduct, s2::CategoryProduct)
   return to_gradedrange(categories_fusion_rule(categories(s1), categories(s2)))
@@ -176,30 +187,11 @@ function fusion_rule(::AbelianStyle, s1::CategoryProduct, s2::CategoryProduct)
   return categories_fusion_rule(categories(s1), categories(s2))
 end
 
-# Empty case
-function fusion_rule(::AbelianStyle, ::TrivialSector, ::TrivialSector)
-  return CategoryProduct(())
-end
-
-# TrivialSector acts as trivial on any AbstractCategory, not just CategoryProduct
-function fusion_rule(::NotAbelianStyle, ::TrivialSector, c::AbstractCategory)
-  return to_gradedrange(c)
-end
-function fusion_rule(::NotAbelianStyle, c::AbstractCategory, ::TrivialSector)
-  return to_gradedrange(c)
-end
-function fusion_rule(::NotAbelianStyle, ::TrivialSector, c::CategoryProduct)
-  return to_gradedrange(c)
-end
-function fusion_rule(::NotAbelianStyle, c::CategoryProduct, ::TrivialSector)
-  return to_gradedrange(c)
-end
-
-# abelian case: return Category
-fusion_rule(::AbelianStyle, c::AbstractCategory, ::TrivialSector) = c
-fusion_rule(::AbelianStyle, ::TrivialSector, c::AbstractCategory) = c
+# lift ambiguities for TrivialSector
 fusion_rule(::AbelianStyle, c::CategoryProduct, ::TrivialSector) = c
 fusion_rule(::AbelianStyle, ::TrivialSector, c::CategoryProduct) = c
+fusion_rule(::NotAbelianStyle, c::CategoryProduct, ::TrivialSector) = to_gradedrange(c)
+fusion_rule(::NotAbelianStyle, ::TrivialSector, c::CategoryProduct) = to_gradedrange(c)
 
 # ===============================  Ordered implementation  =================================
 CategoryProduct(t::Tuple) = _CategoryProduct(t)

NDTensors/src/lib/Sectors/test/test_category_product.jl

@@ -7,8 +7,8 @@ using NDTensors.Sectors:
   Ising,
   SU,
   SU2,
-  U1,
   TrivialSector,
+  U1,
   Z,
   block_dimensions,
   categories,
@@ -62,6 +62,13 @@ end
     @test categories(s)[2] == SU2(1//2)
     @test categories(s)[3] == Fib("τ")
     @test (@inferred_latest trivial(s)) == CategoryProduct(U1(0), SU2(0), Fib("1"))
+
+    s = TrivialSector() × U1(3) × SU2(1 / 2)
+    @test length(categories(s)) == 3
+    @test (@inferred_latest quantum_dimension(s)) == 2
+    @test dual(s) == TrivialSector() × U1(-3) × SU2(1//2)
+    @test (@inferred_latest trivial(s)) == CategoryProduct(TrivialSector(), U1(0), SU2(0))
+    @test s > trivial(s)
   end
 
   @testset "Ordered comparisons" begin
@@ -70,6 +77,7 @@ end
     @test CategoryProduct(U1(1), SU2(0)) != CategoryProduct(U1(1), SU2(1))
     @test CategoryProduct(U1(0), SU2(1)) != CategoryProduct(U1(1), SU2(1))
     @test CategoryProduct(U1(1)) != CategoryProduct(U1(1), U1(0))
+    @test CategoryProduct(U1(0), SU2(0)) == TrivialSector()
 
     # convention: categories must have same length to be compared
     @test CategoryProduct(U1(0)) < CategoryProduct((U1(1)))
@@ -135,6 +143,8 @@ end
   @testset "Fusion of Abelian products" begin
     p1 = CategoryProduct(U1(1))
     p2 = CategoryProduct(U1(2))
+    @test (@inferred p1 ⊗ TrivialSector()) == p1
+    @test (@inferred TrivialSector() ⊗ p2) == p2
     @test (@inferred_latest p1 ⊗ p2) == CategoryProduct(U1(3))
 
     p11 = U1(1) × U1(1)
@@ -151,7 +161,12 @@ end
   @testset "Fusion of NonAbelian products" begin
     p0 = CategoryProduct(SU2(0))
     ph = CategoryProduct(SU2(1//2))
-    @test space_isequal((@inferred p0 ⊗ ph), gradedrange([CategoryProduct(SU2(1//2)) => 1]))
+    @test space_isequal(
+      (@inferred p0 ⊗ TrivialSector()), gradedrange([CategoryProduct(SU2(0)) => 1])
+    )
+    @test space_isequal(
+      (@inferred TrivialSector() ⊗ ph), gradedrange([CategoryProduct(SU2(1//2)) => 1])
+    )
 
     phh = SU2(1//2) × SU2(1//2)
     @test space_isequal(
@@ -397,7 +412,7 @@ end
   end
 
   @testset "Fusion of Abelian products" begin
-    q00 = TrivialSector()
+    q00 = CategoryProduct(;)
     q10 = CategoryProduct(; A=U1(1))
     q01 = CategoryProduct(; B=U1(1))
     q11 = CategoryProduct(; A=U1(1), B=U1(1))
@@ -418,7 +433,7 @@ end
   end
 
   @testset "Fusion of NonAbelian products" begin
-    p0 = TrivialSector()
+    p0 = CategoryProduct(;)
     pha = CategoryProduct(; A=SU2(1//2))
     phb = CategoryProduct(; B=SU2(1//2))
     phab = CategoryProduct(; A=SU2(1//2), B=SU2(1//2))
@@ -543,6 +558,7 @@ end
 
 @testset "Empty category" begin
   for s in (CategoryProduct(()), CategoryProduct((;)))
+    @test s == TrivialSector()
     @test s == CategoryProduct(())
     @test s == CategoryProduct((;))
     @test (@inferred dual(s)) == s
@@ -561,13 +577,12 @@ end
     @test (@inferred CategoryProduct(U1(1)) × s) == CategoryProduct(U1(1))
     @test (@inferred CategoryProduct(; A=U1(1)) × s) == CategoryProduct(; A=U1(1))
 
-    # Empty acts as trivial
-    @test (@inferred_latest U1(1) ⊗ s) == U1(1)
-    @test (@inferred SU2(0) ⊗ s) == gradedrange([SU2(0) => 1])
-    @test (@inferred Fib("τ") ⊗ s) == gradedrange([Fib("τ") => 1])
-    @test (@inferred_latest s ⊗ U1(1)) == U1(1)
-    @test (@inferred s ⊗ SU2(0)) == gradedrange([SU2(0) => 1])
-    @test (@inferred s ⊗ Fib("τ")) == gradedrange([Fib("τ") => 1])
+    @test (@inferred_latest U1(1) ⊗ s) == CategoryProduct(U1(1))
+    @test (@inferred SU2(0) ⊗ s) == gradedrange([CategoryProduct(SU2(0)) => 1])
+    @test (@inferred Fib("τ") ⊗ s) == gradedrange([CategoryProduct(Fib("τ")) => 1])
+    @test (@inferred_latest s ⊗ U1(1)) == CategoryProduct(U1(1))
+    @test (@inferred s ⊗ SU2(0)) == gradedrange([CategoryProduct(SU2(0)) => 1])
+    @test (@inferred s ⊗ Fib("τ")) == gradedrange([CategoryProduct(Fib("τ")) => 1])
 
     @test (@inferred_latest CategoryProduct(U1(1)) ⊗ s) == CategoryProduct(U1(1))
     @test (@inferred_latest CategoryProduct(SU2(0)) ⊗ s) ==

NDTensors/src/lib/Sectors/test/test_fusion_rules.jl

@@ -2,7 +2,18 @@
 using NDTensors.GradedAxes:
   dual, fusion_product, space_isequal, gradedrange, flip, tensor_product
 using NDTensors.Sectors:
-  ⊗, Fib, Ising, O2, SU, SU2, U1, Z, block_dimensions, quantum_dimension, trivial
+  ⊗,
+  Fib,
+  Ising,
+  O2,
+  SU,
+  SU2,
+  TrivialSector,
+  U1,
+  Z,
+  block_dimensions,
+  quantum_dimension,
+  trivial
 using Test: @inferred, @test, @testset, @test_throws
 
 @testset "Simple object fusion rules" begin
@@ -15,6 +26,11 @@ using Test: @inferred, @test, @testset, @test_throws
     @test z1 ⊗ z1 == z0
     @test (@inferred z0 ⊗ z0) == z0  # no better way, see Julia PR 23426
 
+    q = TrivialSector()
+    @test (@inferred q ⊗ q) == q
+    @test (@inferred q ⊗ z0) == z0
+    @test (@inferred z1 ⊗ q) == z1
+
     # using GradedAxes interface
     @test space_isequal(fusion_product(z0, z0), gradedrange([z0 => 1]))
     @test space_isequal(fusion_product(z0, z1), gradedrange([z1 => 1]))
@@ -42,6 +58,10 @@ using Test: @inferred, @test, @testset, @test_throws
     s12 = O2(1//2)
     s1 = O2(1)
 
+    q = TrivialSector()
+    @test space_isequal((@inferred s0e ⊗ q), gradedrange([s0e => 1]))
+    @test space_isequal((@inferred q ⊗ s0o), gradedrange([s0o => 1]))
+
     @test space_isequal((@inferred s0e ⊗ s0e), gradedrange([s0e => 1]))
     @test space_isequal((@inferred s0o ⊗ s0e), gradedrange([s0o => 1]))
     @test space_isequal((@inferred s0o ⊗ s0e), gradedrange([s0o => 1]))

NDTensors/src/lib/Sectors/test/test_simple_categories.jl

@@ -6,6 +6,7 @@ using NDTensors.Sectors:
   O2,
   SU,
   SU2,
+  TrivialSector,
   U1,
   Z,
   adjoint,
@@ -15,6 +16,18 @@ using NDTensors.Sectors:
   trivial
 using Test: @inferred, @test, @testset, @test_throws
 @testset "Test Category Types" begin
+  @testset "TrivialSector" begin
+    q = TrivialSector()
+
+    @test (@inferred quantum_dimension(q)) == 1
+    @test q == q
+    @test trivial(q) == q
+    @test istrivial(q)
+
+    @test dual(q) == q
+    @test !isless(q, q)
+  end
+
   @testset "U(1)" begin
     q1 = U1(1)
     q2 = U1(2)
@@ -27,6 +40,8 @@ using Test: @inferred, @test, @testset, @test_throws
     @test trivial(q1) == U1(0)
     @test trivial(U1) == U1(0)
     @test istrivial(U1(0))
+    @test U1(0) == TrivialSector()
+    @test TrivialSector() == U1(0)
 
     @test dual(U1(2)) == U1(-2)
     @test isless(U1(1), U1(2))
@@ -39,6 +54,7 @@ using Test: @inferred, @test, @testset, @test_throws
 
     @test trivial(Z{2}) == Z{2}(0)
     @test istrivial(Z{2}(0))
+    @test Z{2}(0) == TrivialSector()
 
     @test quantum_dimension(z0) == 1
     @test quantum_dimension(z1) == 1
@@ -60,6 +76,7 @@ using Test: @inferred, @test, @testset, @test_throws
 
     @test trivial(O2) == s0e
     @test istrivial(s0e)
+    @test s0e == TrivialSector()
 
     @test (@inferred quantum_dimension(s0e)) == 1
     @test (@inferred quantum_dimension(s0o)) == 1
@@ -90,6 +107,7 @@ using Test: @inferred, @test, @testset, @test_throws
 
     @test trivial(SU{2}) == SU2(0)
     @test istrivial(SU2(0))
+    @test SU2(0) == TrivialSector()
 
     @test fundamental(SU{2}) == SU2(1//2)
     @test adjoint(SU{2}) == SU2(1)
@@ -116,6 +134,8 @@ using Test: @inferred, @test, @testset, @test_throws
     @test istrivial(SU{3}((0, 0)))
     @test trivial(SU{4}) == SU{4}((0, 0, 0))
     @test istrivial(SU{4}((0, 0, 0)))
+    @test SU{3}((0, 0)) == TrivialSector()
+    @test SU{4}((0, 0, 0)) == TrivialSector()
 
     @test fundamental(SU{3}) == f3
     @test adjoint(SU{3}) == ad3
@@ -144,6 +164,7 @@ using Test: @inferred, @test, @testset, @test_throws
 
     @test trivial(Fib) == ı
     @test istrivial(ı)
+    @test ı == TrivialSector()
 
     @test dual(ı) == ı
     @test dual(τ) == τ
@@ -159,6 +180,7 @@ using Test: @inferred, @test, @testset, @test_throws
 
     @test trivial(Ising) == ı
     @test istrivial(ı)
+    @test ı == TrivialSector()
 
     @test dual(ı) == ı
     @test dual(σ) == σ