one -> unit + left/rightone -> left/rightunit + isone -> isunit when concerning sectors + some more unitspace

Author: borisdevos

src/fusiontrees/fusiontrees.jl

@@ -34,7 +34,7 @@ struct FusionTree{I <: Sector, N, M, L}
         ) 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
@@ -89,7 +89,7 @@ function FusionTree(
 end
 
 function FusionTree{I}(
-        uncoupled::NTuple{N}, coupled = one(I), isdual = ntuple(n -> false, N)
+        uncoupled::NTuple{N}, coupled = unit(I), isdual = ntuple(Returns(false), N)
     ) where {I <: Sector, N}
     FusionStyle(I) isa UniqueFusion ||
         error("fusion tree requires inner lines if `FusionStyle(I) <: MultipleFusion`")
@@ -103,7 +103,7 @@ function FusionTree(
     ) 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
@@ -159,17 +159,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]
+        sqrtdc = sqrtdim(c) # TODO: change conj to dual
+        Zcbartranspose = sqrtdc * convert(A, fusiontensor(conj(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
@@ -257,13 +257,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
@@ -17,7 +17,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
@@ -38,7 +38,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}
+function Base.iterate(it::FusionTreeIterator{I, 0}, 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
@@ -286,7 +286,7 @@ function bendright(f₁::FusionTree{I, N₁}, f₂::FusionTree{I, N₂}) where {
     # 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₁]
 
@@ -358,7 +358,7 @@ function foldright(f₁::FusionTree{I, N₁}, f₂::FusionTree{I, N₂}) where {
         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
@@ -369,7 +369,7 @@ function foldright(f₁::FusionTree{I, N₁}, f₂::FusionTree{I, N₂}) where {
             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))
@@ -722,7 +722,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)
@@ -735,7 +735,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..., f.coupled)
+        inner_extended = (leftunit(f.uncoupled[1]), f.uncoupled[1], f.innerlines..., f.coupled)
         a = inner_extended[i]
         d = inner_extended[i + 2]
         a == d || return newtrees
@@ -759,11 +759,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]
@@ -772,7 +772,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)
@@ -838,14 +838,14 @@ function artin_braid(f::FusionTree{I, N}, i; inv::Bool = false) where {I <: Sect
     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)

src/spaces/deligne.jl

@@ -24,7 +24,7 @@ function ⊠(V::GradedSpace, P₀::ProductSpace{<:ElementarySpace, 0})
     I₁ = sectortype(V)
     I₂ = sectortype(P₀)
     return Vect[I₁ ⊠ I₂](
-        ifelse(isdual(V), dual(c), c) ⊠ one(I₂) => dim(V, c)
+        ifelse(isdual(V), dual(c), c) ⊠ unit(I₂) => dim(V, c)
             for c in sectors(V); dual = isdual(V)
     )
 end
@@ -34,21 +34,21 @@ function ⊠(P₀::ProductSpace{<:ElementarySpace, 0}, V::GradedSpace)
     I₁ = sectortype(P₀)
     I₂ = sectortype(V)
     return Vect[I₁ ⊠ I₂](
-        one(I₁) ⊠ ifelse(isdual(V), dual(c), c) => dim(V, c)
+        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})

src/spaces/gradedspace.jl

@@ -94,7 +94,7 @@ InnerProductStyle(::Type{<:GradedSpace}) = EuclideanInnerProduct()
 function dim(V::GradedSpace)
     return reduce(
         +, dim(V, c) * dim(c) for c in sectors(V);
-        init = zero(dim(one(sectortype(V))))
+        init = zero(dim(unit(sectortype(V))))
     )
 end
 function dim(V::GradedSpace{I, <:AbstractDict}, c::I) where {I <: Sector}
@@ -133,9 +133,9 @@ function Base.axes(V::GradedSpace{I}, c::I) where {I <: Sector}
     end
     return (offset + 1):(offset + dim(c) * dim(V, c))
 end
-#TODO: one -> unit
-unitspace(S::Type{<:GradedSpace{I}}) where {I<:Sector} = S(one(I) => 1)
-Base.zero(S::Type{<:GradedSpace{I}}) where {I<:Sector} = S(one(I) => 0)
+
+unitspace(S::Type{<:GradedSpace{I}}) where {I <: Sector} = S(unit(I) => 1)
+Base.zero(S::Type{<:GradedSpace{I}}) where {I <: Sector} = S(unit(I) => 0)
 
 # TODO: the following methods can probably be implemented more efficiently for
 # `FiniteGradedSpace`, but we don't expect them to be used often in hot loops, so

