fix bad merge conflict choices

borisdevos · borisdevos · commit 6cc06181b765 · 2025-11-03T12:50:04.000+01:00
diff --git a/src/TensorKit.jl b/src/TensorKit.jl
@@ -34,8 +34,10 @@ export TruncationScheme
 export SpaceMismatch, SectorMismatch, IndexError # error types
 
 # general vector space methods
-export space, field, dual, dim, reduceddim, dims, fuse, flip, isdual, oplus,
-       insertleftunitspace, insertrightunitspace, removeunitspace
+# Export general vector space methods
+export space, field, dual, dim, reduceddim, dims, fuse, flip, isdual
+export unitspace, zerospace, oplus, ominus
+export insertleftunitspace, insertrightunitspace, removeunitspace
 
 # partial order for vector spaces
 export infimum, supremum, isisomorphic, ismonomorphic, isepimorphic
diff --git a/src/spaces/homspace.jl b/src/spaces/homspace.jl
@@ -8,18 +8,18 @@ Represents the linear space of morphisms with codomain of type `P1` and domain o
 Note that HomSpace is not a subtype of VectorSpace, i.e. we restrict the latter to denote
 certain categories and their objects, and keep HomSpace distinct.
 """
-struct HomSpace{S<:ElementarySpace,P1<:CompositeSpace{S},P2<:CompositeSpace{S}}
+struct HomSpace{S <: ElementarySpace, P1 <: CompositeSpace{S}, P2 <: CompositeSpace{S}}
     codomain::P1
     domain::P2
 end
 
-function HomSpace(codomain::S, domain::CompositeSpace{S}) where {S<:ElementarySpace}
+function HomSpace(codomain::S, domain::CompositeSpace{S}) where {S <: ElementarySpace}
     return HomSpace(⊗(codomain), domain)
 end
-function HomSpace(codomain::CompositeSpace{S}, domain::S) where {S<:ElementarySpace}
+function HomSpace(codomain::CompositeSpace{S}, domain::S) where {S <: ElementarySpace}
     return HomSpace(codomain, ⊗(domain))
 end
-function HomSpace(codomain::S, domain::S) where {S<:ElementarySpace}
+function HomSpace(codomain::S, domain::S) where {S <: ElementarySpace}
     return HomSpace(⊗(codomain), ⊗(domain))
 end
 HomSpace(codomain::VectorSpace) = HomSpace(codomain, zerospace(codomain))
@@ -45,18 +45,20 @@ numout(W::HomSpace) = length(codomain(W))
 numin(W::HomSpace) = length(domain(W))
 numind(W::HomSpace) = numin(W) + numout(W)
 
-const TensorSpace{S<:ElementarySpace} = Union{S,ProductSpace{S}}
-const TensorMapSpace{S<:ElementarySpace,N₁,N₂} = HomSpace{S,ProductSpace{S,N₁},
-                                                          ProductSpace{S,N₂}}
+const TensorSpace{S <: ElementarySpace} = Union{S, ProductSpace{S}}
+const TensorMapSpace{S <: ElementarySpace, N₁, N₂} = HomSpace{
+    S, ProductSpace{S, N₁},
+    ProductSpace{S, N₂},
+}
 
-function Base.getindex(W::TensorMapSpace{<:IndexSpace,N₁,N₂}, i) where {N₁,N₂}
+function Base.getindex(W::TensorMapSpace{<:IndexSpace, N₁, N₂}, i) where {N₁, N₂}
     return i <= N₁ ? codomain(W)[i] : dual(domain(W)[i - N₁])
 end
 
-function ←(codom::ProductSpace{S}, dom::ProductSpace{S}) where {S<:ElementarySpace}
+function ←(codom::ProductSpace{S}, dom::ProductSpace{S}) where {S <: ElementarySpace}
     return HomSpace(codom, dom)
 end
-function ←(codom::S, dom::S) where {S<:ElementarySpace}
+function ←(codom::S, dom::S) where {S <: ElementarySpace}
     return HomSpace(ProductSpace(codom), ProductSpace(dom))
 end
 ←(codom::VectorSpace, dom::VectorSpace) = ←(promote(codom, dom)...)
@@ -69,7 +71,7 @@ function Base.show(io::IO, W::HomSpace)
         print(io, W.codomain)
     end
     print(io, " ← ")
-    if length(W.domain) == 1
+    return if length(W.domain) == 1
         print(io, W.domain[1])
     else
         print(io, W.domain)
@@ -94,7 +96,7 @@ function blocksectors(W::HomSpace)
     N₁ = length(codom)
     N₂ = length(dom)
     I = sectortype(W)
-     if N₁ == 0 && N₂ == 0
+    if N₁ == 0 && N₂ == 0
         return allunits(I)
     elseif N₁ == 0
         return filter!(isone, collect(blocksectors(dom))) # module space cannot end in empty space
@@ -130,6 +132,8 @@ function dim(W::HomSpace)
     return d
 end
 
+dims(W::HomSpace) = (dims(codomain(W))..., dims(domain(W))...)
+
 """
     fusiontrees(W::HomSpace)
 
