[WIP] Generalising functions to support GenericUnit

Project.toml

@@ -33,7 +33,7 @@ LinearAlgebra = "1"
 PackageExtensionCompat = "1"
 Random = "1"
 Strided = "2"
-TensorKitSectors = "0.1.4, 0.2"
+TensorKitSectors = "0.3"
 TensorOperations = "5.1"
 Test = "1"
 TestExtras = "0.2,0.3"

docs/src/lib/spaces.md

@@ -91,7 +91,7 @@ conj
 flip
 ⊕
 zero(::ElementarySpace)
-oneunit
+unitspace
 supremum
 infimum
 ```
@@ -111,9 +111,9 @@ isisomorphic
 Inserting trivial space factors or removing such factors for `ProductSpace` instances
 can be done with the following methods.
 ```@docs
-insertleftunit(::ProductSpace, ::Val{i}) where {i}
-insertrightunit(::ProductSpace, ::Val{i}) where {i}
-removeunit(::ProductSpace, ::Val{i}) where {i}
+insertleftunitspace(::ProductSpace, ::Val{i}) where {i}
+insertrightunitspace(::ProductSpace, ::Val{i}) where {i}
+removeunitspace(::ProductSpace, ::Val{i}) where {i}
 ```
 
 There are also specific methods for `HomSpace` instances, that are used in determining
@@ -124,7 +124,7 @@ flip(W::HomSpace{S}, I) where {S}
 TensorKit.permute(::HomSpace{S}, ::Index2Tuple{N₁,N₂}) where {S,N₁,N₂}
 TensorKit.select(::HomSpace{S}, ::Index2Tuple{N₁,N₂}) where {S,N₁,N₂}
 TensorKit.compose(::HomSpace{S}, ::HomSpace{S}) where {S}
-insertleftunit(::HomSpace, ::Val{i}) where {i}
-insertrightunit(::HomSpace, ::Val{i}) where {i}
-removeunit(::HomSpace, ::Val{i}) where {i}
+insertleftunitspace(::HomSpace, ::Val{i}) where {i}
+insertrightunitspace(::HomSpace, ::Val{i}) where {i}
+removeunitspace(::HomSpace, ::Val{i}) where {i}
 ```

docs/src/lib/tensors.md

@@ -184,9 +184,9 @@ transpose(::AbstractTensorMap, ::Index2Tuple)
 repartition(::AbstractTensorMap, ::Int, ::Int)
 flip(t::AbstractTensorMap, I)
 twist(::AbstractTensorMap, ::Int)
-insertleftunit(::AbstractTensorMap, ::Val{i}) where {i}
-insertrightunit(::AbstractTensorMap, ::Val{i}) where {i}
-removeunit(::AbstractTensorMap, ::Val{i}) where {i}
+insertleftunitspace(::AbstractTensorMap, ::Val{i}) where {i}
+insertrightunitspace(::AbstractTensorMap, ::Val{i}) where {i}
+removeunitspace(::AbstractTensorMap, ::Val{i}) where {i}
 ```
 
 ```@docs

docs/src/man/spaces.md

@@ -316,19 +316,18 @@ flip(ℂ^4) == ℂ^4
 ```
 
 We also define the direct sum `V1` and `V2` as `V1 ⊕ V2`, where `⊕` is obtained by typing
-`\oplus`+TAB. This is possible only if `isdual(V1) == isdual(V2)`. With a little pun on
-Julia Base, `oneunit` applied to an elementary space (in the value or type domain) returns
-the one-dimensional space, which is isomorphic to the scalar field of the space itself. Some
-examples illustrate this better
+`\oplus`+TAB. This is possible only if `isdual(V1) == isdual(V2)`. `unitspace` applied to an elementary space 
+(in the value or type domain) returns the one-dimensional space, which is isomorphic to the 
+scalar field of the space itself. Some examples illustrate this better.
 ```@repl tensorkit
 ℝ^5 ⊕ ℝ^3
 ℂ^5 ⊕ ℂ^3
 ℂ^5 ⊕ (ℂ^3)'
