Vector spaces

Types

# Field
abstract type Field end
struct RealNumbers <: Field end
struct ComplexNumbers <: Field end
const ℝ = RealNumbers()
const ℂ = ComplexNumbers()

# Vector Space
abstract type VectorSpace end

## Elementary Space
abstract type ElementarySpace{𝕜} <: VectorSpace end
const IndexSpace = ElementarySpace
struct GeneralSpace{𝕜} <: ElementarySpace{𝕜}
    d::Int
    dual::Bool
    conj::Bool
end

abstract type InnerProductSpace{𝕜} <: ElementarySpace{𝕜} end
abstract type EuclideanSpace{𝕜} <: InnerProductSpace{𝕜} end
struct CartesianSpace <: EuclideanSpace{ℝ}
    d::Int
end
struct ComplexSpace <: EuclideanSpace{ℂ}
  d::Int
  dual::Bool
end
struct GradedSpace{I<:Sector, D} <: EuclideanSpace{ℂ}
    dims::D
    dual::Bool
end

# Composite Space
abstract type CompositeSpace{S<:ElementarySpace} <: VectorSpace end
struct ProductSpace{S<:ElementarySpace, N} <: CompositeSpace{S}
    spaces::NTuple{N, S}
end
const TensorSpace{S<:ElementarySpace} = Union{S, ProductSpace{S}}

# Space of Morphisms
struct HomSpace{S<:ElementarySpace, P1<:CompositeSpace{S}, P2<:CompositeSpace{S}}
    codomain::P1
    domain::P2
end
const TensorMapSpace{S<:ElementarySpace, N₁, N₂} = HomSpace{S, ProductSpace{S, N₁}, ProductSpace{S, N₂}}

Properties

On both VectorSpace instances and types:

spacetype # type of ElementarySpace associated with a composite space or a tensor or a HomSpace
field # field of a vector space or a tensor map or a HomSpace
Base.oneunit # the corresponding vector space that represents the trivial 1D space isomorphic to the corresponding field
sectortype # sector type of a space or a tensor or a HomSpace
one(::S) where {S<:ElementarySpace} -> ProductSpace{S, 0}
one(::ProductSpace{S}) where {S<:ElementarySpace} -> ProductSpace{S, 0}  # 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`.

On VectorSpace instances:

