Change terminology from symmetry to grading

Author: mtfishman

ext/QuantumOperatorDefinitionsSymmetrySectorsExt/QuantumOperatorDefinitionsSymmetrySectorsExt.jl

@@ -4,7 +4,7 @@ using BlockArrays: blocklasts, blocklengths
 using GradedUnitRanges: GradedOneTo, gradedrange
 using LabelledNumbers: label, labelled, unlabel
 using QuantumOperatorDefinitions:
-  QuantumOperatorDefinitions, @SiteType_str, @SymmetryType_str, SiteType, SymmetryType, name
+  QuantumOperatorDefinitions, @SiteType_str, @GradingType_str, SiteType, GradingType, name
 using SymmetrySectors: ×, SectorProduct, U1, Z
 
 sortedunion(a, b) = sort(union(a, b))
@@ -21,60 +21,60 @@ end
 QuantumOperatorDefinitions.combine_axes(a::GradedOneTo, b::Base.OneTo) = a
 QuantumOperatorDefinitions.combine_axes(a::Base.OneTo, b::GradedOneTo) = b
 
-function Base.AbstractUnitRange(::SymmetryType"N", t::SiteType)
+function Base.AbstractUnitRange(::GradingType"N", t::SiteType)
   return gradedrange(map(i -> SectorProduct((; N=U1(i - 1))) => 1, 1:length(t)))
 end
-function Base.AbstractUnitRange(::SymmetryType"Sz", t::SiteType)
+function Base.AbstractUnitRange(::GradingType"Sz", t::SiteType)
   return gradedrange(map(i -> SectorProduct((; Sz=U1(i - 1))) => 1, 1:length(t)))
 end
-function Base.AbstractUnitRange(::SymmetryType"Sz↑", t::SiteType)
-  return AbstractUnitRange(SymmetryType"Sz"(), t)
+function Base.AbstractUnitRange(::GradingType"Sz↑", t::SiteType)
+  return AbstractUnitRange(GradingType"Sz"(), t)
 end
-function Base.AbstractUnitRange(::SymmetryType"Sz↓", t::SiteType)
+function Base.AbstractUnitRange(::GradingType"Sz↓", t::SiteType)
   return gradedrange(map(i -> SectorProduct((; Sz=U1(-(i - 1)))) => 1, 1:length(t)))
 end
 
-function sector(symmetrytype::SymmetryType, sec)
-  sectorname = Symbol(get(symmetrytype, :name, name(symmetrytype)))
+function sector(gradingtype::GradingType, sec)
+  sectorname = Symbol(get(gradingtype, :name, name(gradingtype)))
   return SectorProduct(NamedTuple{(sectorname,)}((sec,)))
 end
 
-function Base.AbstractUnitRange(s::SymmetryType"Nf", t::SiteType"Fermion")
+function Base.AbstractUnitRange(s::GradingType"Nf", t::SiteType"Fermion")
   return gradedrange([sector(s, U1(0)) => 1, sector(s, U1(1)) => 1])
 end
-# TODO: Write in terms of `SymmetryType"Nf"` definition.
-function Base.AbstractUnitRange(s::SymmetryType"NfParity", t::SiteType"Fermion")
+# TODO: Write in terms of `GradingType"Nf"` definition.
+function Base.AbstractUnitRange(s::GradingType"NfParity", t::SiteType"Fermion")
   return gradedrange([sector(s, Z{2}(0)) => 1, sector(s, Z{2}(1)) => 1])
 end
-function Base.AbstractUnitRange(s::SymmetryType"Sz", t::SiteType"Fermion")
+function Base.AbstractUnitRange(s::GradingType"Sz", t::SiteType"Fermion")
   return gradedrange([sector(s, U1(0)) => 1, sector(s, U1(1)) => 1])
 end
-function Base.AbstractUnitRange(s::SymmetryType"Sz↑", t::SiteType"Fermion")
+function Base.AbstractUnitRange(s::GradingType"Sz↑", t::SiteType"Fermion")
   return gradedrange([sector(s, U1(0)) => 1, sector(s, U1(1)) => 1])
 end
-function Base.AbstractUnitRange(s::SymmetryType"Sz↓", t::SiteType"Fermion")
+function Base.AbstractUnitRange(s::GradingType"Sz↓", t::SiteType"Fermion")
   return gradedrange([sector(s, U1(0)) => 1, sector(s, U1(-1)) => 1])
 end
 
 # TODO: Write in terms of `SiteType"Fermion"` definitions.
-function Base.AbstractUnitRange(s::SymmetryType"Nf", t::SiteType"Electron")
+function Base.AbstractUnitRange(s::GradingType"Nf", t::SiteType"Electron")
   return gradedrange([
     sector(s, U1(0)) => 1,
     sector(s, U1(1)) => 1,
     sector(s, U1(1)) => 1,
     sector(s, U1(2)) => 1,
   ])
 end