-oneunit(ℝ^3)
-ℂ^5 ⊕ oneunit(ComplexSpace)
-oneunit((ℂ^3)')
-(ℂ^5) ⊕ oneunit((ℂ^5))
-(ℂ^5)' ⊕ oneunit((ℂ^5)')
+unitspace(ℝ^3)
+ℂ^5 ⊕ unitspace(ComplexSpace)
+unitspace((ℂ^3)')
+(ℂ^5) ⊕ unitspace((ℂ^5))
+(ℂ^5)' ⊕ unitspace((ℂ^5)')
 ```
 
 Finally, while spaces have a partial order, there is no unique infimum or supremum of a two

src/TensorKit.jl

@@ -11,13 +11,16 @@ module TensorKit
 export Sector, AbstractIrrep, Irrep
 export FusionStyle, UniqueFusion, MultipleFusion, MultiplicityFreeFusion,
        SimpleFusion, GenericFusion
+export UnitStyle, SimpleUnit, GenericUnit
 export BraidingStyle, SymmetricBraiding, Bosonic, Fermionic, Anyonic, NoBraiding
 export Trivial, Z2Irrep, Z3Irrep, Z4Irrep, ZNIrrep, U1Irrep, SU2Irrep, CU1Irrep
 export ProductSector
 export FermionParity, FermionNumber, FermionSpin
-export FibonacciAnyon, IsingAnyon
+export FibonacciAnyon, IsingAnyon, IsingBimodule
+export unit, rightunit, leftunit, allunits, isunit
 
 export VectorSpace, Field, ElementarySpace # abstract vector spaces
+export unitspace, zerospace, leftunitspace, rightunitspace
 export InnerProductStyle, NoInnerProduct, HasInnerProduct, EuclideanInnerProduct
 export ComplexSpace, CartesianSpace, GeneralSpace, GradedSpace # concrete spaces
 export ZNSpace, Z2Space, Z3Space, Z4Space, U1Space, CU1Space, SU2Space
@@ -32,7 +35,7 @@ export SpaceMismatch, SectorMismatch, IndexError # error types
 
 # general vector space methods
 export space, field, dual, dim, reduceddim, dims, fuse, flip, isdual, oplus,
-       insertleftunit, insertrightunit, removeunit
+       insertleftunitspace, insertrightunitspace, removeunitspace
 
 # partial order for vector spaces
 export infimum, supremum, isisomorphic, ismonomorphic, isepimorphic

src/auxiliary/deprecate.jl

@@ -56,6 +56,6 @@ end
 
 Base.@deprecate EuclideanProduct() EuclideanInnerProduct()
 
-Base.@deprecate insertunit(P::ProductSpace, args...; kwargs...) insertleftunit(args...; kwargs...)
+Base.@deprecate insertunit(P::ProductSpace, args...; kwargs...) insertleftunitspace(args...; kwargs...)
 
 #! format: on

src/fusiontrees/fusiontrees.jl

@@ -32,7 +32,7 @@ struct FusionTree{I<:Sector,N,M,L}
                                  vertices::NTuple{L,Int}) where
              {I<:Sector,N,M,L}
         # if N == 0
-        #     @assert coupled == one(coupled)
+        #     @assert coupled == unit(coupled)
         # elseif N == 1
         #     @assert coupled == uncoupled[1]
         # elseif N == 2
@@ -78,7 +78,7 @@ function FusionTree(uncoupled::NTuple{N,I}, coupled::I,
     end
 end
 
-function FusionTree{I}(uncoupled::NTuple{N}, coupled=one(I),
+function FusionTree{I}(uncoupled::NTuple{N}, coupled=unit(I),
                        isdual=ntuple(n -> false, N)) where {I<:Sector,N}
     FusionStyle(I) isa UniqueFusion ||
         error("fusion tree requires inner lines if `FusionStyle(I) <: MultipleFusion`")
@@ -90,7 +90,7 @@ function FusionTree(uncoupled::NTuple{N,I}, coupled::I,
                     isdual=ntuple(n -> false, length(uncoupled))) where {N,I<:Sector}
     return FusionTree{I}(uncoupled, coupled, isdual)
 end
-FusionTree(uncoupled::Tuple{I,Vararg{I}}) where {I<:Sector} = FusionTree(uncoupled, one(I))
+FusionTree(uncoupled::Tuple{I,Vararg{I}}) where {I<:Sector} = FusionTree(uncoupled, unit(I))
 
 # Properties
 sectortype(::Type{<:FusionTree{I}}) where {I<:Sector} = I
@@ -146,17 +146,17 @@ end
 
 # converting to actual array
 function Base.convert(A::Type{<:AbstractArray}, f::FusionTree{I,0}) where {I}
-    X = convert(A, fusiontensor(one(I), one(I), one(I)))[1, 1, :]
+    X = convert(A, fusiontensor(unit(I), unit(I), unit(I)))[1, 1, :]
     return X
 end
 function Base.convert(A::Type{<:AbstractArray}, f::FusionTree{I,1}) where {I}
     c = f.coupled
     if f.isdual[1]
         sqrtdc = sqrtdim(c)
-        Zcbartranspose = sqrtdc * convert(A, fusiontensor(conj(c), c, one(c)))[:, :, 1, 1]
+        Zcbartranspose = sqrtdc * convert(A, fusiontensor(dual(c), c, unit(c)))[:, :, 1, 1]
         X = conj!(Zcbartranspose) # we want Zcbar^†
     else
-        X = convert(A, fusiontensor(c, one(c), c))[:, 1, :, 1, 1]
+        X = convert(A, fusiontensor(c, unit(c), c))[:, 1, :, 1, 1]
     end
     return X
 end
@@ -234,13 +234,13 @@ include("iterator.jl")
 # _abelianinner: generate the inner indices for given outer indices in the abelian case
 _abelianinner(outer::Tuple{}) = ()
 function _abelianinner(outer::Tuple{I}) where {I<:Sector}
-    return isone(outer[1]) ? () : throw(SectorMismatch())
+    return isunit(outer[1]) ? () : throw(SectorMismatch())
 end
 function _abelianinner(outer::Tuple{I,I}) where {I<:Sector}
     return outer[1] == dual(outer[2]) ? () : throw(SectorMismatch())
 end
 function _abelianinner(outer::Tuple{I,I,I}) where {I<:Sector}
-    return isone(first(⊗(outer...))) ? () : throw(SectorMismatch())
+    return isunit(first(⊗(outer...))) ? () : throw(SectorMismatch())
 end
 function _abelianinner(outer::Tuple{I,I,I,I,Vararg{I}}) where {I<:Sector}
     c = first(outer[1] ⊗ outer[2])

src/fusiontrees/iterator.jl

@@ -1,6 +1,6 @@
 """
     fusiontrees(uncoupled::NTuple{N,I}[,
-        coupled::I=one(I)[, isdual::NTuple{N,Bool}=ntuple(n -> false, length(uncoupled))]])
+        coupled::I=unit(I)[, isdual::NTuple{N,Bool}=ntuple(n -> false, length(uncoupled))]])
         where {N,I<:Sector} -> FusionTreeIterator{I,N,I}
 
 Return an iterator over all fusion trees with a given coupled sector label `coupled` and
@@ -16,7 +16,7 @@ function fusiontrees(uncoupled::Tuple{Vararg{I}}, coupled::I) where {I<:Sector}
     return fusiontrees(uncoupled, coupled, isdual)
 end
 function fusiontrees(uncoupled::Tuple{I,Vararg{I}}) where {I<:Sector}
-    coupled = one(I)
+    coupled = unit(I)
     isdual = ntuple(n -> false, length(uncoupled))
     return fusiontrees(uncoupled, coupled, isdual)
 end
@@ -37,7 +37,7 @@ Base.IteratorEltype(::FusionTreeIterator) = Base.HasEltype()
 Base.eltype(::Type{<:FusionTreeIterator{I,N}}) where {I<:Sector,N} = fusiontreetype(I, N)
 
 Base.length(iter::FusionTreeIterator) = _fusiondim(iter.uncouplediterators, iter.coupled)
-_fusiondim(::Tuple{}, c::I) where {I<:Sector} = Int(isone(c))
+_fusiondim(::Tuple{}, c::I) where {I<:Sector} = Int(isunit(c))
 _fusiondim(iters::NTuple{1}, c::I) where {I<:Sector} = Int(c ∈ iters[1])
 function _fusiondim(iters::NTuple{2}, c::I) where {I<:Sector}
     d = 0
@@ -60,7 +60,7 @@ end
 # * Iterator methods:
 #   Start with special cases:
 function Base.iterate(it::FusionTreeIterator{I,0},
-                      state=!isone(it.coupled)) where {I<:Sector}
+                      state=!isunit(it.coupled)) where {I<:Sector}
     state && return nothing
     tree = FusionTree{I}((), it.coupled, (), (), ())
     return tree, true

src/fusiontrees/manipulations.jl

@@ -165,7 +165,7 @@ operation is the inverse of `insertat` in the sense that if
         f₂ = FusionTree{I}(f.uncoupled, f.coupled, isdual2, f.innerlines, f.vertices)
         return f₁, f₂
     elseif M === 0
-        u = leftone(f.uncoupled[1])
+        u = leftunit(f.uncoupled[1])
         f₁ = FusionTree{I}((), u, (), ())
         uncoupled2 = (u, f.uncoupled...)
         coupled2 = f.coupled
@@ -290,7 +290,7 @@ function bendright(f₁::FusionTree{I,N₁}, f₂::FusionTree{I,N₂}) where {I<
     # map final splitting vertex (a, b)<-c to fusion vertex a<-(c, dual(b))
     @assert N₁ > 0
     c = f₁.coupled
-    a = N₁ == 1 ? leftone(f₁.uncoupled[1]) :
+    a = N₁ == 1 ? leftunit(f₁.uncoupled[1]) :
         (N₁ == 2 ? f₁.uncoupled[1] : f₁.innerlines[end])
     b = f₁.uncoupled[N₁]
 
@@ -362,7 +362,7 @@ function foldright(f₁::FusionTree{I,N₁}, f₂::FusionTree{I,N₂}) where {I<
         hasmultiplicities = FusionStyle(a) isa GenericFusion
         local newtrees
         if N₁ == 1
-            cset = (leftone(c1),) # or rightone(a)
+            cset = (leftunit(c1),) # or rightunit(a)
         elseif N₁ == 2
             cset = (f₁.uncoupled[2],)
         else
@@ -373,7 +373,7 @@ function foldright(f₁::FusionTree{I,N₁}, f₂::FusionTree{I,N₂}) where {I<
             for μ in 1:Nsymbol(c1, c2, c)
                 fc = FusionTree((c1, c2), c, (!isduala, false), (), (μ,))
                 for (fl′, coeff1) in insertat(fc, 2, f₁)
-                    N₁ > 1 && !isone(fl′.innerlines[1]) && continue
+                    N₁ > 1 && !isunit(fl′.innerlines[1]) && continue
                     coupled = fl′.coupled
                     uncoupled = Base.tail(Base.tail(fl′.uncoupled))
                     isdual = Base.tail(Base.tail(fl′.isdual))
@@ -718,7 +718,7 @@ corresponding coefficients.
 function elementary_trace(f::FusionTree{I,N}, i) where {I<:Sector,N}
     (N > 1 && 1 <= i <= N) ||
         throw(ArgumentError("Cannot trace outputs i=$i and i+1 out of only $N outputs"))
-    i < N || isone(f.coupled) ||
+    i < N || isunit(f.coupled) ||
         throw(ArgumentError("Cannot trace outputs i=$N and 1 of fusion tree that couples to non-trivial sector"))
 
     T = sectorscalartype(I)
@@ -731,7 +731,7 @@ function elementary_trace(f::FusionTree{I,N}, i) where {I<:Sector,N}
     # if trace is zero, return empty dict
     (b == dual(b′) && f.isdual[i] != f.isdual[j]) || return newtrees
     if i < N
-        inner_extended = (leftone(f.uncoupled[1]), f.uncoupled[1], f.innerlines...,
+        inner_extended = (leftunit(f.uncoupled[1]), f.uncoupled[1], f.innerlines...,
                           f.coupled)
         a = inner_extended[i]
         d = inner_extended[i + 2]
@@ -756,11 +756,11 @@ function elementary_trace(f::FusionTree{I,N}, i) where {I<:Sector,N}
         if i > 1
             c = f.innerlines[i - 1]
             if FusionStyle(I) isa MultiplicityFreeFusion
-                coeff *= Fsymbol(a, b, dual(b), a, c, rightone(a))
+                coeff *= Fsymbol(a, b, dual(b), a, c, rightunit(a))
             else
                 μ = f.vertices[i - 1]
                 ν = f.vertices[i]
-                coeff *= Fsymbol(a, b, dual(b), a, c, rightone(a))[μ, ν, 1, 1]
+                coeff *= Fsymbol(a, b, dual(b), a, c, rightunit(a))[μ, ν, 1, 1]
             end
         end
         if f.isdual[i]
@@ -769,7 +769,7 @@ function elementary_trace(f::FusionTree{I,N}, i) where {I<:Sector,N}
         push!(newtrees, f′ => coeff)
         return newtrees
     else # i == N
-        unit = leftone(b)
+        unit = leftunit(b)
         if N == 2
             f′ = FusionTree{I}((), unit, (), (), ())
             coeff = sqrtdim(b)
@@ -786,13 +786,13 @@ function elementary_trace(f::FusionTree{I,N}, i) where {I<:Sector,N}
         vertices_ = TupleTools.front(f.vertices)
         f_ = FusionTree(uncoupled_, coupled_, isdual_, inner_, vertices_)
         fs = FusionTree((b,), b, (!f.isdual[1],), (), ())
-        for (f_′, coeff) in merge(fs, f_, unit, 1) # coloring gets reversed here, should be the other unit
+        for (f_′, coeff) in merge(fs, f_, unit, 1)
             f_′.innerlines[1] == unit || continue
             uncoupled′ = Base.tail(Base.tail(f_′.uncoupled))
             isdual′ = Base.tail(Base.tail(f_′.isdual))
             inner′ = N <= 4 ? () : Base.tail(Base.tail(f_′.innerlines))
             vertices′ = N <= 3 ? () : Base.tail(Base.tail(f_′.vertices))
-            f′ = FusionTree(uncoupled′, unit, isdual′, inner′, vertices′) # and this one?
+            f′ = FusionTree(uncoupled′, unit, isdual′, inner′, vertices′)
             coeff *= sqrtdim(b)
             if !(f.isdual[N])
                 coeff *= conj(frobeniusschur(b))
@@ -835,13 +835,13 @@ function artin_braid(f::FusionTree{I,N}, i; inv::Bool=false) where {I<:Sector,N}
     vertices = f.vertices
     oneT = one(sectorscalartype(I))
 
-    if isone(uncoupled[i]) || isone(uncoupled[i + 1])
+    if isunit(a) || isunit(b)
         # braiding with trivial sector: simple and always possible
         inner′ = inner
         vertices′ = vertices
         if i > 1 # we also need to alter innerlines and vertices
             inner′ = TupleTools.setindex(inner,
-                                         inner_extended[isone(a) ? (i + 1) : (i - 1)],
+                                         inner_extended[isunit(a) ? (i + 1) : (i - 1)],
                                          i - 1)
             vertices′ = TupleTools.setindex(vertices′, vertices[i], i - 1)
             vertices′ = TupleTools.setindex(vertices′, vertices[i - 1], i)
@@ -898,7 +898,7 @@ function artin_braid(f::FusionTree{I,N}, i; inv::Bool=false) where {I<:Sector,N}
         return fusiontreedict(I)(f′ => coeff)
     elseif FusionStyle(I) isa SimpleFusion
         local newtrees
-        for c′ in intersect(a ⊗ d, e ⊗ conj(b))
+        for c′ in intersect(a ⊗ d, e ⊗ dual(b))
             coeff = oftype(oneT,
                            if inv
                                conj(Rsymbol(d, c, e) * Fsymbol(d, a, b, e, c′, c)) *
@@ -919,7 +919,7 @@ function artin_braid(f::FusionTree{I,N}, i; inv::Bool=false) where {I<:Sector,N}
         return newtrees
     else # GenericFusion
         local newtrees
-        for c′ in intersect(a ⊗ d, e ⊗ conj(b))
+        for c′ in intersect(a ⊗ d, e ⊗ dual(b))
             Rmat1 = inv ? Rsymbol(d, c, e)' : Rsymbol(c, d, e)
             Rmat2 = inv ? Rsymbol(d, a, c′)' : Rsymbol(a, d, c′)
             Fmat = Fsymbol(d, a, b, e, c′, c)

src/spaces/cartesianspace.jl

@@ -47,8 +47,8 @@ hassector(V::CartesianSpace, ::Trivial) = dim(V) != 0
 sectors(V::CartesianSpace) = OneOrNoneIterator(dim(V) != 0, Trivial())
 sectortype(::Type{CartesianSpace}) = Trivial
 
-Base.oneunit(::Type{CartesianSpace}) = CartesianSpace(1)
-Base.zero(::Type{CartesianSpace}) = CartesianSpace(0)
+unitspace(::Type{CartesianSpace}) = CartesianSpace(1)
+zerospace(::Type{CartesianSpace}) = CartesianSpace(0)
 ⊕(V₁::CartesianSpace, V₂::CartesianSpace) = CartesianSpace(V₁.d + V₂.d)
 fuse(V₁::CartesianSpace, V₂::CartesianSpace) = CartesianSpace(V₁.d * V₂.d)
 flip(V::CartesianSpace) = V

src/spaces/complexspace.jl

@@ -48,8 +48,8 @@ sectortype(::Type{ComplexSpace}) = Trivial
 
 Base.conj(V::ComplexSpace) = ComplexSpace(dim(V), !isdual(V))
 
-Base.oneunit(::Type{ComplexSpace}) = ComplexSpace(1)
-Base.zero(::Type{ComplexSpace}) = ComplexSpace(0)
+unitspace(::Type{ComplexSpace}) = ComplexSpace(1)
+zerospace(::Type{ComplexSpace}) = ComplexSpace(0)
 function ⊕(V₁::ComplexSpace, V₂::ComplexSpace)
     return isdual(V₁) == isdual(V₂) ?
            ComplexSpace(dim(V₁) + dim(V₂), isdual(V₁)) :

src/spaces/deligne.jl

@@ -23,28 +23,28 @@ function ⊠(V::GradedSpace, P₀::ProductSpace{<:ElementarySpace,0})
     field(V) == field(P₀) || throw_incompatible_fields(V, P₀)
     I₁ = sectortype(V)
     I₂ = sectortype(P₀)
-    return Vect[I₁ ⊠ I₂](ifelse(isdual(V), dual(c), c) ⊠ one(I₂) => dim(V, c)
+    return Vect[I₁ ⊠ I₂](ifelse(isdual(V), dual(c), c) ⊠ unit(I₂) => dim(V, c)
                          for c in sectors(V); dual=isdual(V))
 end
 
 function ⊠(P₀::ProductSpace{<:ElementarySpace,0}, V::GradedSpace)
     field(P₀) == field(V) || throw_incompatible_fields(P₀, V)
     I₁ = sectortype(P₀)
     I₂ = sectortype(V)
-    return Vect[I₁ ⊠ I₂](one(I₁) ⊠ ifelse(isdual(V), dual(c), c) => dim(V, c)
+    return Vect[I₁ ⊠ I₂](unit(I₁) ⊠ ifelse(isdual(V), dual(c), c) => dim(V, c)
                          for c in sectors(V); dual=isdual(V))
 end
 
 function ⊠(V::ComplexSpace, P₀::ProductSpace{<:ElementarySpace,0})
     field(V) == field(P₀) || throw_incompatible_fields(V, P₀)
     I₂ = sectortype(P₀)
-    return Vect[I₂](one(I₂) => dim(V); dual=isdual(V))
+    return Vect[I₂](unit(I₂) => dim(V); dual=isdual(V))
 end
 
 function ⊠(P₀::ProductSpace{<:ElementarySpace,0}, V::ComplexSpace)
     field(P₀) == field(V) || throw_incompatible_fields(P₀, V)
     I₁ = sectortype(P₀)
-    return Vect[I₁](one(I₁) => dim(V); dual=isdual(V))
+    return Vect[I₁](unit(I₁) => dim(V); dual=isdual(V))
 end
 
 function ⊠(P::ProductSpace{<:ElementarySpace,0}, P₀::ProductSpace{<:ElementarySpace,0})