rename Category to Sector

Author: ogauthe

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

@@ -1,17 +1,17 @@
 module Sectors
 
 include("symmetry_style.jl")
-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")
-include("category_definitions/zn.jl")
+include("abstractsector.jl")
+include("sector_definitions/fib.jl")
+include("sector_definitions/ising.jl")
+include("sector_definitions/o2.jl")
+include("sector_definitions/trivial.jl")
+include("sector_definitions/su.jl")
+include("sector_definitions/su2k.jl")
+include("sector_definitions/u1.jl")
+include("sector_definitions/zn.jl")
 
 include("namedtuple_operations.jl")
-include("category_product.jl")
+include("sector_product.jl")
 
 end

NDTensors/src/lib/Sectors/src/abstractcategory.jl renamed to NDTensors/src/lib/Sectors/src/abstractsector.jl

@@ -1,15 +1,15 @@
-# This file defines the abstract type AbstractCategory
-# all fusion categories (Z{2}, SU2, Ising...) are subtypes of AbstractCategory
+# This file defines the abstract type AbstractSector
+# all fusion categories (Z{2}, SU2, Ising...) are subtypes of AbstractSector
 
 using BlockArrays: blocklengths
 using ..LabelledNumbers: LabelledInteger, label, label_type, labelled, unlabel, unlabel_type
 using ..GradedAxes: GradedAxes, blocklabels, fuse_blocklengths, gradedrange, tensor_product
 
-abstract type AbstractCategory end
+abstract type AbstractSector end
 
 # ===================================  Base interface  =====================================
-function Base.isless(c1::C, c2::C) where {C<:AbstractCategory}
-  return isless(category_label(c1), category_label(c2))
+function Base.isless(c1::C, c2::C) where {C<:AbstractSector}
+  return isless(sector_label(c1), sector_label(c2))
 end
 
 # =================================  Sectors interface  ====================================
@@ -24,10 +24,10 @@ function trivial(type::Type)
   return error("`trivial` not defined for type $(type).")
 end
 
-istrivial(c::AbstractCategory) = (c == trivial(c))
+istrivial(c::AbstractSector) = (c == trivial(c))
 
-function category_label(c::AbstractCategory)
-  return error("method `category_label` not defined for type $(typeof(c))")
+function sector_label(c::AbstractSector)
+  return error("method `sector_label` not defined for type $(typeof(c))")
 end
 
 block_dimensions(g::AbstractUnitRange) = block_dimensions(SymmetryStyle(g), g)
@@ -38,41 +38,41 @@ end
 
 quantum_dimension(x) = quantum_dimension(SymmetryStyle(x), x)
 
-function quantum_dimension(::NotAbelianStyle, c::AbstractCategory)
+function quantum_dimension(::NotAbelianStyle, c::AbstractSector)
   return error("method `quantum_dimension` not defined for type $(typeof(c))")
 end
 
-quantum_dimension(::AbelianStyle, ::AbstractCategory) = 1
+quantum_dimension(::AbelianStyle, ::AbstractSector) = 1
 quantum_dimension(::AbelianStyle, g::AbstractUnitRange) = length(g)
 quantum_dimension(::NotAbelianStyle, g::AbstractUnitRange) = sum(block_dimensions(g))
 
 # ===============================  Fusion rule interface  ==================================
-⊗(c1::AbstractCategory, c2::AbstractCategory) = fusion_rule(c1, c2)
+⊗(c1::AbstractSector, c2::AbstractSector) = fusion_rule(c1, c2)
 
-function fusion_rule(c1::AbstractCategory, c2::AbstractCategory)
+function fusion_rule(c1::AbstractSector, c2::AbstractSector)
   return fusion_rule(combine_styles(SymmetryStyle(c1), SymmetryStyle(c2)), c1, c2)
 end
 
-function fusion_rule(::NotAbelianStyle, c1::C, c2::C) where {C<:AbstractCategory}
-  degen, sectors = label_fusion_rule(C, category_label(c1), category_label(c2))
+function fusion_rule(::NotAbelianStyle, c1::C, c2::C) where {C<:AbstractSector}
+  degen, sectors = label_fusion_rule(C, sector_label(c1), sector_label(c2))
   return gradedrange(labelled.(degen, sectors))
 end
 
-# abelian case: return Category
-function fusion_rule(::AbelianStyle, c1::C, c2::C) where {C<:AbstractCategory}
-  _, sectors = label_fusion_rule(C, category_label(c1), category_label(c2))
+# abelian case: return Sector
+function fusion_rule(::AbelianStyle, c1::C, c2::C) where {C<:AbstractSector}
+  _, sectors = label_fusion_rule(C, sector_label(c1), sector_label(c2))
   return only(sectors)
 end
 
-function label_fusion_rule(category_type::Type{<:AbstractCategory}, ::Any, ::Any)
-  return error("`label_fusion_rule` not defined for type $(category_type).")
+function label_fusion_rule(sector_type::Type{<:AbstractSector}, ::Any, ::Any)
+  return error("`label_fusion_rule` not defined for type $(sector_type).")
 end
 
 # ================================  GradedAxes interface  ==================================
 # tensor_product interface
 function GradedAxes.fuse_blocklengths(
-  l1::LabelledInteger{<:Integer,<:AbstractCategory},
-  l2::LabelledInteger{<:Integer,<:AbstractCategory},
+  l1::LabelledInteger{<:Integer,<:AbstractSector},
+  l2::LabelledInteger{<:Integer,<:AbstractSector},
 )
   return fuse_blocklengths(combine_styles(SymmetryStyle(l1), SymmetryStyle(l2)), l1, l2)
 end
@@ -93,23 +93,23 @@ function GradedAxes.fuse_blocklengths(
 end
 
 # cast to range
-to_gradedrange(c::AbstractCategory) = to_gradedrange(labelled(1, c))
+to_gradedrange(c::AbstractSector) = to_gradedrange(labelled(1, c))
 to_gradedrange(l::LabelledInteger) = gradedrange([l])
 to_gradedrange(g::AbstractUnitRange) = g
 
-# allow to fuse a category with a GradedUnitRange
-function GradedAxes.tensor_product(c::AbstractCategory, g::AbstractUnitRange)
+# allow to fuse a Sector with a GradedUnitRange
+function GradedAxes.tensor_product(c::AbstractSector, g::AbstractUnitRange)
   return tensor_product(to_gradedrange(c), g)
 end
 
-function GradedAxes.tensor_product(g::AbstractUnitRange, c::AbstractCategory)
+function GradedAxes.tensor_product(g::AbstractUnitRange, c::AbstractSector)
   return tensor_product(g, to_gradedrange(c))
 end
 
-function GradedAxes.tensor_product(c1::AbstractCategory, c2::AbstractCategory)
+function GradedAxes.tensor_product(c1::AbstractSector, c2::AbstractSector)
   return to_gradedrange(fusion_rule(c1, c2))
 end
 
-function GradedAxes.fusion_product(c::AbstractCategory)
+function GradedAxes.fusion_product(c::AbstractSector)
   return to_gradedrange(c)
 end