introduce zerospace to replace zero of a space

Author: borisdevos

src/TensorKit.jl

@@ -20,7 +20,7 @@ export FibonacciAnyon, IsingAnyon
 export unit, rightunit, leftunit, allunits, isunit
 
 export VectorSpace, Field, ElementarySpace # abstract vector spaces
-export unitspace
+export unitspace, zerospace
 export InnerProductStyle, NoInnerProduct, HasInnerProduct, EuclideanInnerProduct
 export ComplexSpace, CartesianSpace, GeneralSpace, GradedSpace # concrete spaces
 export ZNSpace, Z2Space, Z3Space, Z4Space, U1Space, CU1Space, SU2Space

src/spaces/cartesianspace.jl

@@ -48,8 +48,7 @@ sectors(V::CartesianSpace) = OneOrNoneIterator(dim(V) != 0, Trivial())
 sectortype(::Type{CartesianSpace}) = Trivial
 
 unitspace(::Type{CartesianSpace}) = CartesianSpace(1)
-Base.zero(::Type{CartesianSpace}) = CartesianSpace(0)
-
+zerospace(::Type{CartesianSpace}) = CartesianSpace(0)
 ⊕(V₁::CartesianSpace, V₂::CartesianSpace) = CartesianSpace(V₁.d + V₂.d)
 function ⊖(V::CartesianSpace, W::CartesianSpace)
     V ≿ W || throw(ArgumentError("$(W) is not a subspace of $(V)"))

src/spaces/complexspace.jl

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

src/spaces/generalspace.jl

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

src/spaces/gradedspace.jl

@@ -134,8 +134,8 @@ function Base.axes(V::GradedSpace{I}, c::I) where {I <: Sector}
     return (offset + 1):(offset + dim(c) * dim(V, c))
 end
 
