[Breaking] UnitStyle, allunits and a bunch of renaming (#25)

* `MultiFusionStyle` and its properties with itself and `FusionStyle`

* `allones` for `Type{Sector}`

* changes to `IsingBimodule`

* export them all

* `allones` tests

* fix `&` and make commutative for mixed case

* `MultiFusionStyle` tests

* format

* update `MultiFusionStyle` to only reflect the semisimplicity of the unit

* update for `IsingBimodule`

* fix exports

* fix tests

* fix docstrings

* add `MultiFusionStyle` for product sectors + test

* remove interplay `MultiFusionStyle`-`FusionStyle` + related tests

* fix domain error of one of IsingBimodule

* introduce `allones` for all sectors

* introduce generic `one` for type sector + remove for specific sectors

* `allones` for productsector with tests

* have multifusionstyle fully depend on `allones`

* format

* change `one` to `unit` and have `Base.one` fall back to `unit` + rename to `left/rightunit` and `allunits`

* rename  `MultiFusionStyle` to `UnitStyle`

* replace  `Base.conj` with `dual` and have `dual` fall back to `Base.conj`

* replacing more `conj` with `dual` + docstring changes

* minor docstring fix

* more one to unit changes

* fix `allunits` of product sector to be type stable and return set

* `allunits` for `NewSU2Irrep`

* add imports for `NewSU2Irrep`

* `allunits` for `TimeReversed`

* remove some specific `unit`s I missed

* apply code suggestions

* reverse roles of `unit` and `allunits` to make `unit` the entry point of a sector

* more `mapreduce`s

* another `mapreduce` + format

* use `SectorSet` for time reversed `allunits`

* remove `_isreal` code

* derive `unit` from `one` for `GroupElement`

* avoid string interpolations in error messages

* reduce specification

* make otimes output of time reversed a `SectorSet`

* introduce `isunit` and change `isone` to `isunit` where relevant

* bump version to 0.3.0

* one last `isunit`

* change fib field name to `isunit`

* `unit(::Type{<:AbstractGroupElement})`

* noinline domainerror

* also update precompile

---------

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

Author: borisdevos

Project.toml

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

src/TensorKitSectors.jl

@@ -11,9 +11,10 @@ export dim, sqrtdim, invsqrtdim, frobeniusschur, twist, fusiontensor, dual
 export otimes, deligneproduct, times
 export FusionStyle, UniqueFusion, MultipleFusion, SimpleFusion, GenericFusion,
     MultiplicityFreeFusion
+export UnitStyle, SimpleUnit, GenericUnit
 export BraidingStyle, NoBraiding, HasBraiding, SymmetricBraiding, Bosonic, Fermionic, Anyonic
 export SectorSet, SectorValues, findindex
-export rightone, leftone
+export unit, rightunit, leftunit, allunits, isunit
 
 export triangle_equation, pentagon_equation, hexagon_equation
 

src/anyons.jl

@@ -21,8 +21,8 @@ end
 findindex(::SectorValues{PlanarTrivial}, c::PlanarTrivial) = 1
 Base.isless(::PlanarTrivial, ::PlanarTrivial) = false
 
-Base.one(::Type{PlanarTrivial}) = PlanarTrivial()
-Base.conj(::PlanarTrivial) = PlanarTrivial()
+unit(::Type{PlanarTrivial}) = PlanarTrivial()
+dual(::PlanarTrivial) = PlanarTrivial()
 
 FusionStyle(::Type{PlanarTrivial}) = UniqueFusion()
 BraidingStyle(::Type{PlanarTrivial}) = NoBraiding()
@@ -43,11 +43,11 @@ corresponding to the trivial sector `FibonacciAnyon(:I)` and the non-trivial sec
 `FibonacciAnyon(:τ)` with fusion rules ``τ ⊗ τ = 1 ⊕ τ``.
 
 ## Fields
-- `isone::Bool`: indicates whether the sector corresponds the to trivial anyon `:I`
+- `isunit::Bool`: indicates whether the sector corresponds to the trivial anyon `:I`
   (`true`), or the non-trivial anyon `:τ` (`false`).
 """
 struct FibonacciAnyon <: Sector
-    isone::Bool
+    isunit::Bool
     function FibonacciAnyon(s::Symbol)
         s in (:I, :τ, :tau) || throw(ArgumentError("Unknown FibonacciAnyon $s."))
         return new(s === :I)
@@ -68,14 +68,14 @@ function Base.getindex(S::SectorValues{FibonacciAnyon}, i::Int)
         throw(BoundsError(S, i))
     end
 end
-findindex(::SectorValues{FibonacciAnyon}, s::FibonacciAnyon) = 2 - s.isone
+findindex(::SectorValues{FibonacciAnyon}, s::FibonacciAnyon) = 2 - s.isunit
 
 Base.convert(::Type{FibonacciAnyon}, s::Symbol) = FibonacciAnyon(s)
-Base.one(::Type{FibonacciAnyon}) = FibonacciAnyon(:I)
-Base.conj(s::FibonacciAnyon) = s
+unit(::Type{FibonacciAnyon}) = FibonacciAnyon(:I)
+dual(s::FibonacciAnyon) = s
 
 const _goldenratio = Float64(MathConstants.golden)
-dim(a::FibonacciAnyon) = isone(a) ? one(_goldenratio) : _goldenratio
+dim(a::FibonacciAnyon) = isunit(a) ? one(_goldenratio) : _goldenratio
 
 FusionStyle(::Type{FibonacciAnyon}) = SimpleFusion()
 BraidingStyle(::Type{FibonacciAnyon}) = Anyonic()
@@ -89,7 +89,7 @@ struct FibonacciIterator
 end
 Base.IteratorSize(::Type{FibonacciIterator}) = Base.HasLength()
 Base.IteratorEltype(::Type{FibonacciIterator}) = Base.HasEltype()
-Base.length(iter::FibonacciIterator) = (isone(iter.a) || isone(iter.b)) ? 1 : 2
+Base.length(iter::FibonacciIterator) = (isunit(iter.a) || isunit(iter.b)) ? 1 : 2
 Base.eltype(::Type{FibonacciIterator}) = FibonacciAnyon
 function Base.iterate(iter::FibonacciIterator, state = 1)
     I = FibonacciAnyon(:I)
@@ -107,7 +107,7 @@ function Base.iterate(iter::FibonacciIterator, state = 1)
 end
 
 function Nsymbol(a::FibonacciAnyon, b::FibonacciAnyon, c::FibonacciAnyon)
-    return isone(a) + isone(b) + isone(c) != 2
+    return isunit(a) + isunit(b) + isunit(c) != 2
 end # zero if one tau and two ones
 
 function Fsymbol(
@@ -136,21 +136,21 @@ end
 
 function Rsymbol(a::FibonacciAnyon, b::FibonacciAnyon, c::FibonacciAnyon)
     Nsymbol(a, b, c) || return 0 * cispi(0 / 1)
-    if isone(a) || isone(b)
+    if isunit(a) || isunit(b)
         return cispi(0 / 1)
     else
-        return isone(c) ? cispi(4 / 5) : cispi(-3 / 5)
+        return isunit(c) ? cispi(4 / 5) : cispi(-3 / 5)
     end
 end
 
 function Base.show(io::IO, a::FibonacciAnyon)
-    s = isone(a) ? ":I" : ":τ"
+    s = isunit(a) ? ":I" : ":τ"
     return get(io, :typeinfo, nothing) === FibonacciAnyon ?
         print(io, s) : print(io, "FibonacciAnyon(", s, ")")
 end
 
-Base.hash(a::FibonacciAnyon, h::UInt) = hash(a.isone, h)
-Base.isless(a::FibonacciAnyon, b::FibonacciAnyon) = isless(!a.isone, !b.isone)
+Base.hash(a::FibonacciAnyon, h::UInt) = hash(a.isunit, h)
+Base.isless(a::FibonacciAnyon, b::FibonacciAnyon) = isless(!a.isunit, !b.isunit)
 
 # IsingAnyons
 """
@@ -191,8 +191,8 @@ function findindex(::SectorValues{IsingAnyon}, a::IsingAnyon)
 end
 
 Base.convert(::Type{IsingAnyon}, s::Symbol) = IsingAnyon(s)
-Base.one(::Type{IsingAnyon}) = IsingAnyon(:I)
-Base.conj(s::IsingAnyon) = s
+unit(::Type{IsingAnyon}) = IsingAnyon(:I)
+dual(s::IsingAnyon) = s
 
 dim(a::IsingAnyon) = a.s == :σ ? sqrt(2) : 1.0
 

src/fermions.jl

@@ -28,8 +28,8 @@ function Base.getindex(::SectorValues{FermionParity}, i::Int)
 end
 findindex(::SectorValues{FermionParity}, f::FermionParity) = f.isodd ? 2 : 1
 
-Base.one(::Type{FermionParity}) = FermionParity(false)
-Base.conj(f::FermionParity) = f
+unit(::Type{FermionParity}) = FermionParity(false)
+dual(f::FermionParity) = f
 dim(f::FermionParity) = 1
 
 FusionStyle(::Type{FermionParity}) = UniqueFusion()

src/groupelements.jl

@@ -34,8 +34,8 @@ BraidingStyle(::Type{<:AbstractGroupElement}) = NoBraiding()
 
 cocycle(a::I, b::I, c::I) where {I <: AbstractGroupElement} = 1
 ⊗(a::I, b::I) where {I <: AbstractGroupElement} = (a * b,)
-Base.one(a::AbstractGroupElement) = one(typeof(a))
-Base.conj(a::AbstractGroupElement) = inv(a)
+dual(a::AbstractGroupElement) = inv(a)
+unit(::Type{I}) where {I <: AbstractGroupElement} = one(I)
 Nsymbol(a::I, b::I, c::I) where {I <: AbstractGroupElement} = c == a * b
 function Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {I <: AbstractGroupElement}
     ω = cocycle(a, b, c)

src/irreps/cu1irrep.jl

@@ -66,8 +66,8 @@ end
 Base.convert(::Type{CU1Irrep}, j::Real) = CU1Irrep(j)
 Base.convert(::Type{CU1Irrep}, js::Tuple{Real, Int}) = CU1Irrep(js...)
 
-Base.one(::Type{CU1Irrep}) = CU1Irrep(zero(HalfInt), 0)
-Base.conj(c::CU1Irrep) = c
+unit(::Type{CU1Irrep}) = CU1Irrep(zero(HalfInt), 0)
+dual(c::CU1Irrep) = c
 
 struct CU1ProdIterator
     a::CU1Irrep
@@ -82,7 +82,7 @@ function Base.iterate(p::CU1ProdIterator, s::Int = 1)
         elseif p.b.j == zero(HalfInt)
             return p.a, 4
         elseif p.a == p.b # != zero
-            return one(CU1Irrep), 2
+            return unit(CU1Irrep), 2
         else
             return CU1Irrep(abs(p.a.j - p.b.j)), 3
         end

src/irreps/dnirrep.jl

@@ -47,8 +47,8 @@ FusionStyle(::Type{DNIrrep{N}}) where {N} = N < 3 ? UniqueFusion() : SimpleFusio
 sectorscalartype(::Type{DNIrrep{N}}) where {N} = Float64
 Base.isreal(::Type{DNIrrep{N}}) where {N} = true
 
-Base.one(::Type{DNIrrep{N}}) where {N} = DNIrrep{N}(0, false)
-Base.conj(a::DNIrrep) = a
+unit(::Type{DNIrrep{N}}) where {N} = DNIrrep{N}(0, false)
+dual(a::DNIrrep) = a
 
 Base.hash(a::DNIrrep, h::UInt) = hash(a.data, h)
 Base.convert(::Type{DNIrrep{N}}, (j, n)::Tuple{Integer, Bool}) where {N} = DNIrrep{N}(j, n)
@@ -195,7 +195,7 @@ function Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {N, I <: DNIrrep{N}}
     (Nsymbol(a, b, e) & Nsymbol(e, c, d) & Nsymbol(b, c, f) & Nsymbol(a, f, d)) || return zero(T)
 
     # tensoring with units gives 1
-    (isone(a) || isone(b) || isone(c)) && return one(T)
+    (isunit(a) || isunit(b) || isunit(c)) && return one(T)
 
     # fallback through fusiontensor
     A = fusiontensor(a, b, e)

src/irreps/su2irrep.jl

@@ -30,8 +30,8 @@ Base.getindex(::IrrepTable, ::Type{SU₂}) = SU2Irrep
 Base.convert(::Type{SU2Irrep}, j::Real) = SU2Irrep(j)
 
 const _su2one = SU2Irrep(zero(HalfInt))
-Base.one(::Type{SU2Irrep}) = _su2one
-Base.conj(s::SU2Irrep) = s
+unit(::Type{SU2Irrep}) = _su2one
+dual(s::SU2Irrep) = s
 ⊗(s1::SU2Irrep, s2::SU2Irrep) = SectorSet{SU2Irrep}(abs(s1.j - s2.j):(s1.j + s2.j))
 
 Base.IteratorSize(::Type{SectorValues{SU2Irrep}}) = IsInfinite()

src/irreps/u1irrep.jl

@@ -19,8 +19,8 @@ end
 Base.getindex(::IrrepTable, ::Type{U₁}) = U1Irrep
 Base.convert(::Type{U1Irrep}, c::Real) = U1Irrep(c)
 
-Base.one(::Type{U1Irrep}) = U1Irrep(0)
-Base.conj(c::U1Irrep) = U1Irrep(-c.charge)
+unit(::Type{U1Irrep}) = U1Irrep(0)
+dual(c::U1Irrep) = U1Irrep(-c.charge)
 ⊗(c1::U1Irrep, c2::U1Irrep) = (U1Irrep(c1.charge + c2.charge),)
 
 Base.IteratorSize(::Type{SectorValues{U1Irrep}}) = IsInfinite()

src/irreps/znirrep.jl

@@ -25,8 +25,8 @@ const Z2Irrep = ZNIrrep{2}
 const Z3Irrep = ZNIrrep{3}
 const Z4Irrep = ZNIrrep{4}
 
-Base.one(::Type{ZNIrrep{N}}) where {N} = ZNIrrep{N}(0)
-Base.conj(c::ZNIrrep{N}) where {N} = ZNIrrep{N}(-c.n)
+unit(::Type{ZNIrrep{N}}) where {N} = ZNIrrep{N}(0)
+dual(c::ZNIrrep{N}) where {N} = ZNIrrep{N}(-c.n)
 ⊗(c1::ZNIrrep{N}, c2::ZNIrrep{N}) where {N} = (ZNIrrep{N}(c1.n + c2.n),)
 
 Base.IteratorSize(::Type{SectorValues{ZNIrrep{N}}}) where {N} = HasLength()