rename sectors product_sectors

Author: ogauthe

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

@@ -7,38 +7,40 @@ using ..GradedAxes: AbstractGradedUnitRange, GradedAxes, dual
 
 # =====================================  Definition  =======================================
 struct SectorProduct{Sectors} <: AbstractSector
-  sectors::Sectors
+  product_sectors::Sectors
   global _SectorProduct(l) = new{typeof(l)}(l)
 end
 
-SectorProduct(c::SectorProduct) = _SectorProduct(sectors(c))
+SectorProduct(c::SectorProduct) = _SectorProduct(product_sectors(c))
 
-sectors(s::SectorProduct) = s.sectors
+product_sectors(s::SectorProduct) = s.product_sectors
 
 # =================================  Sectors interface  ====================================
-SymmetryStyle(T::Type{<:SectorProduct}) = sectors_symmetrystyle(sectors_type(T))
+function SymmetryStyle(T::Type{<:SectorProduct})
+  return product_sectors_symmetrystyle(product_sectors_type(T))
+end
 
 function quantum_dimension(::NotAbelianStyle, s::SectorProduct)
-  return mapreduce(quantum_dimension, *, sectors(s))
+  return mapreduce(quantum_dimension, *, product_sectors(s))
 end
 
 # use map instead of broadcast to support both Tuple and NamedTuple
-GradedAxes.dual(s::SectorProduct) = SectorProduct(map(dual, sectors(s)))
+GradedAxes.dual(s::SectorProduct) = SectorProduct(map(dual, product_sectors(s)))
 
 function trivial(type::Type{<:SectorProduct})
-  return SectorProduct(sectors_trivial(sectors_type(type)))
+  return SectorProduct(product_sectors_trivial(product_sectors_type(type)))
 end
 
 # ===================================  Base interface  =====================================
 function Base.:(==)(A::SectorProduct, B::SectorProduct)
-  return sectors_isequal(sectors(A), sectors(B))
+  return product_sectors_isequal(product_sectors(A), product_sectors(B))
 end
 
 function Base.show(io::IO, s::SectorProduct)
-  (length(sectors(s)) < 2) && print(io, "sector")
+  (length(product_sectors(s)) < 2) && print(io, "sector")
   print(io, "(")
   symbol = ""
-  for p in pairs(sectors(s))
+  for p in pairs(product_sectors(s))
     print(io, symbol)
     sector_show(io, p[1], p[2])
     symbol = " × "
@@ -50,75 +52,78 @@ sector_show(io::IO, ::Int, v) = print(io, v)
 sector_show(io::IO, k::Symbol, v) = print(io, "($k=$v,)")
 
 function Base.isless(s1::SectorProduct, s2::SectorProduct)
-  return sectors_isless(sectors(s1), sectors(s2))
+  return product_sectors_isless(product_sectors(s1), product_sectors(s2))
 end
 
 # =======================================  shared  =========================================
 # there are 2 implementations for SectorProduct
 # - ordered-like with a Tuple
 # - dictionary-like with a NamedTuple
 
-function sym_sectors_insert_unspecified(s1, s2)
-  return sectors_insert_unspecified(s1, s2), sectors_insert_unspecified(s2, s1)
+function sym_product_sectors_insert_unspecified(s1, s2)
+  return product_sectors_insert_unspecified(s1, s2),
+  product_sectors_insert_unspecified(s2, s1)
 end
 
-function sectors_isequal(s1, s2)
-  return ==(sym_sectors_insert_unspecified(s1, s2)...)
+function product_sectors_isequal(s1, s2)
+  return ==(sym_product_sectors_insert_unspecified(s1, s2)...)
 end
 
 # get clean results when mixing implementations
-function sectors_isequal(nt::NamedTuple, ::Tuple{})
-  return sectors_isequal(nt, (;))
+function product_sectors_isequal(nt::NamedTuple, ::Tuple{})
+  return product_sectors_isequal(nt, (;))
 end
-function sectors_isequal(::Tuple{}, nt::NamedTuple)
-  return sectors_isequal((;), nt)
+function product_sectors_isequal(::Tuple{}, nt::NamedTuple)
+  return product_sectors_isequal((;), nt)
 end
