Extracting a 'k-leaf subtree' from a tensor

[nimaser]

Suppose I have a quantum state expressed in the basis of M-leaf fusion trees labeled with, for the purpose of this question, FibonacciAnyon sectors, stored as a Tensor. As a very simple example, suppose I start with:

num_leaves=5
V = Vect[FibonacciAnyon](unit(FibonacciAnyon) => 1)
t = ones(V^num_leaves)

The basis shape is:

1  2 3 4 5
 \/ / / /
  \/ / /
   \/ /
    \/
     \
      R

And then I modify it in some way so that my leaves and branches and root values are some arbitrary values rather than just the unit sectors, i.e. I have some general quantum state.

Suppose I want to then 'extract' a '3-leaf subtree' from this tensor. On paper, I would do a series of F-moves to rewrite the state's basis so it has the following shape:

1 2  3 4 5
 \ \/ / /
  \ \/ /
   \/ /
    \/
     \
      R

More generally, I want to extract a k-leaf subtree starting from index i in the tensor. To avoid an XY problem, I want to do two primary things with the subtree routine:

• split off a k=2 tree, then project into the total fusion result using Born rule sampling, and discard the 2-leaf tree leaving an M-1 leaf tree
• split off a k<10 tree, then apply dynamics to the state that are easily and efficiently expressed in the split-off subspace, but inconvenient to try to apply to the whole tensor

All of the FusionTrees in TensorKit appear to be left-handed, and it looks like the approach using the existing braid/repartition mechanisms would be inefficient: I could move my subtree to the very front of the tree via braids, then do any operations on it there, then move it back, but then this is at least O(M) braid moves.

Since the subtree itself is left-handed, I was hoping there might be a way to take the original M-leaf tree as input and split off the subtree, returning two trees, one with M-k+1 leaves, and the other with k leaves, where the latter's coupled charge attaches to one of the former's leaves. These could then be merged back together using an inverse procedure. From this part of the docs I have an inkling that this can be done, because after all F moves are unitary basis transformations that can be implemented by tensor contractions, but I fear my background in tensor networks, especially as they're applied here, is not quite enough to grasp it.

Thanks for any assistance!

[Jutho]

At the level of fusion trees, there are a whole bunch of methods for manipulating fusion trees. While they are internal, they have some documentation. You might want to look into "src/fusiontrees/basic_manipulations.jl". No need to look at the code, just the markdown docstrings.

Since I am not sure what exactly you want to do, it would be useful if you could tell me what type of operations you want to do exactly using the building blocks there. I might then be able to help you find a way of doing that at the level of the TensorMap objects.

[nimaser]

In terms of fusion trees, what I'm looking for is insertat and its opposite, "extractat":

extractat(f::FusionTree{I, N}, i::Int, k::Int)

The third image in this section of the docs, pasted here for convenience

shows how

insertat(f1::FusionTree{I, N₁}, i::Int, f2::FusionTree{I, N₂})

can take two fusion trees that are separately in standard form and, as long as f2's coupled charge matches f1's uncoupled charge at the insertion point i, recouple them so that they're a linear combination of single trees each in standard form. extractat would do the opposite basis transformation, where it takes a single standard form tree and results in a linear combination over pairs of two standard form 'subtrees'. This image shows the process for a 6-leaf f, with i=2 and k=3:

i is the first leaf in the extracted subtree, and i+k-1 is the last. The return value could be a dictionary mapping pairs of fusion trees (like the f1, f2 arguments to insertat) to coefficients. In the above image, f1 has uncoupled charges a1, d2, a5, a6, innerlines b3, b4, and coupled charge c, while f2 has uncoupled charges a2, a3, a4, innerlines d1, and coupled charge d2. For each (f1, f2) pair, the d2 leaf and coupled charges are the same. Let's call f1 and f2 the 'remainder' and 'extracted' fusiontrees respectively.

I have some function, call it g, which is most easily expressed in terms of its action on states expressed in the f1 and f2 basis. In particular, it does not modify the f1 part of the state at all, nor does it change the coupled charge of f2. It only reapportions quantum amplitude between different labelings of f2's uncoupled charges and innerlines which have the same coupled charge value. I would like to write a function

with_subtree(g, f::FusionTree{I, N}, i::Int, k::Int)

