add unitspace

Author: borisdevos

docs/src/lib/spaces.md

@@ -92,7 +92,7 @@ flip
 ⊕
 ⊖
 zero(::ElementarySpace)
-oneunit
+unitspace
 supremum
 infimum
 ```

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/spaces/cartesianspace.jl

@@ -47,7 +47,7 @@ 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)
+unitspace(::Type{CartesianSpace}) = CartesianSpace(1)
 Base.zero(::Type{CartesianSpace}) = CartesianSpace(0)
 
 ⊕(V₁::CartesianSpace, V₂::CartesianSpace) = CartesianSpace(V₁.d + V₂.d)

src/spaces/complexspace.jl

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

src/spaces/generalspace.jl

@@ -35,7 +35,7 @@ sectortype(::Type{<:GeneralSpace}) = Trivial
 field(::Type{GeneralSpace{𝔽}}) where {𝔽} = 𝔽
 InnerProductStyle(::Type{<:GeneralSpace}) = NoInnerProduct()
 
-Base.oneunit(::Type{GeneralSpace{𝔽}}) where {𝔽} = GeneralSpace{𝔽}(1, false, false)
+unitspace(::Type{GeneralSpace{𝔽}}) where {𝔽} = GeneralSpace{𝔽}(1, false, false)
 Base.zero(::Type{GeneralSpace{𝔽}}) where {𝔽} = GeneralSpace{𝔽}(0, false, false)
 
 dual(V::GeneralSpace{𝔽}) where {𝔽} = GeneralSpace{𝔽}(dim(V), !isdual(V), isconj(V))

src/spaces/gradedspace.jl

@@ -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
-
-Base.oneunit(S::Type{<:GradedSpace{I}}) where {I <: Sector} = S(one(I) => 1)
-Base.zero(S::Type{<:GradedSpace{I}}) where {I <: Sector} = S(one(I) => 0)
+#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)
 
 # 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

@@ -230,6 +230,7 @@ end
 Return a tensor product of zero spaces of type `S`, i.e. this is the unit object under the
 tensor product operation, such that `V ⊗ one(V) == V`.
 """
+#TODO: unit(V::S)?
 Base.one(V::VectorSpace) = one(typeof(V))
 Base.one(::Type{<:ProductSpace{S}}) where {S <: ElementarySpace} = ProductSpace{S, 0}(())
 Base.one(::Type{S}) where {S <: ElementarySpace} = ProductSpace{S, 0}(())
@@ -240,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} = oneunit(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)
@@ -252,10 +253,9 @@ 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}
-    u = oneunit(spacetype(P))
+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)
     end
@@ -274,10 +274,9 @@ 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}
-    u = oneunit(spacetype(P))
+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)
     end
@@ -299,7 +298,7 @@ and [`insertrightunit`](@ref insertrightunit(::ProductSpace, ::Val{i}) where {i}
 """
 function removeunit(P::ProductSpace, ::Val{i}) where {i}
     1 ≤ i ≤ length(P) || _boundserror(P, i)
-    isisomorphic(P[i], oneunit(P[i])) || _nontrivialspaceerror(P, i)
+    isisomorphic(P[i], unitspace(P[i])) || _nontrivialspaceerror(P, i)
     return ProductSpace{spacetype(P)}(TupleTools.deleteat(P.spaces, i))
 end
 
@@ -326,8 +325,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} = oneunit(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/spaces/vectorspaces.jl

@@ -80,7 +80,7 @@ Base.adjoint(V::VectorSpace) = dual(V)
 """
     isdual(V::ElementarySpace) -> Bool
 
-Return wether an ElementarySpace `V` is normal or rather a dual space. Always returns
+Return whether an ElementarySpace `V` is normal or rather a dual space. Always returns
 `false` for spaces where `V == dual(V)`.
 """
 function isdual end
@@ -120,21 +120,23 @@ Return the sum of all degeneracy dimensions of the vector space `V`.
 reduceddim(V::ElementarySpace) = sum(Base.Fix1(dim, V), sectors(V); init = 0)
 
 """
-    oneunit(V::S) where {S<:ElementarySpace} -> S
+    unitspace(V::S) where {S<:ElementarySpace} -> S
 
 Return the corresponding vector space of type `S` that represents the trivial
 one-dimensional space, i.e. the space that is isomorphic to the corresponding field. Note
 that this is different from `one(V::S)`, which returns the empty product space
-`ProductSpace{S,0}(())`.
+`ProductSpace{S,0}(())`. `Base.oneunit` falls back to `unitspace`.
 """
-Base.oneunit(V::ElementarySpace) = oneunit(typeof(V))
+unitspace(V::ElementarySpace) = unitspace(typeof(V))
+Base.oneunit(V::ElementarySpace) = unitspace(V)
 
 """
     zero(V::S) where {S<:ElementarySpace} -> S
 
 Return the corresponding vector space of type `S` that represents the zero-dimensional or empty space.
 This is, with a slight abuse of notation, the zero element of the direct sum of vector spaces. 
 """
+#TODO: zerospace?
 Base.zero(V::ElementarySpace) = zero(typeof(V))
 
 """