-function sectors_isequal(::NamedTuple{()}, t::Tuple)
-  return sectors_isequal((), t)
+function product_sectors_isequal(::NamedTuple{()}, t::Tuple)
+  return product_sectors_isequal((), t)
 end
-function sectors_isequal(t::Tuple, ::NamedTuple{()})
-  return sectors_isequal(t, ())
+function product_sectors_isequal(t::Tuple, ::NamedTuple{()})
+  return product_sectors_isequal(t, ())
 end
-sectors_isequal(::Tuple{}, ::NamedTuple{()}) = true
-sectors_isequal(::NamedTuple{()}, ::Tuple{}) = true
-sectors_isequal(::Tuple, ::NamedTuple) = false
-sectors_isequal(::NamedTuple, ::Tuple) = false
+product_sectors_isequal(::Tuple{}, ::NamedTuple{()}) = true
+product_sectors_isequal(::NamedTuple{()}, ::Tuple{}) = true
+product_sectors_isequal(::Tuple, ::NamedTuple) = false
+product_sectors_isequal(::NamedTuple, ::Tuple) = false
 
-function sectors_isless(nt::NamedTuple, ::Tuple{})
-  return sectors_isless(nt, (;))
+function product_sectors_isless(nt::NamedTuple, ::Tuple{})
+  return product_sectors_isless(nt, (;))
 end
-function sectors_isless(::Tuple{}, nt::NamedTuple)
-  return sectors_isless((;), nt)
+function product_sectors_isless(::Tuple{}, nt::NamedTuple)
+  return product_sectors_isless((;), nt)
 end
-function sectors_isless(::NamedTuple{()}, t::Tuple)
-  return sectors_isless((), t)
+function product_sectors_isless(::NamedTuple{()}, t::Tuple)
+  return product_sectors_isless((), t)
 end
-function sectors_isless(t::Tuple, ::NamedTuple{()})
-  return sectors_isless(t, ())
+function product_sectors_isless(t::Tuple, ::NamedTuple{()})
+  return product_sectors_isless(t, ())
 end
-function sectors_isless(s1, s2)
-  return isless(sym_sectors_insert_unspecified(s1, s2)...)
+function product_sectors_isless(s1, s2)
+  return isless(sym_product_sectors_insert_unspecified(s1, s2)...)
 end
 
-sectors_isless(::NamedTuple, ::Tuple) = throw(ArgumentError("Not implemented"))
-sectors_isless(::Tuple, ::NamedTuple) = throw(ArgumentError("Not implemented"))
+product_sectors_isless(::NamedTuple, ::Tuple) = throw(ArgumentError("Not implemented"))
+product_sectors_isless(::Tuple, ::NamedTuple) = throw(ArgumentError("Not implemented"))
 
-sectors_type(::Type{<:SectorProduct{T}}) where {T} = T
+product_sectors_type(::Type{<:SectorProduct{T}}) where {T} = T
 
-function sectors_fusion_rule(sects1, sects2)
-  shared_sect = shared_sectors_fusion_rule(sectors_common(sects1, sects2)...)
-  diff_sect = SectorProduct(sectors_diff(sects1, sects2))
+function product_sectors_fusion_rule(sects1, sects2)
+  shared_sect = shared_product_sectors_fusion_rule(
+    product_sectors_common(sects1, sects2)...
+  )
+  diff_sect = SectorProduct(product_sectors_diff(sects1, sects2))
   return shared_sect × diff_sect
 end
 
-# edge case with empty sectors
-sectors_fusion_rule(sects::Tuple, ::NamedTuple{()}) = SectorProduct(sects)
-sectors_fusion_rule(::NamedTuple{()}, sects::Tuple) = SectorProduct(sects)
-sectors_fusion_rule(sects::NamedTuple, ::Tuple{}) = SectorProduct(sects)
-sectors_fusion_rule(::Tuple{}, sects::NamedTuple) = SectorProduct(sects)
+# edge case with empty product_sectors
+product_sectors_fusion_rule(sects::Tuple, ::NamedTuple{()}) = SectorProduct(sects)
+product_sectors_fusion_rule(::NamedTuple{()}, sects::Tuple) = SectorProduct(sects)
+product_sectors_fusion_rule(sects::NamedTuple, ::Tuple{}) = SectorProduct(sects)
+product_sectors_fusion_rule(::Tuple{}, sects::NamedTuple) = SectorProduct(sects)
 
 function recover_style(T::Type, fused)
