fix arg order braid

Author: lkdvos

src/fusiontrees/manipulations.jl

@@ -936,7 +936,7 @@ end
 
 # braid fusion tree
 """
-    braid(f::FusionTree{<:Sector, N}, levels::NTuple{N, Int}, p::NTuple{N, Int})
+    braid(f::FusionTree{<:Sector, N}, p::NTuple{N, Int}, levels::NTuple{N, Int})
     -> <:AbstractDict{typeof(t), <:Number}
 
 Perform a braiding of the uncoupled indices of the fusion tree `f` and return the result as
@@ -949,7 +949,7 @@ that if `i` and `j` cross, ``τ_{i,j}`` is applied if `levels[i] < levels[j]` an
 ``τ_{j,i}^{-1}`` if `levels[i] > levels[j]`. This does not allow to encode the most general
 braid, but a general braid can be obtained by combining such operations.
 """
-function braid(f::FusionTree{I,N}, levels::NTuple{N,Int}, p::NTuple{N,Int}) where {I,N}
+function braid(f::FusionTree{I,N}, p::NTuple{N,Int}, levels::NTuple{N,Int}) where {I,N}
     TupleTools.isperm(p) || throw(ArgumentError("not a valid permutation: $p"))
     if FusionStyle(I) isa UniqueFusion && BraidingStyle(I) isa SymmetricBraiding
         coeff = one(sectorscalartype(I))
@@ -998,13 +998,13 @@ as a `<:AbstractDict` of output trees and corresponding coefficients; this requi
 """
 function permute(f::FusionTree{I,N}, p::NTuple{N,Int}) where {I,N}
     @assert BraidingStyle(I) isa SymmetricBraiding
-    return braid(f, ntuple(identity, Val(N)), p)
+    return braid(f, p, ntuple(identity, Val(N)))
 end
 
 # braid double fusion tree
 """
-    braid((f₁, f₂)::FusionTreePair{I}, (levels1, levels2)::Index2Tuple,
-          (p1, p2)::Index2Tuple{N₁, N₂}) where {I, N₁, N₂}
+    braid((f₁, f₂)::FusionTreePair{I}, (p1, p2)::Index2Tuple{N₁,N₂},
+          (levels1, levels2)::Index2Tuple) where {I,N₁,N₂}
         -> <:AbstractDict{<:FusionTreePair{I, N₁, N₂}}, <:Number}
 
 Input is a fusion-splitting tree pair that describes the fusion of a set of incoming
