various utility functions

Author: lkdvos

src/spaces/homspace.jl

@@ -50,6 +50,9 @@ const TensorMapSpace{S <: ElementarySpace, N₁, N₂} = HomSpace{
     S, ProductSpace{S, N₁},
     ProductSpace{S, N₂},
 }
+numout(::Type{TensorMapSpace{S, N₁, N₂}}) where {S, N₁, N₂} = N₁
+numin(::Type{TensorMapSpace{S, N₁, N₂}}) where {S, N₁, N₂} = N₂
+numind(T::Type{TensorMapSpace{S, N₁, N₂}}) where {S, N₁, N₂} = numout(T) + numin(T)
 
 function Base.getindex(W::TensorMapSpace{<:IndexSpace, N₁, N₂}, i) where {N₁, N₂}
     return i <= N₁ ? codomain(W)[i] : dual(domain(W)[i - N₁])
@@ -139,18 +142,33 @@ fusiontrees(W::HomSpace) = fusionblockstructure(W).fusiontreelist
 # Operations on HomSpaces
 # -----------------------
 """
-    permute(W::HomSpace, (p₁, p₂)::Index2Tuple{N₁,N₂})
+    permute(W::HomSpace, (p₁, p₂)::Index2Tuple)
 
 Return the `HomSpace` obtained by permuting the indices of the domain and codomain of `W`
 according to the permutation `p₁` and `p₂` respectively.
 """
-function permute(W::HomSpace{S}, (p₁, p₂)::Index2Tuple{N₁, N₂}) where {S, N₁, N₂}
+function permute(W::HomSpace, (p₁, p₂)::Index2Tuple)
     p = (p₁..., p₂...)
     TupleTools.isperm(p) && length(p) == numind(W) ||
         throw(ArgumentError("$((p₁, p₂)) is not a valid permutation for $(W)"))
     return select(W, (p₁, p₂))
 end
 
+_transpose_indices(W::HomSpace) = (reverse(domainind(W)), reverse(codomainind(W)))
+
+function LinearAlgebra.transpose(W::HomSpace, (p₁, p₂)::Index2Tuple = _transpose_indices(W))
+    p = linearizepermutation(p₁, p₂, numout(W), numin(W))
+    iscyclicpermutation(p) || throw(ArgumentError(lazy"$((p₁, p₂)) is not a cyclic permutation for $W"))
+    return select(W, (p₁, p₂))
+end
+
+function braid(W::HomSpace, (p₁, p₂)::Index2Tuple, lvls::IndexTuple)
+    p = (p₁..., p₂...)
+    TupleTools.isperm(p) && length(p) == numind(W) == length(lvls) ||
+        throw(ArgumentError("$((p₁, p₂)), $lvls is not a valid braiding for $(W)"))
+    return select(W, (p₁, p₂))
+end
+
 """
     select(W::HomSpace, (p₁, p₂)::Index2Tuple{N₁,N₂})
 

src/tensors/abstracttensor.jl

@@ -119,40 +119,40 @@ numind(::Type{TT}) where {TT <: AbstractTensorMap} = numin(TT) + numout(TT)
 const order = numind
 
 """
-    codomainind(::Union{TT,Type{TT}}) where {TT<:AbstractTensorMap} -> Tuple{Int}
+    codomainind(::Union{TT, Type{TT}}) where {TT <: Union{HomSpace, AbstractTensorMap}} -> Tuple{Int}
 
-Return all indices of the codomain of a tensor.
+Return all indices of the codomain of a tensor or tensor space.
 
 See also [`domainind`](@ref) and [`allind`](@ref).
 """
-function codomainind(::Type{TT}) where {TT <: AbstractTensorMap}
+function codomainind(::Type{TT}) where {TT <: Union{AbstractTensorMap, HomSpace}}
     return ntuple(identity, numout(TT))
 end
-codomainind(t::AbstractTensorMap) = codomainind(typeof(t))
+codomainind(t::Union{AbstractTensorMap, HomSpace}) = codomainind(typeof(t))
 
 """
     domainind(::Union{TT,Type{TT}}) where {TT<:AbstractTensorMap} -> Tuple{Int}
 
-Return all indices of the domain of a tensor.
+Return all indices of the domain of a tensor or tensor space.
 
 See also [`codomainind`](@ref) and [`allind`](@ref).
 """
-function domainind(::Type{TT}) where {TT <: AbstractTensorMap}
+function domainind(::Type{TT}) where {TT <: Union{HomSpace, AbstractTensorMap}}
     return ntuple(n -> numout(TT) + n, numin(TT))
 end
-domainind(t::AbstractTensorMap) = domainind(typeof(t))
+domainind(t::Union{AbstractTensorMap, HomSpace}) = domainind(typeof(t))
 
 """
     allind(::Union{TT,Type{TT}}) where {TT<:AbstractTensorMap} -> Tuple{Int}
 
-Return all indices of a tensor, i.e. the indices of its domain and codomain.
+Return all indices of a tensor or tensor space, i.e. the indices of its domain and codomain.
 
 See also [`codomainind`](@ref) and [`domainind`](@ref).
 """
-function allind(::Type{TT}) where {TT <: AbstractTensorMap}
+function allind(::Type{TT}) where {TT <: Union{HomSpace, AbstractTensorMap}}
     return ntuple(identity, numind(TT))
 end
-allind(t::AbstractTensorMap) = allind(typeof(t))
+allind(t::Union{HomSpace, AbstractTensorMap}) = allind(typeof(t))
 
 function adjointtensorindex(t::AbstractTensorMap, i)
     return ifelse(i <= numout(t), numin(t) + i, i - numout(t))