end of the ends (#36)

* end of the ends

* wack the intruder

* bump that version

* one more consistency update

* format docstrings

* remove unused exception

* share docs of fusion and braiding style

* more docstring format

* improve leftrightunit doc strings

* more runic style in doc strings

* more runic style in doc strings2

* some more missing type_reprs

* move and document type_repr

* make type_repr public

---------

Co-authored-by: Lukas Devos <ldevos98@gmail.com>

Author: Jutho

Project.toml

@@ -1,7 +1,7 @@
 name = "TensorKitSectors"
 uuid = "13a9c161-d5da-41f0-bcbd-e1a08ae0647f"
 authors = ["Lukas Devos", "Jutho Haegeman"]
-version = "0.3.0"
+version = "0.3.1"
 
 [deps]
 HalfIntegers = "f0d1745a-41c9-11e9-1dd9-e5d34d218721"

src/TensorKitSectors.jl

@@ -37,6 +37,12 @@ export ⊠, ⊗, ×
 export Cyclic, ℤ, ℤ₂, ℤ₃, ℤ₄, U₁, SU, SU₂, Dihedral, D₃, D₄, CU₁
 export fℤ₂, fU₁, fSU₂
 
+# public
+# ------
+@static if VERSION >= v"1.11.0-DEV.469"
+    eval(Expr(:public, :type_repr))
+end
+
 # imports
 # -------
 using Base: SizeUnknown, HasLength, IsInfinite

src/anyons.jl

@@ -11,6 +11,8 @@ useful for testing.
 """
 struct PlanarTrivial <: Sector end
 
+type_repr(::Type{PlanarTrivial}) = "PlanarTrivial"
+
 Base.IteratorSize(::Type{SectorValues{PlanarTrivial}}) = HasLength()
 Base.length(::SectorValues{PlanarTrivial}) = 1
 Base.iterate(::SectorValues{PlanarTrivial}, i = 0) = i == 0 ? (PlanarTrivial(), 1) : nothing
@@ -54,6 +56,8 @@ struct FibonacciAnyon <: Sector
     end
 end
 
+type_repr(::Type{FibonacciAnyon}) = "FibonacciAnyon"
+
 Base.IteratorSize(::Type{SectorValues{FibonacciAnyon}}) = HasLength()
 Base.length(::SectorValues{FibonacciAnyon}) = 2
 function Base.iterate(::SectorValues{FibonacciAnyon}, i = 0)
@@ -172,6 +176,8 @@ struct IsingAnyon <: Sector
     end
 end
 
+type_repr(::Type{IsingAnyon}) = "IsingAnyon"
+
 const all_isinganyons = (IsingAnyon(:I), IsingAnyon(:σ), IsingAnyon(:ψ))
 
 Base.IteratorSize(::Type{SectorValues{IsingAnyon}}) = HasLength()

src/fermions.jl

@@ -1,7 +1,8 @@
 """
-    FermionParity <: Sector
+    struct FermionParity <: Sector
+    FermionParity(isodd::Bool)
 
-Represents sectors with fermion parity. The fermion parity is a ℤ₂ quantum number that
+Represents sectors with fermion parity. The fermion parity is a ``ℤ₂`` quantum number that
 yields an additional sign when two odd fermions are exchanged, corresponding to a
 [`BraidingStyle`](@ref) that is `Fermionic()`.
 

src/groupelements.jl

@@ -2,7 +2,7 @@
 # associator given by a 3-cocycle.
 #------------------------------------------------------------------------------#
 """
-    abstract type AbstractGroupElement{G<:Group} <: Sector end
+    abstract type AbstractGroupElement{G <: Group} <: Sector
 
 Abstract supertype for sectors which corresponds to group elements of a group `G`.
 
@@ -14,7 +14,7 @@ All group elements have [`FusionStyle`](@ref) equal to `UniqueFusion()`.
 Furthermore, the [`BraidingStyle`](@ref) is set to `NoBraiding()`, although this can be
 overridden by a concrete implementation of `AbstractGroupElement`.
 
-For the fusion structure, a specific `SomeGroupElement<:AbstractGroupElement{SomeGroup}`
+For the fusion structure, a specific `SomeGroupElement <: AbstractGroupElement{SomeGroup}`
 should only implement the following methods
 ```julia
 Base.:*(c1::GroupElement, c2::GroupElement) -> GroupElement
@@ -60,10 +60,10 @@ struct ElementTable end
 """
     const GroupElement
 
-A constant of a singleton type used as `GroupElement[G]` or `GroupElement[G,ω]` with `G<:Group`
-a type of group, to construct or obtain a concrete subtype of `AbstractElement{G}`
-that implements the data structure used to represent elements of the group `G`, possibly
-with a second argument `ω` that specifies the associated 3-cocycle.
+A constant of a singleton type used as `GroupElement[G]` or `GroupElement[G, ω]` with
+`G <: Group` a type of group, to construct or obtain a concrete subtype of
+`AbstractElement{G}` that implements the data structure used to represent elements of the
+group `G`, possibly with a second argument `ω` that specifies the associated 3-cocycle.
 """
 const GroupElement = ElementTable()
 
@@ -92,11 +92,12 @@ end
     ZNElement{N, p}(n::Integer)
     GroupElement[ℤ{N}, p](n::Integer)
 
-Represents an element of the group ``ℤ_N`` for some value of `N<64`. (We need `2*(N-1) <= 127`
-in order for `a ⊗ b` to work correctly.) For `N` equals `2`, `3` or `4`, `ℤ{N}` can be replaced
-by `ℤ₂`, `ℤ₃`, `ℤ₄`. An arbitrary `Integer` `n` can be provided to the constructor, but only
-the value `mod(n, N)` is relevant. The second type parameter `p` should also be specified as
-an integer ` 0 <= p < N` and specifies the 3-cocycle, which is then being given by 
+Represents an element of the group ``ℤ_N`` for some value of `N < 64`. (We need
+`2 * (N - 1) <= 127` in order for `a ⊗ b` to work correctly.) For `N` equals `2`, `3` or
+`4`, `ℤ{N}` can be replaced by `ℤ₂`, `ℤ₃`, `ℤ₄`. An arbitrary `Integer` `n` can be provided
+to the constructor, but only the value `mod(n, N)` is relevant. The second type parameter
+`p` should also be specified as an integer ` 0 <= p < N` and specifies the 3-cocycle, which
+is then being given by
 
 ```julia
 cocycle(a, b, c) = cispi(2 * p * a.n * (b.n + c.n - mod(b.n + c.n, N)) / N))

src/groups.jl

@@ -1,7 +1,7 @@
 # Groups
 #------------------------------------------------------------------------------#
 """
-    abstract type Group end
+    abstract type Group
 
 Abstract supertype for representing different types of groups. Groups can be used
 to define Sector subtypes, either via their irreducible representations, or
@@ -11,7 +11,7 @@ are not meant to be instantiated and are defined as abstract types.
 abstract type Group end
 
 """
-    abstract type AbelianGroup <: Group end
+    abstract type AbelianGroup <: Group
 
 Abstract supertype for representing different types of Abelian groups.
 Abelian groups have both irreps and group elements that have several
@@ -20,7 +20,7 @@ simplified properties, that can be defined in general.
 abstract type AbelianGroup <: Group end
 
 """
-    abstract type Cyclic{N} <: AbelianGroup end
+    abstract type Cyclic{N} <: AbelianGroup
 
 Type to represent the cyclic group of order `N`, i.e. the multiplicative
 group of roots of unity of order `N`, which is a discrete abelian group.
@@ -30,7 +30,7 @@ and we define the latter as a type alias `const ℤ{N} = Cyclic{N}`.
 abstract type Cyclic{N} <: AbelianGroup end
 
 """
-    abstract type Dihedral{N} <: Group end
+    abstract type Dihedral{N} <: Group
 
 Type to represent the dihedral group of order `2N`, which is the symmetry
 group of a regular polygon with `N` sides, and is a discrete non-Abelian
@@ -40,23 +40,23 @@ abstract type Dihedral{N} <: Group end
 
 
 """
-    abstract type U₁ <: AbelianGroup end
+    abstract type U₁ <: AbelianGroup
 
 Type to represent the group ``U(1)`` of complex numbers of unit modulus,
 which is a compact Abelian Lie group.
 """
 abstract type U₁ <: AbelianGroup end
 
 """
-    abstract type SU{N} <: Group end
+    abstract type SU{N} <: Group
 
 Type to represent the special unitary group ``SU(N)``, which is a
 compact non-Abelian Lie group.
 """
 abstract type SU{N} <: Group end
 
 """
-    abstract type CU₁ <: Group end
+    abstract type CU₁ <: Group
 
 Type to represent the group of U₁ in combination with charge conjugation,
 i.e. the group generated by U₁ and an additional element that acts as
@@ -77,17 +77,17 @@ const SU₂ = SU{2}
 type_repr(::Type{ℤ₂}) = "ℤ₂"
 type_repr(::Type{ℤ₃}) = "ℤ₃"
 type_repr(::Type{ℤ₄}) = "ℤ₄"
+type_repr(::Type{ℤ{N}}) where {N} = "ℤ{$N}"
 type_repr(::Type{D₃}) = "D₃"
 type_repr(::Type{D₄}) = "D₄"
 type_repr(::Type{SU₂}) = "SU₂"
 type_repr(::Type{U₁}) = "U₁"
 type_repr(::Type{CU₁}) = "CU₁"
-type_repr(T::Type) = repr(T)
 
 const GroupTuple = Tuple{Vararg{Group}}
 
 """
-    abstract type ProductGroup{T <: Tuple{Vararg{Group}}} <: Group end
+    abstract type ProductGroup{T <: Tuple{Vararg{Group}}} <: Group
 
 Type to represent the direct product of a tuple of groups. This is typically
 constructed via the [`×`](@ref) operator.

src/irreps/irreps.jl

@@ -1,7 +1,7 @@
 # Sectors corresponding to irreducible representations of compact groups
 #------------------------------------------------------------------------------#
 """
-    abstract type AbstractIrrep{G <: Group} <: Sector end
+    abstract type AbstractIrrep{G <: Group} <: Sector
 
 Abstract supertype for sectors which corresponds to irreps (irreducible representations) of
 a group `G`. As we assume unitary representations, these would be finite groups or compact
@@ -20,7 +20,7 @@ struct IrrepTable end
 """
     const Irrep
 
-A constant of a singleton type used as `Irrep[G]` with `G<:Group` a type of group, to
+A constant of a singleton type used as `Irrep[G]` with `G <: Group` a type of group, to
 construct or obtain a concrete subtype of `AbstractIrrep{G}` that implements the data
 structure used to represent irreducible representations of the group `G`.
 """

src/irreps/su2irrep.jl

@@ -1,12 +1,3 @@
-# SU2Irrep: irreps of SU2 are labelled by half integers j
-struct SU2IrrepException <: Exception end
-function Base.show(io::IO, ::SU2IrrepException)
-    return print(
-        io,
-        "Irreps of (bosonic or fermionic) `SU₂` should be labelled by non-negative half integers, i.e. elements of `Rational{Int}` with denominator 1 or 2"
-    )
-end
-
 """
     struct SU2Irrep <: AbstractIrrep{SU₂}
     SU2Irrep(j::Real)

src/product.jl

@@ -3,7 +3,8 @@
 const SectorTuple = Tuple{Vararg{Sector}}
 
 """
-    ProductSector{T<:SectorTuple}
+    struct ProductSector{T <: SectorTuple}
+    ProductSector((s₁, s₂, ...))
 
 Represents the Deligne tensor product of sectors. The type parameter `T` is a tuple of the
 component sectors. The recommended way to construct a `ProductSector` is using the