@@ -145,7 +149,7 @@ fusiontrees(W::HomSpace) = fusionblockstructure(W).fusiontreelist
 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{S}, (p₁, p₂)::Index2Tuple{N₁, N₂}) where {S, N₁, N₂}
     p = (p₁..., p₂...)
     TupleTools.isperm(p) && length(p) == numind(W) ||
         throw(ArgumentError("$((p₁, p₂)) is not a valid permutation for $(W)"))
@@ -158,9 +162,9 @@ end
 Return the `HomSpace` obtained by a selection from the domain and codomain of `W` according
 to the indices in `p₁` and `p₂` respectively.
 """
-function select(W::HomSpace{S}, (p₁, p₂)::Index2Tuple{N₁,N₂}) where {S,N₁,N₂}
-    cod = ProductSpace{S,N₁}(map(n -> W[n], p₁))
-    dom = ProductSpace{S,N₂}(map(n -> dual(W[n]), p₂))
+function select(W::HomSpace{S}, (p₁, p₂)::Index2Tuple{N₁, N₂}) where {S, N₁, N₂}
+    cod = ProductSpace{S, N₁}(map(n -> W[n], p₁))
+    dom = ProductSpace{S, N₂}(map(n -> dual(W[n]), p₂))
     return cod ← dom
 end
 
@@ -201,8 +205,10 @@ More specifically, adds a left monoidal unit or its dual.
 See also [`insertrightunitspace`](@ref insertrightunitspace(::HomSpace, ::Val{i}) where {i}),
 [`removeunitspace`](@ref removeunitspace(::HomSpace, ::Val{i}) where {i}).
 """
-function insertleftunitspace(W::HomSpace, ::Val{i}=Val(numind(W) + 1);
-                        conj::Bool=false, dual::Bool=false) where {i}
+function insertleftunitspace(
+        W::HomSpace, ::Val{i} = Val(numind(W) + 1);
+        conj::Bool = false, dual::Bool = false
+    ) where {i}
     if i ≤ numout(W)
         return insertleftunitspace(codomain(W), Val(i); conj, dual) ← domain(W)
     else
