FusionTreePair

Author: lkdvos

src/fusiontrees/fusiontrees.jl

@@ -92,6 +92,8 @@ function FusionTree(uncoupled::NTuple{N,I}, coupled::I,
 end
 FusionTree(uncoupled::Tuple{I,Vararg{I}}) where {I<:Sector} = FusionTree(uncoupled, one(I))
 
+const FusionTreePair{I,N₁,N₂} = Tuple{FusionTree{I,N₁},FusionTree{I,N₂}}
+
 # Properties
 sectortype(::Type{<:FusionTree{I}}) where {I<:Sector} = I
 FusionStyle(::Type{<:FusionTree{I}}) where {I<:Sector} = FusionStyle(I)
@@ -199,8 +201,7 @@ function Base.convert(A::Type{<:AbstractArray}, f::FusionTree{I,N}) where {I,N}
 end
 
 # TODO: is this piracy?
-function Base.convert(A::Type{<:AbstractArray},
-                      (f₁, f₂)::Tuple{FusionTree{I},FusionTree{I}}) where {I}
+function Base.convert(A::Type{<:AbstractArray}, (f₁, f₂)::FusionTreePair{I}) where {I}
     F₁ = convert(A, f₁)
     F₂ = convert(A, f₂)
     sz1 = size(F₁)

src/fusiontrees/manipulations.jl

@@ -230,7 +230,7 @@ function planarcontract!(C::AbstractTensorMap,
     inv_braid = τ_levels[cindA[1]] > τ_levels[cindA[2]]
     for (f₁, f₂) in fusiontrees(B)
         local newtrees
-        for ((f₁′, f₂′), coeff′) in transpose(f₁, f₂, cindB, oindB)
+        for ((f₁′, f₂′), coeff′) in transpose((f₁, f₂), (cindB, oindB))
             for (f₁′′, coeff′′) in artin_braid(f₁′, 1; inv=inv_braid)
                 f12 = (f₁′′, f₂′)
                 coeff = coeff′ * coeff′′
@@ -281,7 +281,7 @@ function planarcontract!(C::AbstractTensorMap,
 
     for (f₁, f₂) in fusiontrees(A)
         local newtrees
-        for ((f₁′, f₂′), coeff′) in transpose(f₁, f₂, oindA, cindA)
+        for ((f₁′, f₂′), coeff′) in transpose((f₁, f₂), oindA, cindA)
             for (f₂′′, coeff′′) in artin_braid(f₂′, 1; inv=inv_braid)
                 f12 = (f₁′, f₂′′)
                 coeff = coeff′ * conj(coeff′′)

src/tensors/braidingtensor.jl

@@ -203,7 +203,7 @@ function permute(d::DiagonalTensorMap, (p₁, p₂)::Index2Tuple{1,1};
         d′ = typeof(d)(undef, dual(d.domain))
         for (c, b) in blocks(d)
             f = only(fusiontrees(codomain(d), c))
-            ((f′, _), coeff) = only(permute(f, f, p₁, p₂))
+            ((f′, _), coeff) = only(permute((f, f), (p₁, p₂)))
             c′ = f′.coupled
             scale!(block(d′, c′), b, coeff)
         end

src/tensors/diagonal.jl

@@ -17,7 +17,7 @@ function flip(t::AbstractTensorMap, I; inv::Bool=false)
     P = flip(space(t), I)
     t′ = similar(t, P)
     for (f₁, f₂) in fusiontrees(t)
-        (f₁′, f₂′), factor = only(flip(f₁, f₂, I; inv))
+        (f₁′, f₂′), factor = only(flip((f₁, f₂), I; inv))
         scale!(t′[f₁′, f₂′], t[f₁, f₂], factor)
     end
     return t′
@@ -558,7 +558,7 @@ function _add_abelian_kernel_threaded!(tdst, tsrc, p, transformer, α, β, backe
 end
 
 function _add_abelian_block!(tdst, tsrc, p, transformer, f₁, f₂, α, β, backend...)
-    (f₁′, f₂′), coeff = first(transformer(f₁, f₂))
+    (f₁′, f₂′), coeff = first(transformer((f₁, f₂)))
     @inbounds TO.tensoradd!(tdst[f₁′, f₂′], tsrc[f₁, f₂], p, false, α * coeff, β,
                             backend...)
     return nothing
@@ -618,7 +618,7 @@ function _add_general_kernel_nonthreaded!(tdst, tsrc, p, transformer, α, β, ba
         tdst = scale!(tdst, β)
     end
     for (f₁, f₂) in fusiontrees(tsrc)
-        for ((f₁′, f₂′), coeff) in transformer(f₁, f₂)
+        for ((f₁′, f₂′), coeff) in transformer((f₁, f₂))
             @inbounds TO.tensoradd!(tdst[f₁′, f₂′], tsrc[f₁, f₂], p, false, α * coeff,
                                     One(), backend...)
         end
@@ -683,7 +683,7 @@ end
 function _add_nonabelian_sector!(tdst, tsrc, p, fusiontreetransform, s₁, s₂, α, backend...)
     for (f₁, f₂) in fusiontrees(tsrc)
         (f₁.uncoupled == s₁ && f₂.uncoupled == s₂) || continue
-        for ((f₁′, f₂′), coeff) in fusiontreetransform(f₁, f₂)
+        for ((f₁′, f₂′), coeff) in fusiontreetransform((f₁, f₂))
             @inbounds TO.tensoradd!(tdst[f₁′, f₂′], tsrc[f₁, f₂], p, false, α * coeff,
                                     One(), backend...)
         end

src/tensors/indexmanipulations.jl

@@ -199,7 +199,7 @@ function trace_permute!(tdst::AbstractTensorMap,
         r₁ = (p₁..., q₁...)
         r₂ = (p₂..., q₂...)
         for (f₁, f₂) in fusiontrees(tsrc)
-            for ((f₁′, f₂′), coeff) in permute(f₁, f₂, r₁, r₂)
+            for ((f₁′, f₂′), coeff) in permute((f₁, f₂), (r₁, r₂))
                 f₁′′, g₁ = split(f₁′, N₁)
                 f₂′′, g₂ = split(f₂′, N₂)
                 g₁ == g₂ || continue

src/tensors/tensoroperations.jl

@@ -166,29 +166,29 @@ end
 
 # braid is special because it has levels
 function treebraider(::AbstractTensorMap, ::AbstractTensorMap, p::Index2Tuple, levels)
-    return fusiontreetransform(f1, f2) = braid(f1, f2, levels..., p...)
+    return fusiontreetransform((f1, f2)) = braid((f1, f2), levels, p)
 end
 function treebraider(tdst::TensorMap, tsrc::TensorMap, p::Index2Tuple, levels)
     return treebraider(space(tdst), space(tsrc), p, levels)
 end
 @cached function treebraider(Vdst::TensorMapSpace, Vsrc::TensorMapSpace, p::Index2Tuple,
                              levels)::treetransformertype(Vdst, Vsrc)
-    fusiontreebraider(f1, f2) = braid(f1, f2, levels..., p...)
+    fusiontreebraider((f1, f2)) = braid((f1, f2), levels, p)
     return TreeTransformer(fusiontreebraider, p, Vdst, Vsrc)
 end
 
 for (transform, treetransformer) in
     ((:permute, :treepermuter), (:transpose, :treetransposer))
     @eval begin
         function $treetransformer(::AbstractTensorMap, ::AbstractTensorMap, p::Index2Tuple)
-            return fusiontreetransform(f1, f2) = $transform(f1, f2, p...)
+            return fusiontreetransform(f1, f2) = $transform((f1, f2), p)
         end
         function $treetransformer(tdst::TensorMap, tsrc::TensorMap, p::Index2Tuple)
             return $treetransformer(space(tdst), space(tsrc), p)
         end
         @cached function $treetransformer(Vdst::TensorMapSpace, Vsrc::TensorMapSpace,
                                           p::Index2Tuple)::treetransformertype(Vdst, Vsrc)
-            fusiontreetransform(f1, f2) = $transform(f1, f2, p...)
+            fusiontreetransform((f1, f2)) = $transform((f1, f2), p)
             return TreeTransformer(fusiontreetransform, p, Vdst, Vsrc)
         end
     end

src/tensors/treetransformers.jl

@@ -432,12 +432,12 @@ ti = time()
                 ip = invperm(p)
                 ip1, ip2 = ip[1:N], ip[(N + 1):(2N)]
 
-                d = @constinferred TensorKit.permute(f1, f2, p1, p2)
+                d = @constinferred TensorKit.permute((f1, f2), (p1, p2))
                 @test dim(incoming) ≈
                       sum(abs2(coef) * dim(f1.coupled) for ((f1, f2), coef) in d)
                 d2 = Dict{typeof((f1, f2)),valtype(d)}()
                 for ((f1′, f2′), coeff) in d
-                    d′ = TensorKit.permute(f1′, f2′, ip1, ip2)
+                    d′ = TensorKit.permute((f1′, f2′), (ip1, ip2))
                     for ((f1′′, f2′′), coeff2) in d′
                         d2[(f1′′, f2′′)] = get(d2, (f1′′, f2′′), zero(coeff)) +
                                            coeff2 * coeff
@@ -490,12 +490,12 @@ ti = time()
             ip′ = tuple(getindex.(Ref(vcat(1:n, (2N):-1:(n + 1))), ip)...)
             ip1, ip2 = ip′[1:N], ip′[(2N):-1:(N + 1)]
 
-            d = @constinferred transpose(f1, f2, p1, p2)
+            d = @constinferred transpose((f1, f2), (p1, p2))
             @test dim(incoming) ≈
                   sum(abs2(coef) * dim(f1.coupled) for ((f1, f2), coef) in d)
             d2 = Dict{typeof((f1, f2)),valtype(d)}()
             for ((f1′, f2′), coeff) in d
-                d′ = transpose(f1′, f2′, ip1, ip2)
+                d′ = transpose((f1′, f2′), (ip1, ip2))
                 for ((f1′′, f2′′), coeff2) in d′
                     d2[(f1′′, f2′′)] = get(d2, (f1′′, f2′′), zero(coeff)) + coeff2 * coeff
                 end
@@ -509,7 +509,7 @@ ti = time()
             end
 
             if BraidingStyle(I) isa Bosonic
-                d3 = permute(f1, f2, p1, p2)
+                d3 = permute((f1, f2), (p1, p2))
                 for (f1′, f2′) in union(keys(d), keys(d3))
                     coeff1 = get(d, (f1′, f2′), zero(valtype(d)))
                     coeff3 = get(d3, (f1′, f2′), zero(valtype(d3)))
@@ -546,14 +546,15 @@ ti = time()
         end
     end
     @testset "Double fusion tree $Istr: planar trace" begin
-        d1 = transpose(f1, f1, (N + 1, 1:N..., ((2N):-1:(N + 3))...), (N + 2,))
+        d1 = transpose((f1, f1), ((N + 1, 1:N..., ((2N):-1:(N + 3))...), (N + 2,)))
         f1front, = TK.split(f1, N - 1)
         T = typeof(Fsymbol(one(I), one(I), one(I), one(I), one(I), one(I))[1, 1, 1, 1])
         d2 = Dict{typeof((f1front, f1front)),T}()
         for ((f1′, f2′), coeff′) in d1
             for ((f1′′, f2′′), coeff′′) in
-                TK.planar_trace(f1′, f2′, (2:N...,), (1, ((2N):-1:(N + 3))...), (N + 1,),
-                                (N + 2,))
+                TK.planar_trace((f1′, f2′), ((2:N...,), (1, ((2N):-1:(N + 3))...)),
+                                ((N + 1,),
+                                 (N + 2,)))
                 coeff = coeff′ * coeff′′
                 d2[(f1′′, f2′′)] = get(d2, (f1′′, f2′′), zero(coeff)) + coeff
             end