src/spaces/productspace.jl

@@ -147,7 +147,7 @@ function blocksectors(P::ProductSpace{S, N}) where {S, N}
     end
     bs = Vector{I}()
     if N == 0
-        push!(bs, one(I))
+        push!(bs, unit(I))
     elseif N == 1
         for s in sectors(P)
             push!(bs, first(s))
@@ -241,8 +241,8 @@ function Base.literal_pow(::typeof(^), V::ElementarySpace, p::Val{N}) where {N}
     return ProductSpace{typeof(V), N}(ntuple(n -> V, p))
 end
 
-fuse(P::ProductSpace{S,0}) where {S<:ElementarySpace} = unitspace(S)
-fuse(P::ProductSpace{S}) where {S<:ElementarySpace} = fuse(P.spaces...)
+fuse(P::ProductSpace{S, 0}) where {S <: ElementarySpace} = unitspace(S)
+fuse(P::ProductSpace{S}) where {S <: ElementarySpace} = fuse(P.spaces...)
 
 """
     insertleftunit(P::ProductSpace, i::Int=length(P) + 1; conj=false, dual=false)
@@ -253,8 +253,10 @@ More specifically, adds a left monoidal unit or its dual.
 
 See also [`insertrightunit`](@ref insertrightunit(::ProductSpace, ::Val{i}) where {i}), [`removeunit`](@ref removeunit(::ProductSpace, ::Val{i}) where {i}).
 """
-function insertleftunit(P::ProductSpace, ::Val{i}=Val(length(P) + 1);
-                        conj::Bool=false, dual::Bool=false) where {i}
+function insertleftunit(
+        P::ProductSpace, ::Val{i} = Val(length(P) + 1);
+        conj::Bool = false, dual::Bool = false
+    ) where {i}
     u = unitspace(spacetype(P))
     if dual
         u = TensorKit.dual(u)