sectors # an iterator over the different sectors of an ElementarySpace
sectors(P::ProductSpace{S, N}) # Return an iterator over all possible combinations of sectors (represented as an `NTuple{N, sectortype(S)}`) that can appear within the tensor product space `P`.
blocksectors(V::ElementarySpace) = sectors(V) # make ElementarySpace instances behave similar to ProductSpace instances
blocksectors(P::ProductSpace) # Return an iterator over the different unique coupled sector labels
blocksectors(W::HomSpace) # Return an iterator over the different unique coupled sector labels, i.e. the intersection of the different fusion outputs that can be obtained by fusing the sectors present in the domain, as well as from the codomain.
blocksectors(t::TensorMap) # Return an iterator over the different unique coupled sector labels
dim # total dimension of a vector space or a product space
dim(V::ElementarySpace, ::Trivial) # return dim(V)
dim(V::GradedSpace, c::I) # the degeneracy or multiplicity of sector c in a Graded Space
dim(W::HomSpace) # Return the total dimension of a `HomSpace`, i.e. the number of linearly independent morphisms that can be constructed within this space.
dim(P::ProductSpace, n::Int) # dim for the `n`th vector space of the product space
dim(P::ProductSpace{S, N}, s::NTuple{N, sectortype(S)}) # Return the total degeneracy dimension corresponding to a tuple of sectors for each of the spaces in the tensor product, obtained as `prod(dims(P, s))``.
dim(t::AbstractTensorMap) # total dim for corresponding HomSpace
dim(t::TensorMap) # Return the total dimension of the tensor map, i.e., the number of elements in all DenseMatrix of the data.
dims(P::ProductSpace) # Return the dimensions of the spaces in the tensor product space as a tuple of integers.
dims(P::ProductSpace{S, N}, s::NTuple{N, sectortype(S)}) # Return the degeneracy dimensions corresponding to a tuple of sectors `s` for each of the spaces in the tensor product `P`.
blockdim(V::ElementarySpace, c::Sector) = dim(V, c) # make ElementarySpace instances behave similar to ProductSpace instances
blockdim(P::ProductSpace, c::Sector) # Return the total dimension of a coupled sector `c` in the product space
hassector(V::ElementarySpace, a::Sector) # whether a vector space `V` has a subspace corresponding to sector `a` with non-zero multiplicity
hassector(P::ProductSpace{S, N}, s::NTuple{N, sectortype(S)}) # Query whether `P` has a non-zero degeneracy of sector `s`, representing a combination of sectors on the individual tensor indices.
Base.axes(V::ElementarySpace) # the axes of an elementary space as `1:dim(V)`
Base.axes(V::ElementarySpace, a::Sector) # axes corresponding to the sector `a` in an elementary space as a UnitRange.
Base.axes(P::ProductSpace) # the axes for all index spaces in product space `P`
Base.axes(P::ProductSpace, n::Int) # the axes for `n`th index space of product space `P`
Base.axes(P::ProductSpace{<:ElementarySpace, N}, sectors::NTuple{N, <:Sector}) where {N} # the axes of `sectors[i]` in `P.spaces[i]` for all `i ∈ 1:N`.
Base.conj(V::ElementarySpace) # returns the complex conjugate space (conj(V)==V̅)
dual(V::EuclideanSpace) = conj(V) # returns the dual space (dual(V)==V^*); for product space the sequence of the vector spaces are reversed.
dual(P::ProductSpace) # Return a new product space with reversed order of index spaces of the input product space and take the dual of each index space.
dual(W::HomSpace) # Return the dual of a HomSpace which contains the dual of morphisms in this space. It corresponds to 180 degree rotation in the graphical representation.
Base.adjoint(V::VectorSpace) = dual(V) # make V' as the dual of V
Base.adjoint(W::HomSpace{<:EuclideanSpace}) # Return the adjoint of a HomSpace which contains the dagger of morphisms in this space. It corresponds to mirror operation and then reversing all arrows in the graphical
representation.
isdual(V::ElementarySpace) # wether an ElementarySpace `V` is normal or rather a dual space
flip(V::ElementarySpace) # flip(V)==V̅^*
⊕ # direct sum of the elementary spaces `V1`, `V2`, ...
⊗ # representing the tensor product of several elementary vector spaces
Base.:*(V1::VectorSpace, V2::VectorSpace) = ⊗(V1, V2)
fuse(V1::S, V2::S, V3::S...) where {S<:ElementarySpace} # returns a single vector space that is isomorphic to the fusion product of the individual spaces
fuse(P::ProductSpace{S}) where {S<:ElementarySpace}
ismonomorphic # Return whether there exist monomorphisms from `V1` to `V2`, i.e. 'injective' morphisms with left inverses.
isepimorphic # Return whether there exist epimorphisms from `V1` to `V2`, i.e. 'surjective' morphisms with right inverses.
isisomorphic # Return if `V1` and `V2` are isomorphic, meaning that there exists isomorphisms from `V1` to `V2`, i.e. morphisms with left and right inverses.
const ≾ = ismonomorphic
const ≿ = isepimorphic
const ≅ = isisomorphic
≺(V1::VectorSpace, V2::VectorSpace) = V1 ≾ V2 && !(V1 ≿ V2)
≻(V1::VectorSpace, V2::VectorSpace) = V1 ≿ V2 && !(V1 ≾ V2)
infimum # Return the infimum of a number of elementary spaces
supremum # Return the supremum of a number of elementary spaces
Base.:(==)
Base.hash
Base.length(P::ProductSpace) # number of vector spaces
Base.iterate
Base.indexed_iterate
Base.eltype
Base.IteratorEltype
Base.IteratorSize
Base.convert
codomain(W::HomSpace) # codomain of a HomSpace.
domain(W::HomSpace) # domain of a HomSpace.

Constructors