@@ -220,8 +226,10 @@ More specifically, adds a right monoidal unit or its dual.
 See also [`insertleftunitspace`](@ref insertleftunitspace(::HomSpace, ::Val{i}) where {i}),
 [`removeunitspace`](@ref removeunitspace(::HomSpace, ::Val{i}) where {i}).
 """
-function insertrightunitspace(W::HomSpace, ::Val{i}=Val(numind(W));
-                         conj::Bool=false, dual::Bool=false) where {i}
+function insertrightunitspace(
+        W::HomSpace, ::Val{i} = Val(numind(W));
+        conj::Bool = false, dual::Bool = false
+    ) where {i}
     if i ≤ numout(W)
         return insertrightunitspace(codomain(W), Val(i); conj, dual) ← domain(W)
     else
@@ -251,14 +259,14 @@ end
 #--------------------------------------------------------------------------
 
 # sizes, strides, offset
-const StridedStructure{N} = Tuple{NTuple{N,Int},NTuple{N,Int},Int}
+const StridedStructure{N} = Tuple{NTuple{N, Int}, NTuple{N, Int}, Int}
 
-struct FusionBlockStructure{I,N,F₁,F₂}
+struct FusionBlockStructure{I, N, F₁, F₂}
     totaldim::Int
-    blockstructure::SectorDict{I,Tuple{Tuple{Int,Int},UnitRange{Int}}}
-    fusiontreelist::Vector{Tuple{F₁,F₂}}
+    blockstructure::SectorDict{I, Tuple{Tuple{Int, Int}, UnitRange{Int}}}
+    fusiontreelist::Vector{Tuple{F₁, F₂}}
     fusiontreestructure::Vector{StridedStructure{N}}
-    fusiontreeindices::FusionTreeDict{Tuple{F₁,F₂},Int}
+    fusiontreeindices::FusionTreeDict{Tuple{F₁, F₂}, Int}
 end
 
 function fusionblockstructuretype(W::HomSpace)
@@ -268,7 +276,7 @@ function fusionblockstructuretype(W::HomSpace)
     I = sectortype(W)
     F₁ = fusiontreetype(I, N₁)
     F₂ = fusiontreetype(I, N₂)
-    return FusionBlockStructure{I,N,F₁,F₂}
+    return FusionBlockStructure{I, N, F₁, F₂}
 end
 
 @cached function fusionblockstructure(W::HomSpace)::fusionblockstructuretype(W)
@@ -281,13 +289,13 @@ end
     F₂ = fusiontreetype(I, N₂)
 
     # output structure
-    blockstructure = SectorDict{I,Tuple{Tuple{Int,Int},UnitRange{Int}}}() # size, range
-    fusiontreelist = Vector{Tuple{F₁,F₂}}()
-    fusiontreestructure = Vector{Tuple{NTuple{N₁ + N₂,Int},NTuple{N₁ + N₂,Int},Int}}() # size, strides, offset
+    blockstructure = SectorDict{I, Tuple{Tuple{Int, Int}, UnitRange{Int}}}() # size, range
+    fusiontreelist = Vector{Tuple{F₁, F₂}}()
+    fusiontreestructure = Vector{Tuple{NTuple{N₁ + N₂, Int}, NTuple{N₁ + N₂, Int}, Int}}() # size, strides, offset
 
     # temporary data structures
     splittingtrees = Vector{F₁}()
-    splittingstructure = Vector{Tuple{Int,Int}}()
+    splittingstructure = Vector{Tuple{Int, Int}}()
 
     # main computational routine
     blockoffset = 0
@@ -327,15 +335,17 @@ end
         blockstructure[c] = (blocksize, blockrange)
     end
 
-    fusiontreeindices = sizehint!(FusionTreeDict{Tuple{F₁,F₂},Int}(),
-                                  length(fusiontreelist))
+    fusiontreeindices = sizehint!(
+        FusionTreeDict{Tuple{F₁, F₂}, Int}(),
+        length(fusiontreelist)
+    )
     for (i, f₁₂) in enumerate(fusiontreelist)
         fusiontreeindices[f₁₂] = i
     end
     totaldim = blockoffset
-    structure = FusionBlockStructure(totaldim, blockstructure,
-                                     fusiontreelist, fusiontreestructure,
-                                     fusiontreeindices)
+    structure = FusionBlockStructure(
+        totaldim, blockstructure, fusiontreelist, fusiontreestructure, fusiontreeindices
+    )
     return structure
 end
 
@@ -357,7 +367,7 @@ end
 function diagonalblockstructure(W::HomSpace)
     ((numin(W) == numout(W) == 1) && domain(W) == codomain(W)) ||
         throw(SpaceMismatch("Diagonal only support on V←V with a single space V"))
-    structure = SectorDict{sectortype(W),UnitRange{Int}}() # range
+    structure = SectorDict{sectortype(W), UnitRange{Int}}() # range
     offset = 0
     dom = domain(W)[1]
     for c in blocksectors(W)
diff --git a/src/spaces/productspace.jl b/src/spaces/productspace.jl
@@ -234,7 +234,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}(())
diff --git a/test/symmetries/fusiontrees.jl b/test/symmetries/fusiontrees.jl
@@ -578,7 +578,7 @@ using .TestSetup
         d1 = transpose(f1, f1, (N + 1, 1:N..., ((2N):-1:(N + 3))...), (N + 2,))
         f1front, = TK.split(f1, N - 1)
         T = sectorscalartype(I)
-        d2 = Dict{typeof((f1front, f1front)),T}()
+        d2 = Dict{typeof((f1front, f1front)), T}()
         for ((f1′, f2′), coeff′) in d1
             for ((f1′′, f2′′), coeff′′) in
                 TK.planar_trace(
diff --git a/test/symmetries/spaces.jl b/test/symmetries/spaces.jl
@@ -291,9 +291,9 @@ end
     @test @constinferred(⊗(V1, V2, V3 ⊗ V4)) == P
     @test @constinferred(⊗(V1, V2 ⊗ V3, V4)) == P
     @test V1 * V2 * unitspace(V1) * V3 * V4 ==
-        @constinferred(insertleftunit(P, 3)) ==
-        @constinferred(insertrightunit(P, 2))
-    @test @constinferred(removeunit(V1 * V2 * unitspace(V1)' * V3 * V4, 3)) == P
+        @constinferred(insertleftunitspace(P, 3)) ==
+        @constinferred(insertrightunitspace(P, 2))
+    @test @constinferred(removeunitspace(V1 * V2 * unitspace(V1)' * V3 * V4, 3)) == P
     @test fuse(V1, V2', V3) ≅ V1 ⊗ V2' ⊗ V3
     @test fuse(V1, V2', V3) ≾ V1 ⊗ V2' ⊗ V3
     @test fuse(V1, V2', V3) ≿ V1 ⊗ V2' ⊗ V3
@@ -352,9 +352,9 @@ end
     @test @constinferred(⊗(V1, V2, V3)) == P
     @test @constinferred(adjoint(P)) == dual(P) == V3' ⊗ V2' ⊗ V1'
     @test V1 * V2 * unitspace(V1)' * V3 ==
-        @constinferred(insertleftunit(P, 3; conj = true)) ==
-        @constinferred(insertrightunit(P, 2; conj = true))
-    @test P == @constinferred(removeunit(insertleftunit(P, 3), 3))
+        @constinferred(insertleftunitspace(P, 3; conj = true)) ==
+        @constinferred(insertrightunitspace(P, 2; conj = true))
+    @test P == @constinferred(removeunitspace(insertleftunitspace(P, 3), 3))
     @test fuse(V1, V2', V3) ≅ V1 ⊗ V2' ⊗ V3
     @test fuse(V1, V2', V3) ≾ V1 ⊗ V2' ⊗ V3 ≾ fuse(V1 ⊗ V2' ⊗ V3)
     @test fuse(V1, V2') ⊗ V3 ≾ V1 ⊗ V2' ⊗ V3
@@ -433,22 +433,22 @@ end
         @test permute(W, ((2, 4, 5), (3, 1))) == (V2 ⊗ V4' ⊗ V5' ← V3 ⊗ V1')
         @test (V1 ⊗ V2 ← V1 ⊗ V2) == @constinferred TensorKit.compose(W, W')
         @test (V1 ⊗ V2 ← V3 ⊗ V4 ⊗ V5 ⊗ unitspace(V5)) ==
-            @constinferred(insertleftunit(W)) ==
-            @constinferred(insertrightunit(W))
-        @test @constinferred(removeunit(insertleftunit(W), $(numind(W) + 1))) == W
+            @constinferred(insertleftunitspace(W)) ==
+            @constinferred(insertrightunitspace(W))
+        @test @constinferred(removeunitspace(insertleftunitspace(W), $(numind(W) + 1))) == W
         @test (V1 ⊗ V2 ← V3 ⊗ V4 ⊗ V5 ⊗ unitspace(V5)') ==
-            @constinferred(insertleftunit(W; conj = true)) ==
-            @constinferred(insertrightunit(W; conj = true))
+            @constinferred(insertleftunitspace(W; conj = true)) ==
+            @constinferred(insertrightunitspace(W; conj = true))
         @test (unitspace(V1) ⊗ V1 ⊗ V2 ← V3 ⊗ V4 ⊗ V5) ==
-            @constinferred(insertleftunit(W, 1)) ==
-            @constinferred(insertrightunit(W, 0))
+            @constinferred(insertleftunitspace(W, 1)) ==
+            @constinferred(insertrightunitspace(W, 0))
         @test (V1 ⊗ V2 ⊗ unitspace(V1) ← V3 ⊗ V4 ⊗ V5) ==
-            @constinferred(insertrightunit(W, 2))
+            @constinferred(insertrightunitspace(W, 2))
         @test (V1 ⊗ V2 ← unitspace(V1) ⊗ V3 ⊗ V4 ⊗ V5) ==
-            @constinferred(insertleftunit(W, 3))
-        @test @constinferred(removeunit(insertleftunit(W, 3), 3)) == W
-        @test @constinferred(insertrightunit(one(V1) ← V1, 0)) == (unitspace(V1) ← V1)
-        @test_throws BoundsError insertleftunit(one(V1) ← V1, 0)
+            @constinferred(insertleftunitspace(W, 3))
+        @test @constinferred(removeunitspace(insertleftunitspace(W, 3), 3)) == W
+        @test @constinferred(insertrightunitspace(one(V1) ← V1, 0)) == (unitspace(V1) ← V1)
+        @test_throws BoundsError insertleftunitspace(one(V1) ← V1, 0)
     end
 end
 
diff --git a/test/tensors/tensors.jl b/test/tensors/tensors.jl
@@ -50,7 +50,7 @@ for V in spacelist
                 next = @constinferred Nothing iterate(bs, state)
                 b2 = @constinferred block(t, first(blocksectors(t)))
                 @test b1 == b2
-                @test eltype(bs) === Pair{typeof(c),typeof(b1)}
+                @test eltype(bs) === Pair{typeof(c), typeof(b1)}
                 @test typeof(b1) === TK.blocktype(t)
                 @test typeof(c) === sectortype(t)
             end
@@ -112,7 +112,7 @@ for V in spacelist
                 next = @constinferred Nothing iterate(bs, state)
                 b2 = @constinferred block(t', first(blocksectors(t')))
                 @test b1 == b2
-                @test eltype(bs) === Pair{typeof(c),typeof(b1)}
+                @test eltype(bs) === Pair{typeof(c), typeof(b1)}
                 @test typeof(b1) === TK.blocktype(t')
                 @test typeof(c) === sectortype(t)
                 # linear algebra
@@ -156,20 +156,20 @@ for V in spacelist
                 @test scalartype(t2) === T
                 @test t.data === t2.data
                 @test @constinferred(removeunitspace(t2, $(numind(t2)))) == t
-                t3 = @constinferred insertleftunitspace(t; copy=true)
-                @test t3 == @constinferred insertrightunitspace(t; copy=true)
+                t3 = @constinferred insertleftunitspace(t; copy = true)
+                @test t3 == @constinferred insertrightunitspace(t; copy = true)
                 @test t.data !== t3.data
                 for (c, b) in blocks(t)
                     @test b == block(t3, c)
                 end
                 @test @constinferred(removeunitspace(t3, $(numind(t3)))) == t
-                t4 = @constinferred insertrightunitspace(t, 3; dual=true)
+                t4 = @constinferred insertrightunitspace(t, 3; dual = true)
                 @test numin(t4) == numin(t) && numout(t4) == numout(t) + 1
                 for (c, b) in blocks(t)
                     @test b == block(t4, c)
                 end
                 @test @constinferred(removeunitspace(t4, 4)) == t
-                t5 = @constinferred insertleftunitspace(t, 4; dual=true)
+                t5 = @constinferred insertleftunitspace(t, 4; dual = true)
                 @test numin(t5) == numin(t) + 1 && numout(t5) == numout(t)
                 for (c, b) in blocks(t)
                     @test b == block(t5, c)