which extracts f according to i and k, applies g to each resulting f2, then uses insertat to get back a linear combination over f-shaped standard form trees.

extractat creates a superposition over the possible labelings of f2. g is linear, so it is applied to each such labeling, with each application resulting in a linear combination over possible labelings of f2, multiplied by the coefficient of the labeling g was applied to. At the end, each labeling of f2 may have amplitude contributed to its total amplitude from multiple of these linear combinations, and so it would be ideal if this function could operate at the Tensor level and automatically aggregate those amplitudes together.

The particular example of g I'm interested in are equations 77 and 87 in this 2022 paper by Schotte et al: to make use of the tensor network-calculated matrix elements (eqs 90-94), the state needs to be written with a 2- or 4-leaf subtree extracted, as seen in eqs 75 and 84 respectively. Those equations seem to be implementable as tensor network contractions if I can get the extraction working properly, but if no such routines exist then I think it should be possible to hand-roll something using the FusionTree-level manipulations.

Apologies for the longer post, hopefully this is sufficient detail to understand what I'm trying to do 😅.

[lkdvos]

I think in general the way I would try this that is the most straightforward (albeit not necessarily the most efficient) is to do things like this is through tensor maps by making use of the fact that fusiontrees form an orthonormal basis set. What I'm getting at here is that if you want to act on the some subset of the indices with a fusiontree-dependent coefficient, you can combine a "project the subtree on a given specific tree" with a scalar + "map to a different subtree" by constructing an operator that does this.

To give some flavor of this, imagine I want to map 2-leg subtree f2 in the original state to subtree f1 with a given transition alpha, I can create a (2, 2) tensormap acting on the 2 leaves, that therefore contains f2 as fusion tree and f1 as splitting tree, fill it with zeros, set t[f1, f2] .= alpha, and then multiply through @tensor state2[i j' k' l] := t[j' k'; j k] * state[i j k l]. At least that makes it such that TensorKit is the one figuring out all of the recouplings, and these are in principle cached so there should mostly be a single upfront cost associated to that bookkeeping, I'm just not entirely sure how well it actually ends up scaling if you have very large number of legs.

Note also that this method would work equally well if you immediately fill out all transitions of possible f2s to possible f1s.

[nimaser]

I'm slightly confused. If:

• the quantum state, stored as a Tensor, is $|\psi\rangle$
• the product of F-move recoupling tensors which can be contracted with $|\psi\rangle$ to change the basis is $F$
• the quantum state, expressed in the 'extracted' basis in the image I posted above, is then $F|\psi\rangle$
• the operator I want to apply, which is in some sense 'small' or 'convenient' in said extracted basis, is $O$
• the state I want to end up with is then $F^{-1}OF|\psi\rangle$

Then which of the following is correct:

1. Your suggestion is that rather than starting with $|\psi\rangle$ and applying $F$, $O$, $F^{-1}$ one at a time, which would require being able to internally store non standard form trees (or some tensor product trees like in my image above), I should instead separately compute $F^{-1}OF$ upfront as an operator on the standard-form-basis quantum states supported by TensorKit, then apply it with a tensor contraction?
2. Your suggestion is that the $F$ and $F^{-1}$ recouplings are performed automatically under the hood by TensorKit whenever the domain of a map does not span the entire space of a quantum state. Therefore, I can directly contract O, decomposed into 'projection-like' operators that map subtree1 to subtree2 while picking up a coefficient $\alpha$, onto $|\psi\rangle$, and get the result $F^{-1}OF|\psi\rangle$? To be concrete about this, suppose my state's basis is fusion trees with 8 leaves. I know I want to extract out a subtree of four leaves starting from leaf 3, so leaves 3, 4, 5, and 6, apply the operator O (which acts nontrivially only on the extracted 4-leaf subtree, and as identity on the rest of the tree), then change basis back to standard form. So I can just decompose O as projection-like operators on leaves 3-6 of the overall state, using the same coefficients and everything as I would have while applying it to the extracted state, and TensorKit will be smart enough to figure out the recouplings on its own?

The reason I ask is because in principle O acts not just based on the leaves but also on the innerlines of the extracted subtree, which would have different values compared to the innerlines of the unextracted full state (labels d1 vs b1 in the above hand-drawn image).