# Cartesian and Complex Space
CartesianSpace(d::Integer = 0; dual = false) # Constructed by an integer number which is the dim of the space
ComplexSpace(d::Integer = 0; dual = false)
CartesianSpace(dim::Pair; dual = false) # Constructed by (Trivial(),d)
ComplexSpace(dim::Pair; dual = false)
CartesianSpace(dims::AbstractDict; kwargs...) # Constructed by (Trivial() => d)
ComplexSpace(dims::AbstractDict; kwargs...)
Base.getindex(::RealNumbers) = CartesianSpace # Make ℝ[] a synonyms for CartesianSpace.
Base.getindex(::ComplexNumbers) = ComplexSpace # make ℂ[] a synonyms for ComplexSpace
Base.:^(::RealNumbers, d::Int) # Return a CartesianSpace with dimension `d`.
Base.:^(::ComplexNumbers, d::Int) # Return a ComplexSpace with dimension `d`

# Graded Space
GradedSpace{I, NTuple{N, Int}}(dims; dual::Bool = false) where {I, N} # dims = (c=>dc,...)
GradedSpace{I, NTuple{N, Int}}(dims::Pair; dual::Bool = false) where {I, N}
GradedSpace{I, SectorDict{I, Int}}(dims; dual::Bool = false) where {I<:Sector}
GradedSpace{I, SectorDict{I, Int}}(dims::Pair; dual::Bool = false) where {I<:Sector}
GradedSpace{I,D}(; kwargs...) where {I<:Sector,D}
GradedSpace{I,D}(d1::Pair, d2::Pair, dims::Vararg{Pair}; kwargs...) where {I<:Sector,D}
GradedSpace{I}(args...; kwargs...) where {I<:Sector}
GradedSpace(dims::Tuple{Vararg{Pair{I, <:Integer}}}; dual::Bool = false) where {I<:Sector}
GradedSpace(dims::Vararg{Pair{I, <:Integer}}; dual::Bool = false) where {I<:Sector}
GradedSpace(dims::AbstractDict{I, <:Integer}; dual::Bool = false) where {I<:Sector}

struct SpaceTable end
const Vect = SpaceTable()
Base.getindex(::SpaceTable) = ComplexSpace # Vect[] = ComplexSpace
Base.getindex(::SpaceTable, ::Type{Trivial}) = ComplexSpace
Base.getindex(::SpaceTable, I::Type{<:Sector}) # # Vect[I]; Return `GradedSpace{I, NTuple{N, Int}}` if `HasLength`; return `GradedSpace{I, SectorDict{I, Int}}` if `IsInfinite`.
Base.getindex(::ComplexNumbers, I::Type{<:Sector}) = Vect[I] # Make ℂ[I] = Vect[I]

struct RepTable end
const Rep = RepTable()
Base.getindex(::RepTable, G::Type{<:Group}) # Rep[G] = Vect[Irrep[G]]
const ZNSpace{N} = GradedSpace{ZNIrrep{N}, NTuple{N,Int}}
const Z2Space = ZNSpace{2}
const Z3Space = ZNSpace{3}
const Z4Space = ZNSpace{4}
const U1Space = Rep[U₁]
const CU1Space = Rep[CU₁]
const SU2Space = Rep[SU₂]
const ℤ₂Space = Z2Space
const ℤ₃Space = Z3Space
const ℤ₄Space = Z4Space
const U₁Space = U1Space
const CU₁Space = CU1Space
const SU₂Space = SU2Space

# Product Space
ProductSpace(spaces::Vararg{S, N}) where {S<:ElementarySpace, N}
ProductSpace{S, N}(spaces::Vararg{S, N}) where {S<:ElementarySpace, N}
ProductSpace{S}(spaces) where {S<:ElementarySpace}
ProductSpace(P::ProductSpace)
⊗(V1::S, V2::S) where {S<:ElementarySpace}= ProductSpace((V1, V2))
⊗(P1::ProductSpace{S}, V2::S) where {S<:ElementarySpace}
⊗(V1::S, P2::ProductSpace{S}) where {S<:ElementarySpace}
⊗(P1::ProductSpace{S}, P2::ProductSpace{S}) where {S<:ElementarySpace}
⊗(P::ProductSpace{S, 0}, ::ProductSpace{S, 0}) where {S<:ElementarySpace} = P
⊗(P::ProductSpace{S}, ::ProductSpace{S, 0}) where {S<:ElementarySpace} = P
⊗(::ProductSpace{S, 0}, P::ProductSpace{S}) where {S<:ElementarySpace} = P
⊗(V::ElementarySpace) = ProductSpace((V,))
⊗(P::ProductSpace) = P
Base.:^(V::ElementarySpace, N::Int) = ProductSpace{typeof(V), N}(ntuple(n->V, N))
Base.:^(V::ProductSpace, N::Int) = ⊗(ntuple(n->V, N)...)
Base.literal_pow(::typeof(^), V::ElementarySpace, p::Val{N}) where N =
    ProductSpace{typeof(V), N}(ntuple(n->V, p))