@@ -274,8 +276,10 @@ More specifically, adds a right monoidal unit or its dual.
 
 See also [`insertleftunit`](@ref insertleftunit(::ProductSpace, ::Val{i}) where {i}), [`removeunit`](@ref removeunit(::ProductSpace, ::Val{i}) where {i}).
 """
-function insertrightunit(P::ProductSpace, ::Val{i}=Val(length(P));
-                         conj::Bool=false, dual::Bool=false) where {i}
+function insertrightunit(
+        P::ProductSpace, ::Val{i} = Val(length(P));
+        conj::Bool = false, dual::Bool = false
+    ) where {i}
     u = unitspace(spacetype(P))
     if dual
         u = TensorKit.dual(u)
@@ -325,8 +329,8 @@ function Base.promote_rule(::Type{S}, ::Type{<:ProductSpace{S}}) where {S <: Ele
 end
 
 # ProductSpace to ElementarySpace
-Base.convert(::Type{S}, P::ProductSpace{S,0}) where {S<:ElementarySpace} = unitspace(S)
-Base.convert(::Type{S}, P::ProductSpace{S}) where {S<:ElementarySpace} = fuse(P.spaces...)
+Base.convert(::Type{S}, P::ProductSpace{S, 0}) where {S <: ElementarySpace} = unitspace(S)
+Base.convert(::Type{S}, P::ProductSpace{S}) where {S <: ElementarySpace} = fuse(P.spaces...)
 
 # ElementarySpace to ProductSpace
 Base.convert(::Type{<:ProductSpace}, V::S) where {S <: ElementarySpace} = ⊗(V)

src/tensors/braidingtensor.jl

@@ -366,7 +366,7 @@ end
 #         rmul!(C, β)
 #     end
 #     I = sectortype(B)
-#     u = one(I)
+#     u = unit(I)
 #     f₀ = FusionTree{I}((), u, (), (), ())
 #     braidingtensor_levels = A.adjoint ? (1, 2, 2, 1) : (2, 1, 1, 2)
 #     inv_braid = braidingtensor_levels[cindA[2]] > braidingtensor_levels[cindA[3]]
@@ -434,7 +434,7 @@ end
 #         rmul!(C, β)
 #     end
 #     I = sectortype(B)
-#     u = one(I)
+#     u = unit(I)
 #     f₀ = FusionTree{I}((), u, (), (), ())
 #     braidingtensor_levels = B.adjoint ? (1, 2, 2, 1) : (2, 1, 1, 2)
 #     inv_braid = braidingtensor_levels[cindB[2]] > braidingtensor_levels[cindB[3]]
@@ -501,7 +501,7 @@ end
 #         rmul!(C, β)
 #     end
 #     I = sectortype(B)
-#     u = one(I)
+#     u = unit(I)
 #     braidingtensor_levels = A.adjoint ? (1, 2, 2, 1) : (2, 1, 1, 2)
 #     inv_braid = braidingtensor_levels[cindA[2]] > braidingtensor_levels[cindA[3]]
 #     for (f₁, f₂) in fusiontrees(B)
@@ -563,7 +563,7 @@ end
 #         rmul!(C, β)
 #     end
 #     I = sectortype(B)
-#     u = one(I)
+#     u = unit(I)
 #     braidingtensor_levels = B.adjoint ? (1, 2, 2, 1) : (2, 1, 1, 2)
 #     inv_braid = braidingtensor_levels[cindB[2]] > braidingtensor_levels[cindB[3]]
 #     for (f₁, f₂) in fusiontrees(A)

src/tensors/linalg.jl

@@ -608,13 +608,13 @@ function ⊠(t1::AbstractTensorMap, t2::AbstractTensorMap)
     dom1 = domain(t1) ⊠ one(S2)
     t1′ = similar(t1, codom1 ← dom1)
     for (c, b) in blocks(t1)
-        copy!(block(t1′, c ⊠ one(I2)), b)
+        copy!(block(t1′, c ⊠ unit(I2)), b)
     end
     codom2 = one(S1) ⊠ codomain(t2)
     dom2 = one(S1) ⊠ domain(t2)
     t2′ = similar(t2, codom2 ← dom2)
     for (c, b) in blocks(t2)
-        copy!(block(t2′, one(I1) ⊠ c), b)
+        copy!(block(t2′, unit(I1) ⊠ c), b)
     end
     return t1′ ⊗ t2′
 end

src/tensors/tensor.jl

@@ -548,9 +548,9 @@ since it assumes a  uniquely defined coupled charge.
         throw(ArgumentError("Number of sectors does not match."))
     s₁ = TupleTools.getindices(sectors, codomainind(t))
     s₂ = map(dual, TupleTools.getindices(sectors, domainind(t)))
-    c1 = length(s₁) == 0 ? one(I) : (length(s₁) == 1 ? s₁[1] : first(⊗(s₁...)))
+    c1 = length(s₁) == 0 ? unit(I) : (length(s₁) == 1 ? s₁[1] : first(⊗(s₁...)))
     @boundscheck begin
-        c2 = length(s₂) == 0 ? one(I) : (length(s₂) == 1 ? s₂[1] : first(⊗(s₂...)))
+        c2 = length(s₂) == 0 ? unit(I) : (length(s₂) == 1 ? s₂[1] : first(⊗(s₂...)))
         c2 == c1 || throw(SectorMismatch("Not a valid sector for this tensor"))
         hassector(codomain(t), s₁) && hassector(domain(t), s₂)
     end

test/fusiontrees.jl

@@ -26,7 +26,7 @@ ti = time()
         @test eval(Meta.parse(sprint(show, f))) == f
     end
     @testset "Fusion tree $Istr: constructor properties" begin
-        u = one(I)
+        u = unit(I)
         @constinferred FusionTree((), u, (), (), ())
         @constinferred FusionTree((u,), u, (false,), (), ())
         @constinferred FusionTree((u, u), u, (false, false), (), (1,))
@@ -130,7 +130,7 @@ ti = time()
             outgoing = (s, dual(s), s, dual(s), s, dual(s))
             for bool in (true, false)
                 isdual = (bool, !bool, bool, !bool, bool, !bool)
-                for f in fusiontrees(outgoing, one(s), isdual)
+                for f in fusiontrees(outgoing, unit(s), isdual)
                     af = convert(Array, f)
                     T = eltype(af)
 
@@ -570,7 +570,7 @@ ti = time()
     @testset "Double fusion tree $Istr: planar trace" begin
         d1 = transpose(f1, f1, (N + 1, 1:N..., ((2N):-1:(N + 3))...), (N + 2,))
         f1front, = TK.split(f1, N - 1)
-        T = typeof(Fsymbol(one(I), one(I), one(I), one(I), one(I), one(I))[1, 1, 1, 1])
+        T = TensorKitSectors._Fscalartype(I)
         d2 = Dict{typeof((f1front, f1front)), T}()
         for ((f1′, f2′), coeff′) in d1
             for ((f1′′, f2′′), coeff′′) in