more tolerant on missing sectors

Author: ogauthe

NDTensors/src/lib/SymmetrySectors/src/sector_product.jl

@@ -58,31 +58,42 @@ end
 # - ordered-like with a Tuple
 # - dictionary-like with a NamedTuple
 
-sectors_isequal(o1::Tuple, o2::Tuple) = (o1 == o2)
+function sectors_isequal(s1, s2)
+  return ==(sym_sectors_insert_unspecified(s1, s2)...)
+end
+
+# get clean results when mixing implementations
 function sectors_isequal(nt::NamedTuple, ::Tuple{})
   return sectors_isequal(nt, (;))
 end
 function sectors_isequal(::Tuple{}, nt::NamedTuple)
   return sectors_isequal((;), nt)
 end
-function sectors_isequal(nt1::NamedTuple, nt2::NamedTuple)
-  return ==(sym_sectors_insert_unspecified(nt1, nt2)...)
+function sectors_isequal(::NamedTuple{()}, t::Tuple)
+  return sectors_isequal((), t)
 end
-
-# get clean results when mixing implementations
+function sectors_isequal(t::Tuple, ::NamedTuple{()})
+  return sectors_isequal(t, ())
+end
+sectors_isequal(::Tuple{}, ::NamedTuple{()}) = true
+sectors_isequal(::NamedTuple{()}, ::Tuple{}) = true
 sectors_isequal(::Tuple, ::NamedTuple) = false
 sectors_isequal(::NamedTuple, ::Tuple) = false
 
-sectors_isless(::Tuple, ::Tuple) = throw(ArgumentError("Not implemented"))
-sectors_isless(t1::T, t2::T) where {T<:Tuple} = t1 < t2
 function sectors_isless(nt::NamedTuple, ::Tuple{})
   return sectors_isless(nt, (;))
 end
 function sectors_isless(::Tuple{}, nt::NamedTuple)
   return sectors_isless((;), nt)
 end
-function sectors_isless(nt1::NamedTuple, nt2::NamedTuple)
-  return isless(sym_sectors_insert_unspecified(nt1, nt2)...)
+function sectors_isless(::NamedTuple{()}, t::Tuple)
+  return sectors_isless((), t)
+end
+function sectors_isless(t::Tuple, ::NamedTuple{()})
+  return sectors_isless(t, ())
+end
+function sectors_isless(s1, s2)
+  return isless(sym_sectors_insert_unspecified(s1, s2)...)
 end
 
 sectors_isless(::NamedTuple, ::Tuple) = throw(ArgumentError("Not implemented"))
@@ -223,6 +234,12 @@ function shared_sectors_fusion_rule(shared1::T, shared2::T) where {T<:Tuple}
   return recover_style(T, fused)
 end
 
+function sym_sectors_insert_unspecified(t1::Tuple, t2::Tuple)
+  n1 = length(t1)
+  n2 = length(t2)
+  return (t1..., trivial.(t2[(n1 + 1):end])...), (t2..., trivial.(t1[(n2 + 1):end])...)
+end
+
 # ===========================  Dictionary-like implementation  =============================
 function SectorProduct(nt::NamedTuple)
   sectors = sort_keys(nt)

NDTensors/src/lib/SymmetrySectors/test/test_sector_product.jl

@@ -71,17 +71,22 @@ end
   end
 
   @testset "Ordered comparisons" begin
-    # convention: sectors must have same length to evaluate as equal
+    # convention: missing sectors are filled with singlets
     @test SectorProduct(U1(1), SU2(1)) == SectorProduct(U1(1), SU2(1))
     @test SectorProduct(U1(1), SU2(0)) != SectorProduct(U1(1), SU2(1))
     @test SectorProduct(U1(0), SU2(1)) != SectorProduct(U1(1), SU2(1))
-    @test SectorProduct(U1(1)) != SectorProduct(U1(1), U1(0))
+    @test SectorProduct(U1(1)) != U1(1)
+    @test SectorProduct(U1(1)) == SectorProduct(U1(1), U1(0))
+    @test SectorProduct(U1(1)) != SectorProduct(U1(1), U1(1))
     @test SectorProduct(U1(0), SU2(0)) == TrivialSector()
+    @test SectorProduct(U1(0), SU2(0)) == SectorProduct(TrivialSector(), SU2(0))
+    @test SectorProduct(U1(0), SU2(0)) == SectorProduct(U1(0), TrivialSector())
+    @test SectorProduct(U1(0), SU2(0)) == SectorProduct(TrivialSector(), TrivialSector())
 
-    # convention: sectors must have same length to be compared
     @test SectorProduct(U1(0)) < SectorProduct((U1(1)))
     @test SectorProduct(U1(0), U1(2)) < SectorProduct((U1(1)), U1(0))
-    @test_throws ArgumentError SectorProduct(U1(0)) < SectorProduct(U1(1), U1(2))
+    @test SectorProduct(U1(0)) < SectorProduct(U1(0), U1(1))
+    @test SectorProduct(U1(0)) > SectorProduct(U1(0), U1(-1))
   end
 
   @testset "Quantum dimension and GradedUnitRange" begin
@@ -596,13 +601,13 @@ end
 
     # Empty behaves as empty NamedTuple
     @test s != U1(0)
-    @test s != SectorProduct(U1(0))
+    @test s == SectorProduct(U1(0))
     @test s != SectorProduct(; A=U1(1))
     @test s == SectorProduct(; A=U1(0))
     @test SectorProduct(; A=U1(0)) == s
 
     @test !(s < s)
-    @test_throws ArgumentError s < SectorProduct(U1(0))
+    @test s < SectorProduct(U1(1))
     @test s < SectorProduct(; A=U1(1))
     @test s > SectorProduct(; A=U1(-1))
     @test !(s < SectorProduct(; A=U1(0)))