insertunit(P::ProductSpace, i::Int = length(P)+1; dual = false, conj = false) # For `P::ProductSpace{S,N}`, this adds an extra tensor product factor at position `1 <= i <= N+1` (last position by default) which is just a the `S`-equivalent of the underlying field of scalars, i.e. `oneunit(S)`.

# HomSpace
→(dom::TensorSpace{S}, codom::TensorSpace{S}) where {S<:ElementarySpace} =
    HomSpace(ProductSpace(codom), ProductSpace(dom))
←(codom::TensorSpace{S}, dom::TensorSpace{S}) where {S<:ElementarySpace} =
    HomSpace(ProductSpace(codom), ProductSpace(dom))    

Others structures

struct TrivialOrEmptyIterator
    isempty::Bool
end # returns nothing is isempty = true, otherwise returns Trivial()

Details about dual, conj, flip

In vectorspaces.jl:

function dual end
dual(V::EuclideanSpace) = conj(V)
Base.adjoint(V::VectorSpace) = dual(V)
function flip end

In generalspace.jl:

dual(V::GeneralSpace{𝕜}) where {𝕜} =
    GeneralSpace{𝕜}(dim(V), !isdual(V), isconj(V))
Base.conj(V::GeneralSpace{𝕜}) where {𝕜} =
    GeneralSpace{𝕜}(dim(V), isdual(V), !isconj(V))

In cartesianspace.jl:

flip(V::CartesianSpace) = V

In complexspace.jl:

Base.conj(V::ComplexSpace) = ComplexSpace(dim(V), !isdual(V))
flip(V::ComplexSpace) = dual(V)

In sectors.jl:

Base.conj(a::I): $\overline{a}$, conjugate or dual label of $a$.

dual(a::Sector) = conj(a)

In trivial.jl:

Base.conj(::Trivial) = Trivial()

In anyons.jl:

Base.conj(s::IsingAnyon) = s
Base.conj(s::FibonacciAnyon) = s

In irreps.jl:

Base.conj(c::ZNIrrep{N}) where {N} = ZNIrrep{N}(-c.n)
Base.conj(c::U1Irrep) = U1Irrep(-c.charge)
Base.conj(s::SU2Irrep) = s
Base.conj(c::CU1Irrep) = c

In gradedspace.jl:

In fact, GradedSpace is the reason flip exists, cause in this case it is different than dual. The existence of flip originates from the non-trivial isomorphism between $R_{\overline{a}}$ and $R_{a}^*$, i.e. the representation space of the dual $\overline{a}$ of sector $a$ and the dual of the representation space of sector $a$. In order for flip(V) to be isomorphic to V, it is such that, if V = GradedSpace(a=>n_a,...) then flip(V) = dual(GradedSpace(dual(a)=>n_a,....)).

In the structure of TensorLabXD.jl, we only keep the simple objects. It means that we don't have objects correspond to $a^*$ in the language of category. Therefore, dual(a) = conj(a) both correspond to $\overline{a}$. The dual space of a space is denoted in the field named as dual in the type definitions. If dual = true, it means that we represent the space $R_a^*$ which is isomorphic to $R_{\overline{a}}$, and in the methods like sectors and dim we get the sectors and corresponding dims in the corresponding $R_{\overline{a}}$.

sectors(V::GradedSpace{I,<:AbstractDict}) where {I<:Sector} =
    SectorSet{I}(s->isdual(V) ? dual(s) : s, keys(V.dims))
sectors(V::GradedSpace{I,NTuple{N,Int}}) where {I<:Sector, N} =
    SectorSet{I}(Iterators.filter(n->V.dims[n]!=0, 1:N)) do n
        isdual(V) ? dual(values(I)[n]) : values(I)[n]