@@ -1019,22 +1019,22 @@ respectively, which determines how indices braid. In particular, if `i` and `j`
 levels[j]`. This does not allow to encode the most general braid, but a general braid can
 be obtained by combining such operations.
 """
-function braid((f₁, f₂)::FusionTreePair{I}, (levels1, levels2)::Index2Tuple,
-               (p1, p2)::Index2Tuple{N₁,N₂}) where {I,N₁,N₂}
+function braid((f₁, f₂)::FusionTreePair{I}, (p1, p2)::Index2Tuple{N₁,N₂},
+               (levels1, levels2)::Index2Tuple) where {I,N₁,N₂}
     @assert length(f₁) + length(f₂) == N₁ + N₂
     @assert length(f₁) == length(levels1) && length(f₂) == length(levels2)
     @assert TupleTools.isperm((p1..., p2...))
-    return fsbraid(((f₁, f₂), (levels1, levels2), (p1, p2)))
+    return fsbraid(((f₁, f₂), (p1, p2), (levels1, levels2)))
 end
-const FSBraidKey{I,N₁,N₂} = Tuple{<:FusionTreePair{I},Index2Tuple,Index2Tuple{N₁,N₂}}
+const FSBraidKey{I,N₁,N₂} = Tuple{<:FusionTreePair{I},Index2Tuple{N₁,N₂},Index2Tuple}
 
 @cached function fsbraid(key::FSBraidKey{I,N₁,N₂})::_fsdicttype(I, N₁, N₂) where {I,N₁,N₂}
-    ((f₁, f₂), (l1, l2), (p1, p2)) = key
+    ((f₁, f₂), (p1, p2), (l1, l2)) = key
     p = linearizepermutation(p1, p2, length(f₁), length(f₂))
     levels = (l1..., reverse(l2)...)
     local newtrees
     for ((f, f0), coeff1) in repartition((f₁, f₂), N₁ + N₂)
-        for (f′, coeff2) in braid(f, levels, p)
+        for (f′, coeff2) in braid(f, p, levels)
             for ((f₁′, f₂′), coeff3) in repartition((f′, f0), N₁)
                 if @isdefined newtrees
                     newtrees[(f₁′, f₂′)] = get(newtrees, (f₁′, f₂′), zero(coeff3)) +
@@ -1067,9 +1067,9 @@ outgoing (`t1`) and incoming sectors (`t2`) respectively (with identical coupled
 repartitioning and permuting the tree such that sectors `p1` become outgoing and sectors
 `p2` become incoming.
 """
-function permute((f₁, f₂)::FusionTreePair{I}, (p1, p2)::Index2Tuple{N₁, N₂}) where {I, N₁, N₂}
+function permute((f₁, f₂)::FusionTreePair{I}, (p1, p2)::Index2Tuple{N₁,N₂}) where {I,N₁,N₂}
     @assert BraidingStyle(I) isa SymmetricBraiding
     levels1 = ntuple(identity, length(f₁))
     levels2 = length(f₁) .+ ntuple(identity, length(f₂))
-    return braid((f₁, f₂), (levels1, levels2), (p1, p2))
+    return braid((f₁, f₂), (p1, p2), (levels1, levels2))
 end

src/fusiontrees/uncouplediterator.jl

@@ -19,7 +19,6 @@ function fusiontrees(iter::OuterTreeIterator{I,N₁,N₂}) where {I,N₁,N₂}
     trees = Vector{Tuple{F₁,F₂}}(undef, 0)
     for c in blocksectors(iter), f₁ in fusiontrees(iter.uncoupled[1], c, iter.isdual[1]),
         f₂ in fusiontrees(iter.uncoupled[2], c, iter.isdual[2])
-
         push!(trees, (f₁, f₂))
     end
     return trees
@@ -211,10 +210,10 @@ end
 const _FSTransposeKey{I,N₁,N₂} = Tuple{<:OuterTreeIterator{I},Index2Tuple{N₁,N₂}}
 
 @cached function _fstranspose(key::_FSTransposeKey{I,N₁,N₂})::Tuple{OuterTreeIterator{I,N₁,
-                                                                                     N₂},
-                                                                   Matrix{sectorscalartype(I)}} where {I,
-                                                                                                       N₁,
-                                                                                                       N₂}
+                                                                                      N₂},
+                                                                    Matrix{sectorscalartype(I)}} where {I,
+                                                                                                        N₁,
+                                                                                                        N₂}
     fs_src, (p1, p2) = key
 
     N = N₁ + N₂
@@ -277,8 +276,8 @@ function artin_braid(fs_src::OuterTreeIterator{I,N,0}, i; inv::Bool=false) where
     return fs_dst, U
 end
 
-function braid(fs_src::OuterTreeIterator{I,N,0}, levels::NTuple{N,Int},
-               p::NTuple{N,Int}) where {I,N}
+function braid(fs_src::OuterTreeIterator{I,N,0}, p::NTuple{N,Int},
+               levels::NTuple{N,Int}) where {I,N}
     TupleTools.isperm(p) || throw(ArgumentError("not a valid permutation: $p"))
 
     if FusionStyle(I) isa UniqueFusion && BraidingStyle(I) isa SymmetricBraiding
@@ -292,7 +291,7 @@ function braid(fs_src::OuterTreeIterator{I,N,0}, levels::NTuple{N,Int},
         U = zeros(sectorscalartype(I), length(trees_dst), length(trees_src))
 
         for (col, (f₁, f₂)) in enumerate(trees_src)
-            for (f₁′, c) in braid(f₁, levels, p)
+            for (f₁′, c) in braid(f₁, p, levels)
                 row = indexmap[(f₁′, f₂)]
                 U[row, col] = c
             end
@@ -310,27 +309,27 @@ function braid(fs_src::OuterTreeIterator{I,N,0}, levels::NTuple{N,Int},
     return fs_dst, U
 end
 
-function braid(fs_src::OuterTreeIterator{I}, levels::Index2Tuple,
-               p::Index2Tuple{N₁,N₂}) where {I,N₁,N₂}
+function braid(fs_src::OuterTreeIterator{I}, p::Index2Tuple{N₁,N₂},
+               levels::Index2Tuple) where {I,N₁,N₂}
     @assert numind(fs_src) == N₁ + N₂
     @assert numout(fs_src) == length(levels[1]) && numin(fs_src) == length(levels[2])
     @assert TupleTools.isperm((p[1]..., p[2]...))
-    return _fsbraid((fs_src, levels, p))
+    return _fsbraid((fs_src, p, levels))
 end
 
-const _FSBraidKey{I,N₁,N₂} = Tuple{<:OuterTreeIterator{I},Index2Tuple,Index2Tuple{N₁,N₂}}
+const _FSBraidKey{I,N₁,N₂} = Tuple{<:OuterTreeIterator{I},Index2Tuple{N₁,N₂},Index2Tuple}
 
 @cached function _fsbraid(key::_FSBraidKey{I,N₁,N₂})::Tuple{OuterTreeIterator{I,N₁,N₂},
-                                                           Matrix{sectorscalartype(I)}} where {I,
-                                                                                               N₁,
-                                                                                               N₂}
-    fs_src, (l1, l2), (p1, p2) = key
+                                                            Matrix{sectorscalartype(I)}} where {I,
+                                                                                                N₁,
+                                                                                                N₂}
+    fs_src, (p1, p2), (l1, l2) = key
 
     p = linearizepermutation(p1, p2, numout(fs_src), numin(fs_src))
     levels = (l1..., reverse(l2)...)
 
     fs_dst, U = repartition(fs_src, numind(fs_src))
-    fs_dst, U_tmp = braid(fs_dst, levels, p)
+    fs_dst, U_tmp = braid(fs_dst, p, levels)
     U = U_tmp * U
     fs_dst, U_tmp = repartition(fs_dst, N₁)
     U = U_tmp * U
@@ -349,5 +348,5 @@ function permute(fs_src::OuterTreeIterator{I}, p::Index2Tuple) where {I}
     @assert BraidingStyle(I) isa SymmetricBraiding
     levels1 = ntuple(identity, numout(fs_src))
     levels2 = numout(fs_src) .+ ntuple(identity, numin(fs_src))
-    return braid(fs_src, (levels1, levels2), p)
+    return braid(fs_src, p, (levels1, levels2))
 end

src/tensors/treetransformers.jl

@@ -153,14 +153,14 @@ end
 
 # braid is special because it has levels
 function treebraider(::AbstractTensorMap, ::AbstractTensorMap, p::Index2Tuple, levels)
-    return fusiontreetransform(f) = braid(f, levels, p)
+    return fusiontreetransform(f) = braid(f, p, levels)
 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(f) = braid(f, levels, p)
+    fusiontreebraider(f) = braid(f, p, levels)
     return TreeTransformer(fusiontreebraider, p, Vdst, Vsrc)
 end
 

test/fusiontrees.jl

@@ -89,13 +89,13 @@ ti = time()
                 @test c′ == one(c′)
                 return t′
             end
-            braid_i_to_1 = braid(f1, levels, (i, (1:(i - 1))..., ((i + 1):N)...))
+            braid_i_to_1 = braid(f1, (i, (1:(i - 1))..., ((i + 1):N)...), levels)
             trees2 = Dict(_reinsert_partial_tree(t, f2) => c for (t, c) in braid_i_to_1)
             trees3 = empty(trees2)
             p = (((N + 1):(N + i - 1))..., (1:N)..., ((N + i):(2N - 1))...)
             levels = ((i:(N + i - 1))..., (1:(i - 1))..., ((i + N):(2N - 1))...)
             for (t, coeff) in trees2
-                for (t′, coeff′) in braid(t, levels, p)
+                for (t′, coeff′) in braid(t, p, levels)
                     trees3[t′] = get(trees3, t′, zero(coeff′)) + coeff * coeff′
                 end
             end
@@ -273,11 +273,11 @@ ti = time()
         ip = invperm(p)
 
         levels = ntuple(identity, N)
-        d = @constinferred braid(f, levels, p)
+        d = @constinferred braid(f, p, levels)
         d2 = Dict{typeof(f),valtype(d)}()
         levels2 = p
         for (f2, coeff) in d
-            for (f1, coeff2) in braid(f2, levels2, ip)
+            for (f1, coeff2) in braid(f2, ip, levels2)
                 d2[f1] = get(d2, f1, zero(coeff)) + coeff2 * coeff
             end
         end
@@ -334,7 +334,7 @@ ti = time()
                 perm = ((N .+ (1:N))..., (1:N)...)
                 levels = ntuple(identity, 2 * N)
                 for (t, coeff) in trees1
-                    for (t′, coeff′) in braid(t, levels, perm)
+                    for (t′, coeff′) in braid(t, perm, levels)
                         trees3[t′] = get(trees3, t′, zero(valtype(trees3))) + coeff * coeff′
                     end
                 end