-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)
+unitspace(S::Type{<:GradedSpace{I}}) where {I<:Sector} = S(unit(I) => 1)
+zerospace(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/homspace.jl

@@ -22,7 +22,7 @@ end
 function HomSpace(codomain::S, domain::S) where {S <: ElementarySpace}
     return HomSpace(⊗(codomain), ⊗(domain))
 end
-HomSpace(codomain::VectorSpace) = HomSpace(codomain, zero(codomain))
+HomSpace(codomain::VectorSpace) = HomSpace(codomain, zerospace(codomain))
 
 codomain(W::HomSpace) = W.codomain
 domain(W::HomSpace) = W.domain

src/spaces/vectorspaces.jl

@@ -129,15 +129,18 @@ that this is different from `one(V::S)`, which returns the empty product space
 """
 unitspace(V::ElementarySpace) = unitspace(typeof(V))
 Base.oneunit(V::ElementarySpace) = unitspace(V)
+#TODO: add for type
 
 """
-    zero(V::S) where {S<:ElementarySpace} -> S
+    zerospace(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. 
+This is, with a slight abuse of notation, the zero element of the direct sum of vector spaces.
+`Base.zero` falls back to `zerospace`.
 """
-#TODO: zerospace?
-Base.zero(V::ElementarySpace) = zero(typeof(V))
+zerospace(V::ElementarySpace) = zerospace(typeof(V))
+Base.zero(V::ElementarySpace) = zerospace(V)
+Base.zero(::Type{V}) where {V<:ElementarySpace} = zerospace(V)
 
 """
     ⊕(V₁::S, V₂::S, V₃::S...) where {S<:ElementarySpace} -> S

test/spaces.jl

@@ -65,14 +65,14 @@ println("------------------------------------")
         @test length(sectors(V)) == 1
         @test @constinferred(TensorKit.hassector(V, Trivial()))
         @test @constinferred(dim(V)) == d == @constinferred(dim(V, Trivial()))
-        @test dim(@constinferred(zero(V))) == 0
-        @test (sectors(zero(V))...,) == ()
+        @test dim(@constinferred(zerospace(V))) == 0
+        @test (sectors(zerospace(V))...,) == ()
         @test @constinferred(TensorKit.axes(V)) == Base.OneTo(d)
         @test ℝ^d == ℝ[](d) == CartesianSpace(d) == typeof(V)(d)
         W = @constinferred ℝ^1
         @test @constinferred(unitspace(V)) == W == unitspace(typeof(V))
-        @test @constinferred(zero(V)) == ℝ^0 == zero(typeof(V))
-        @test @constinferred(⊕(V, zero(V))) == V
+        @test @constinferred(zerospace(V)) == ℝ^0 == zerospace(typeof(V))
+        @test @constinferred(⊕(V, zerospace(V))) == V
         @test @constinferred(⊕(V, V)) == ℝ^(2d)
         @test @constinferred(⊕(V, unitspace(V))) == ℝ^(d + 1)
         @test @constinferred(⊕(V, V, V, V)) == ℝ^(4d)
@@ -111,14 +111,14 @@ println("------------------------------------")
         @test length(sectors(V)) == 1
         @test @constinferred(TensorKit.hassector(V, Trivial()))
         @test @constinferred(dim(V)) == d == @constinferred(dim(V, Trivial()))
-        @test dim(@constinferred(zero(V))) == 0
-        @test (sectors(zero(V))...,) == ()
+        @test dim(@constinferred(zerospace(V))) == 0
+        @test (sectors(zerospace(V))...,) == ()
         @test @constinferred(TensorKit.axes(V)) == Base.OneTo(d)
         @test ℂ^d == Vect[Trivial](d) == Vect[](Trivial() => d) == ℂ[](d) == typeof(V)(d)
         W = @constinferred ℂ^1
         @test @constinferred(unitspace(V)) == W == unitspace(typeof(V))
-        @test @constinferred(zero(V)) == ℂ^0 == zero(typeof(V))
-        @test @constinferred(⊕(V, zero(V))) == V
+        @test @constinferred(zerospace(V)) == ℂ^0 == zerospace(typeof(V))
+        @test @constinferred(⊕(V, zerospace(V))) == V
         @test @constinferred(⊕(V, V)) == ℂ^(2d)
         @test_throws SpaceMismatch (⊕(V, V'))
         # promote_except = ErrorException("promotion of types $(typeof(ℝ^d)) and " *
@@ -202,12 +202,12 @@ println("------------------------------------")
         @test eval(Meta.parse(sprint(show, V))) == V
         @test eval(Meta.parse(sprint(show, typeof(V)))) == typeof(V)
         # space with no sectors
-        @test dim(@constinferred(zero(V))) == 0
+        @test dim(@constinferred(zerospace(V))) == 0
         # space with a single sector
         W = @constinferred GradedSpace(unit(I) => 1)
         @test W == GradedSpace(unit(I) => 1, randsector(I) => 0)
         @test @constinferred(unitspace(V)) == W == unitspace(typeof(V))
-        @test @constinferred(zero(V)) == GradedSpace(unit(I) => 0)
+        @test @constinferred(zerospace(V)) == GradedSpace(unit(I) => 0)
         # randsector never returns trivial sector, so this cannot error
         @test_throws ArgumentError GradedSpace(unit(I) => 1, randsector(I) => 0, unit(I) => 3)
         @test eval(Meta.parse(sprint(show, W))) == W
@@ -228,7 +228,7 @@ println("------------------------------------")
         if hasfusiontensor(I)
             @test @constinferred(TensorKit.axes(V)) == Base.OneTo(dim(V))
         end
-        @test @constinferred(⊕(V, zero(V))) == V
+        @test @constinferred(⊕(V, zerospace(V))) == V
         @test @constinferred(⊕(V, V)) == Vect[I](c => 2dim(V, c) for c in sectors(V))
         @test @constinferred(⊕(V, V, V, V)) == Vect[I](c => 4dim(V, c) for c in sectors(V))
         @test @constinferred(⊕(V, oneunit(V))) == Vect[I](c => isunit(c) + dim(V, c) for c in sectors(V))

test/tensors.jl

@@ -80,7 +80,7 @@ for V in spacelist
                     end
                 end
                 for T in (Int, Float32, ComplexF64)
-                    t = randn(T, V1 ⊗ V2 ← zero(V1))
+                    t = randn(T, V1 ⊗ V2 ← zerospace(V1))
                     a = convert(Array, t)
                     @test norm(a) == 0
                 end