dim(V::GradedSpace{I,<:AbstractDict}, c::I) where {I<:Sector} =
    get(V.dims, isdual(V) ? dual(c) : c, 0)
dim(V::GradedSpace{I,<:Tuple}, c::I) where {I<:Sector} =
    V.dims[findindex(values(I), isdual(V) ? dual(c) : c)]    
Base.conj(V::GradedSpace) = typeof(V)(V.dims, !V.dual)
function flip(V::GradedSpace{I}) where {I<:Sector}
    if isdual(V)
        typeof(V)(c=>dim(V, c) for c in sectors(V))
    else
        typeof(V)(dual(c)=>dim(V, c) for c in sectors(V))'
    end
end        

In productspace.jl:

The order of the spaces are reversed before taking the dual of each elementray vecor space:

dual(P::ProductSpace{<:ElementarySpace, 0}) = P
dual(P::ProductSpace) = ProductSpace(map(dual, reverse(P.spaces)))

In homespace.jl:

For a morphism the dual of the morphism is different with the adjoint of it. In the tensor category language, the dual of a morphism is called the transpose of the morphism, while the adjoint of a morphism is called the dagger of the morphism.

dual(W::HomSpace) = HomSpace(dual(W.domain), dual(W.codomain))
Base.adjoint(W::HomSpace{<:EuclideanSpace}) = HomSpace(W.domain, W.codomain)

The sequence of the elementary spaces in a TensorMapSpace is defined as $1:N_1$ for codomain vectors, and $N_1+1:N_1+N_2$ for domain dual vectors. Note that the sequence of the domain vectors are not reversed, and the dual is taken individually for each elementary space.

Base.getindex(W::TensorMapSpace{<:IndexSpace, N₁, N₂}, i) where {N₁, N₂} =
    i <= N₁ ? codomain(W)[i] : dual(domain(W)[i-N₁])

VectorSpace type

From the Introduction, it should be clear that an important aspect in the definition of a tensor (map) is specifying the vector spaces and their structure in the domain and codomain of the map. The starting point is an abstract type VectorSpace

abstract type VectorSpace end

which is actually a too restricted name. Subtypes of VectorSpace will in general represent $𝕜$-linear tensor categories, which can go beyond $\mathbf{Vect}$ and $\mathbf{SVect}$. The instances of it represent the objects of the category.

In order not to make the remaining discussion too abstract or complicated, we will simply refer to subtypes of VectorSpace instead of specific categories, and to spaces instead of objects from these categories.

We define two abstract subtypes

abstract type ElementarySpace{𝕜} <: VectorSpace end
const IndexSpace = ElementarySpace

abstract type CompositeSpace{S<:ElementarySpace} <: VectorSpace end

The ElementarySpace is a super type for all categories that can be associated with the individual indices of a tensor, as hinted to by its alias IndexSpace. The parameter 𝕜 here could represent the field of vector spaces of Vect, or the field of the morphism space of 𝕜-linear tensor categories.

The CompositeSpace{S} where S<:ElementarySpace is a super type for all vector spaces that are composed of a number of elementary spaces of type S. One concrete subtype of it is the ProductSpace{S,N} which represents a homogeneous tensor product of N vector spaces of type S.

Throughout TensorLabXD.jl, the function spacetype returns the type of ElementarySpace associated with e.g. a composite space or a tensor. It works both on instances and type.

Fields

Vector spaces (linear categories) are defined over a field of scalars $𝕜$. We define a type hierarchy to specify the scalar field, but so far only support real and complex numbers, via

abstract type Field end

struct RealNumbers <: Field end
struct ComplexNumbers <: Field end

const ℝ = RealNumbers()
const ℂ = ComplexNumbers()

Note that ℝ and ℂ can be typed as \bbR+TAB and \bbC+TAB. One reason for defining this new type hierarchy instead of recycling the types from Julia's Number hierarchy is to introduce some syntactic sugar without committing type piracy.

Some examples:

julia> 3 ∈ ℝtrue
julia> 5.0 ∈ ℂtrue
julia> 5.0+1.0*im ∈ ℝfalse
julia> Float64 ⊆ ℝtrue
julia> ComplexF64 ⊆ ℂtrue
julia> ℝ ⊆ ℂtrue
julia> ℂ ⊆ ℝfalse