-# TODO: Write in terms of `SymmetryType"Nf"` definition.
-function Base.AbstractUnitRange(s::SymmetryType"NfParity", t::SiteType"Electron")
+# TODO: Write in terms of `GradingType"Nf"` definition.
+function Base.AbstractUnitRange(s::GradingType"NfParity", t::SiteType"Electron")
   return gradedrange([
     sector(s, Z{2}(0)) => 1,
     sector(s, Z{2}(1)) => 1,
     sector(s, Z{2}(1)) => 1,
     sector(s, Z{2}(0)) => 1,
   ])
 end
-function Base.AbstractUnitRange(s::SymmetryType"Sz", t::SiteType"Electron")
+function Base.AbstractUnitRange(s::GradingType"Sz", t::SiteType"Electron")
   return gradedrange([
     sector(s, U1(0)) => 1,
     sector(s, U1(1)) => 1,

src/sitetype.jl

@@ -29,33 +29,33 @@ end
 combine_axes(a) = a
 combine_axes(a, b, rest...) = combine_axes(combine_axes(a, b), rest...)
 
-struct SymmetryType{T,Params}
+struct GradingType{T,Params}
   params::Params
-  function SymmetryType{N}(params::NamedTuple) where {N}
+  function GradingType{N}(params::NamedTuple) where {N}
     return new{N,typeof(params)}(params)
   end
 end
-name(::SymmetryType{T}) where {T} = T
-params(t::SymmetryType) = getfield(t, :params)
-Base.getproperty(t::SymmetryType, name::Symbol) = getfield(params(t), name)
-Base.get(t::SymmetryType, name::Symbol, default) = get(params(t), name, default)
-Base.haskey(t::SymmetryType, name::Symbol) = haskey(params(t), name)
-SymmetryType{N}(; kwargs...) where {N} = SymmetryType{N}((; kwargs...))
-SymmetryType(s::AbstractString; kwargs...) = SymmetryType{Symbol(s)}(; kwargs...)
-function SymmetryType(s::Pair{<:AbstractString,<:AbstractString}; kwargs...)
-  return SymmetryType(first(s); kwargs..., name=last(s))
+name(::GradingType{T}) where {T} = T
+params(t::GradingType) = getfield(t, :params)
+Base.getproperty(t::GradingType, name::Symbol) = getfield(params(t), name)
+Base.get(t::GradingType, name::Symbol, default) = get(params(t), name, default)
+Base.haskey(t::GradingType, name::Symbol) = haskey(params(t), name)
+GradingType{N}(; kwargs...) where {N} = GradingType{N}((; kwargs...))
+GradingType(s::AbstractString; kwargs...) = GradingType{Symbol(s)}(; kwargs...)
+function GradingType(s::Pair{<:AbstractString,<:AbstractString}; kwargs...)
+  return GradingType(first(s); kwargs..., name=last(s))
 end
-function SymmetryType(s::Pair{<:AbstractString,<:NamedTuple}; kwargs...)
-  return SymmetryType(first(s); kwargs..., last(s)...)
+function GradingType(s::Pair{<:AbstractString,<:NamedTuple}; kwargs...)
+  return GradingType(first(s); kwargs..., last(s)...)
 end
-macro SymmetryType_str(s)
-  return :(SymmetryType{$(Expr(:quote, Symbol(s)))})
+macro GradingType_str(s)
+  return :(GradingType{$(Expr(:quote, Symbol(s)))})
 end
 
-function Base.AbstractUnitRange(symmetry::SymmetryType, t::SiteType)
+function Base.AbstractUnitRange(grading::GradingType, t::SiteType)
   return error("Not implemented.")
 end
-function Base.AbstractUnitRange(symmetry::SymmetryType"Trivial", t::SiteType)
+function Base.AbstractUnitRange(grading::GradingType"Trivial", t::SiteType)
   return Base.OneTo(length(t))
 end
 
@@ -70,8 +70,8 @@ function Base.AbstractUnitRange(t::SiteType)
   # This logic allows specifying a range with extra properties,
   # like ones with symmetry sectors.
   haskey(t, :range) && return t.range
-  if haskey(t, :symmetries)
-    rs = map(symmetry -> AbstractUnitRange(SymmetryType(symmetry), t), t.symmetries)
+  if haskey(t, :gradings)
+    rs = map(grading -> AbstractUnitRange(GradingType(grading), t), t.gradings)
     return combine_axes(Base.OneTo(length(t)), rs...)
   end
   return Base.OneTo(length(t))