-  style = sectors_symmetrystyle(T)
+  style = product_sectors_symmetrystyle(T)
   return recover_sector_product_type(style, T, fused)
 end
 
@@ -146,11 +151,11 @@ function recover_sector_product_type(T::Type, c::AbstractSector)
 end
 
 function recover_sector_product_type(T::Type, c::SectorProduct)
-  return recover_sector_product_type(T, sectors(c))
+  return recover_sector_product_type(T, product_sectors(c))
 end
 
 function recover_sector_product_type(T::Type{<:SectorProduct}, sects)
-  return recover_sector_product_type(sectors_type(T), sects)
+  return recover_sector_product_type(product_sectors_type(T), sects)
 end
 
 function recover_sector_product_type(T::Type, sects)
@@ -160,7 +165,7 @@ end
 # =================================  Cartesian Product  ====================================
 ×(c1::AbstractSector, c2::AbstractSector) = ×(SectorProduct(c1), SectorProduct(c2))
 function ×(p1::SectorProduct, p2::SectorProduct)
-  return SectorProduct(sectors_product(sectors(p1), sectors(p2)))
+  return SectorProduct(product_sectors_product(product_sectors(p1), product_sectors(p2)))
 end
 
 ×(a, g::AbstractUnitRange) = ×(to_gradedrange(a), g)
@@ -194,12 +199,14 @@ end
 
 # generic case: fusion returns a GradedAxes, even for fusion with Empty
 function fusion_rule(::NotAbelianStyle, s1::SectorProduct, s2::SectorProduct)
-  return to_gradedrange(sectors_fusion_rule(sectors(s1), sectors(s2)))
+  return to_gradedrange(
+    product_sectors_fusion_rule(product_sectors(s1), product_sectors(s2))
+  )
 end
 
 # Abelian case: fusion returns SectorProduct
 function fusion_rule(::AbelianStyle, s1::SectorProduct, s2::SectorProduct)
-  return sectors_fusion_rule(sectors(s1), sectors(s2))
+  return product_sectors_fusion_rule(product_sectors(s1), product_sectors(s2))
 end
 
 # lift ambiguities for TrivialSector
@@ -212,41 +219,41 @@ fusion_rule(::NotAbelianStyle, ::TrivialSector, c::SectorProduct) = to_gradedran
 SectorProduct(t::Tuple) = _SectorProduct(t)
 SectorProduct(sects::AbstractSector...) = SectorProduct(sects)
 
-function sectors_symmetrystyle(T::Type{<:Tuple})
+function product_sectors_symmetrystyle(T::Type{<:Tuple})
   return mapreduce(SymmetryStyle, combine_styles, fieldtypes(T); init=AbelianStyle())
 end
 
-sectors_product(::NamedTuple{()}, l1::Tuple) = l1
-sectors_product(l2::Tuple, ::NamedTuple{()}) = l2
-sectors_product(l1::Tuple, l2::Tuple) = (l1..., l2...)
+product_sectors_product(::NamedTuple{()}, l1::Tuple) = l1
+product_sectors_product(l2::Tuple, ::NamedTuple{()}) = l2
+product_sectors_product(l1::Tuple, l2::Tuple) = (l1..., l2...)
 
-sectors_trivial(type::Type{<:Tuple}) = trivial.(fieldtypes(type))
+product_sectors_trivial(type::Type{<:Tuple}) = trivial.(fieldtypes(type))
 
-function sectors_common(t1::Tuple, t2::Tuple)
+function product_sectors_common(t1::Tuple, t2::Tuple)
   n = min(length(t1), length(t2))
   return t1[begin:n], t2[begin:n]
 end
 