The field of a vector space or tensor a can be obtained with field(a).

Elementary spaces

Vector spaces that are associated with the individual indices of a tensor should be implemented as subtypes of ElementarySpace. As the domain and codomain of a tensor map will be the tensor product of such objects which all have the same type, it is important that related vector spaces, e.g. the dual space, are objects of the same concrete type.

Every ElementarySpace should implement the following methods

• dim(::ElementarySpace) -> ::Int returns the dimension of the space as an Int

• dual(::ElementarySpace) returns the dual space, using an instance of the same concrete type. The dual of a space V can also be obtained as V'.

• conj(::ElementarySpace) returns the complex conjugate space, using an instance of the same concrete type

The GeneralSpace is one of the concrete type of the ElementarySpace. It is completely characterized by its field 𝕜, its dimension and whether its the dual and/or complex conjugate of $𝕜^d$.

struct GeneralSpace{𝕜} <: ElementarySpace{𝕜}
    d::Int
    dual::Bool
    conj::Bool
end

The abstract type

abstract type InnerProductSpace{𝕜} <: ElementarySpace{𝕜} end

is defined to contain all vector spaces V which have an inner product and thus a canonical mapping from dual(V) to conj(V). This mapping is provided by the metric, but no further support for working with metrics is currently implemented.

The abstract type

abstract type EuclideanSpace{𝕜} <: InnerProductSpace{𝕜} end

is defined to contain all spaces V with a standard Euclidean inner product. The canonical mapping from dual(V) to conj(V) is identity. This subtype represents dagger categories.

We have two concrete types

struct CartesianSpace <: EuclideanSpace{ℝ}
    d::Int
end
struct ComplexSpace <: EuclideanSpace{ℂ}
  d::Int
  dual::Bool
end

to represent the Euclidean spaces $ℝ^d$ and $ℂ^d$. They can be created using the syntax CartesianSpace(d) == ℝ^d == ℝ[](d) and ComplexSpace(d) == ℂ^d == ℂ[](d). The dual space of $\mathbb{C}^d$ can be created by ComplexSpace(d, true) == ComplexSpace(d; dual = true) == (ℂ^d)' == ℂ[](d)'. Note that the brackets are required because of the precedence rules, since d' == d for d::Integer.

Some examples:

julia> dim(ℝ^10)10
julia> (ℝ^10)' == ℝ^10 == ℝ[](10)true
julia> isdual((ℂ^5))false
julia> isdual((ℂ^5)')true
julia> isdual((ℝ^5)')false
julia> dual(ℂ^5) == (ℂ^5)' == conj(ℂ^5) == ComplexSpace(5; dual = true)true
julia> typeof(ℝ^3)CartesianSpace
julia> spacetype(ℝ^3)CartesianSpace
julia> spacetype(ℝ[])CartesianSpace
julia> field(ℂ^5)ℂ

Note that ℝ[] and ℂ[] are synonyms for CartesianSpace and ComplexSpace respectively. This is not very useful in itself, and is motivated by its generalization to GradedSpace. We refer to the subsection on graded spaces on the next page for further information about GradedSpace, which is another subtype of EuclideanSpace{ℂ} with an inner structure corresponding to the irreducible representations of a group, or more generally, the simple objects of a fusion category.

Composite spaces

Composite spaces are vector spaces that are built up out of individual elementary vector spaces of the same type. The most prominent and currently only subtype is a tensor product of N elementary spaces of the same type S:

struct ProductSpace{S<:ElementarySpace, N} <: CompositeSpace{S}
    spaces::NTuple{N, S}
end

Given some V1::S, V2::S, V3::S of the same type S<:ElementarySpace, we can easily construct ProductSpace{S,3}((V1,V2,V3)) as ProductSpace(V1,V2,V3) or using V1 ⊗ V2 ⊗ V3, where ⊗ is simply obtained by typing \otimes+TAB. For convenience, the regular multiplication operator * also acts as tensor product between vector spaces, and as a consequence so does raising a vector space to a positive integer power, i.e.

julia> V1 = ℂ^2ℂ^2
julia> V2 = ℂ^3ℂ^3
julia> V1 ⊗ V2 ⊗ V1' == V1 * V2 * V1' == ProductSpace(V1,V2,V1') == ProductSpace(V1,V2) ⊗ V1'true
julia> V1^3(ℂ^2 ⊗ ℂ^2 ⊗ ℂ^2)
julia> dim(V1 ⊗ V2)6
julia> dims(V1 ⊗ V2)(2, 3)
julia> dual(V1 ⊗ V2)((ℂ^3)' ⊗ (ℂ^2)')
julia> spacetype(V1 ⊗ V2)ComplexSpace
julia> spacetype(ProductSpace{ComplexSpace,3})ComplexSpace

Here, the new function dims gives the dimension of the individual spaces in a ProductSpace as a tuple.

The function one applied to a ProductSpace{S,N} or an instance V of S::ElementarySpace returns the multiplicative identity, which is ProductSpace{S,0}(()). Note that V ⊗ one(V) or ⊗(V) will yield a ProductSpace{S,1}(V) and not V itself.

In the future, other CompositeSpace types could be added. For example, the wave function of an N-particle quantum system in first quantization would require the introduction of a SymmetricSpace{S,N} or a AntiSymmetricSpace{S,N} for bosons or fermions respectively, which correspond to the symmetric (permutation invariant) or antisymmetric subspace of V^N, where V::S represents the Hilbert space of the single particle system. Other domains, like general relativity, might also benefit from tensors living in a subspace with certain symmetries under specific index permutations.

Space of morphisms

In a $𝕜$-linear category $C$, the set of morphisms $\mathrm{Hom}(W,V)$ for $V,W ∈ C$ form a vector space with field $𝕜$, irrespective of whether or not $C$ is a subcategory of $\mathbf{(S)Vect}$, and we define tensor maps as the morphisms.

The space of morphisms is represented by the type

struct HomSpace{S<:ElementarySpace, P1<:CompositeSpace{S}, P2<:CompositeSpace{S}}
    codomain::P1
    domain::P2
end

It can be created by domain → codomain or codomain ← domain (where the arrows are obtained as \to+TAB or \leftarrow+TAB, and as \rightarrow+TAB respectively).

Note that HomSpace is not a subtype of VectorSpace.

Some properties of HomSpace:

julia> W = ℂ^2 ⊗ ℂ^3 → ℂ^3 ⊗ dual(ℂ^4)(ℂ^3 ⊗ (ℂ^4)') ← (ℂ^2 ⊗ ℂ^3)
julia> field(W)ℂ
julia> dual(W)((ℂ^3)' ⊗ (ℂ^2)') ← (ℂ^4 ⊗ (ℂ^3)')
julia> adjoint(W)(ℂ^2 ⊗ ℂ^3) ← (ℂ^3 ⊗ (ℂ^4)')
julia> spacetype(W)ComplexSpace
julia> spacetype(typeof(W))ComplexSpace
julia> W[1]ℂ^3
julia> W[2](ℂ^4)'
julia> W[3](ℂ^2)'
julia> W[4](ℂ^3)'
julia> dim(W)72

The indexing W yields first the spaces in the codomain, followed by the dual of the individual spaces in the domain. This convention is useful in combination with the instances of type TensorMap, which represent morphisms living in such a HomSpace. The dim(::HomSpace) represent the number of linearly independent morphisms in this space.

Partial order among vector spaces

Vector spaces of the same spacetype can be given a partial order, based on whether there exist injective morphisms (a.k.a monomorphisms) or surjective morphisms (a.k.a. epimorphisms) between them.

We define ismonomorphic(V1, V2), with Unicode synonym V1 ≾ V2 (obtained as \precsim+TAB), to express whether there exist injective morphisms in V1 → V2.

We define isepimorphic(V1, V2), with Unicode synonym V1 ≿ V2 (obtained as \succsim+TAB), to express whether there exist surjective morphisms in V1 → V2.

We define isisomorphic(V1, V2), with Unicode alternative V1 ≅ V2 (obtained as \cong+TAB), to express whether there exist isomorphism in V1 → V2. V1 ≅ V2 if and only if V1 ≾ V2 && V1 ≿ V2.

The strict comparison operators ≺ and ≻ (\prec+TAB and \succ+TAB) are defined by

≺(V1::VectorSpace, V2::VectorSpace) = V1 ≾ V2 && !(V1 ≿ V2)
≻(V1::VectorSpace, V2::VectorSpace) = V1 ≿ V2 && !(V1 ≾ V2)

However, as we expect these to be less commonly used, no ASCII alternative is provided.

In the context of spacetype(V) <: EuclideanSpace, V1 ≾ V2 implies that there exists isometries $W:V1 → V2$ such that $W^† ∘ W = \mathrm{id}_{V1}$, while V1 ≅ V2 implies that there exist unitaries $U:V1 → V2$ such that $U^† ∘ U = \mathrm{id}_{V1}$ and $U ∘ U^† = \mathrm{id}_{V2}$.

Note that spaces that are isomorphic are not necessarily equal. One can be a dual space, and the other a normal space, or one can be an instance of ProductSpace, while the other is an ElementarySpace. There will exist (infinitely) many isomorphisms between the corresponding spaces, but in general none of those will be canonical.

There are a number of convenience functions to create isomorphic spaces. The function fuse(V1, V2, ...) or fuse(V1 ⊗ V2 ⊗ ...) returns an elementary space that is isomorphic to V1 ⊗ V2 ⊗ .... The function flip(V::ElementarySpace) returns a space that is isomorphic to V but has isdual(flip(V)) == isdual(V'), i.e. if V is a normal space then flip(V) is a dual space. flip(V) is different from dual(V) in the case of GradedSpace. It is useful to flip a tensor index from a ket to a bra (or vice versa), by contracting that index with a unitary map from V to flip(V). (In the language of category, the we have flip(a)== $\overline{a}^*$ .)

Some examples:

julia> ℝ^3 ≾ ℝ^5true
julia> ℂ^3 ≾ (ℂ^5)'true
julia> (ℂ^5) ≅ (ℂ^5)'true
julia> fuse(ℝ^5, ℝ^3)ℝ^15
julia> fuse(ℂ^3, (ℂ^5)' ⊗ ℂ^2)ℂ^30
julia> fuse(ℂ^3, (ℂ^5)') ⊗ ℂ^2 ≅ fuse(ℂ^3, (ℂ^5)', ℂ^2) ≅ ℂ^3 ⊗ (ℂ^5)' ⊗ ℂ^2true
julia> flip(ℂ^4)(ℂ^4)'
julia> flip(ℂ^4) ≅ ℂ^4true
julia> flip(ℂ^4) == ℂ^4false

We 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).

Applying oneunit to an elementary space returns the one-dimensional space, which is isomorphic to the scalar field of the space itself.

Some examples:

julia> ℝ^5 ⊕ ℝ^3ℝ^8
julia> ℂ^5 ⊕ ℂ^3ℂ^8
julia> ℂ^5 ⊕ (ℂ^3)'ERROR: SpaceMismatch(Direct sum of a vector space and its dual does not exist)
julia> oneunit(ℝ^3)ℝ^1
julia> ℂ^5 ⊕ oneunit(ComplexSpace)ℂ^6
julia> oneunit((ℂ^3)')ℂ^1
julia> (ℂ^5) ⊕ oneunit((ℂ^5))ℂ^6
julia> (ℂ^5)' ⊕ oneunit((ℂ^5)')ERROR: SpaceMismatch(Direct sum of a vector space and its dual does not exist)

If V1 and V2 are two ElementarySpace instances with isdual(V1) == isdual(V2), we can define a unique infimum V::ElementarySpace with the same value of isdual that satisfies V ≾ V1 and V ≾ V2, as well as a unique supremum W::ElementarySpace that satisfies W ≿ V1 and W ≿ V2. For CartesianSpace and ComplexSpace, this simply amounts to the space with minimal or maximal dimension, i.e.

julia> infimum(ℝ^5, ℝ^3)ℝ^3
julia> supremum(ℂ^5, ℂ^3)ℂ^5
julia> supremum(ℂ^5, (ℂ^3)')ERROR: SpaceMismatch(Supremum of space and dual space does not exist)

The names infimum and supremum are especially suited in the case of GradedSpace, as the infimum of two spaces might be different from either of those two spaces, and similar for the supremum.