-function sectors_diff(t1::Tuple, t2::Tuple)
+function product_sectors_diff(t1::Tuple, t2::Tuple)
   n1 = length(t1)
   n2 = length(t2)
   return n1 < n2 ? t2[(n1 + 1):end] : t1[(n2 + 1):end]
 end
 
-function shared_sectors_fusion_rule(shared1::T, shared2::T) where {T<:Tuple}
+function shared_product_sectors_fusion_rule(shared1::T, shared2::T) where {T<:Tuple}
   fused = map(fusion_rule, shared1, shared2)
   return recover_style(T, fused)
 end
 
-function sectors_insert_unspecified(t1::Tuple, t2::Tuple)
+function product_sectors_insert_unspecified(t1::Tuple, t2::Tuple)
   n1 = length(t1)
   return (t1..., trivial.(t2[(n1 + 1):end])...)
 end
 
 # ===========================  Dictionary-like implementation  =============================
 function SectorProduct(nt::NamedTuple)
-  sectors = sort_keys(nt)
-  return _SectorProduct(sectors)
+  product_sectors = sort_keys(nt)
+  return _SectorProduct(product_sectors)
 end
 
 SectorProduct(; kws...) = SectorProduct((; kws...))
@@ -257,38 +264,38 @@ function SectorProduct(pairs::Pair...)
   return SectorProduct(NamedTuple{keys}(vals))
 end
 
-function sectors_symmetrystyle(NT::Type{<:NamedTuple})
+function product_sectors_symmetrystyle(NT::Type{<:NamedTuple})
   return mapreduce(SymmetryStyle, combine_styles, fieldtypes(NT); init=AbelianStyle())
 end
 
-function sectors_insert_unspecified(nt1::NamedTuple, nt2::NamedTuple)
-  diff1 = sectors_trivial(typeof(setdiff_keys(nt2, nt1)))
+function product_sectors_insert_unspecified(nt1::NamedTuple, nt2::NamedTuple)
+  diff1 = product_sectors_trivial(typeof(setdiff_keys(nt2, nt1)))
   return sort_keys(union_keys(nt1, diff1))
 end
 
-sectors_product(l1::NamedTuple, ::Tuple{}) = l1
-sectors_product(::Tuple{}, l2::NamedTuple) = l2
-function sectors_product(l1::NamedTuple, l2::NamedTuple)
+product_sectors_product(l1::NamedTuple, ::Tuple{}) = l1
+product_sectors_product(::Tuple{}, l2::NamedTuple) = l2
+function product_sectors_product(l1::NamedTuple, l2::NamedTuple)
   if length(intersect_keys(l1, l2)) > 0
     throw(ArgumentError("Cannot define product of shared keys"))
   end
   return union_keys(l1, l2)
 end
 
-function sectors_trivial(type::Type{<:NamedTuple{Keys}}) where {Keys}
+function product_sectors_trivial(type::Type{<:NamedTuple{Keys}}) where {Keys}
   return NamedTuple{Keys}(trivial.(fieldtypes(type)))
 end
 
-function sectors_common(nt1::NamedTuple, nt2::NamedTuple)
+function product_sectors_common(nt1::NamedTuple, nt2::NamedTuple)
   # SectorProduct(nt::NamedTuple) sorts keys at init
   @assert issorted(keys(nt1))
   @assert issorted(keys(nt2))
   return intersect_keys(nt1, nt2), intersect_keys(nt2, nt1)
 end
 
-sectors_diff(nt1::NamedTuple, nt2::NamedTuple) = symdiff_keys(nt1, nt2)
+product_sectors_diff(nt1::NamedTuple, nt2::NamedTuple) = symdiff_keys(nt1, nt2)
 
-function shared_sectors_fusion_rule(shared1::T, shared2::T) where {T<:NamedTuple}
+function shared_product_sectors_fusion_rule(shared1::T, shared2::T) where {T<:NamedTuple}
   fused = map(fusion_rule, values(shared1), values(shared2))
   return recover_style(T, fused)
 end