Custom contraction path

[epelaaez]

I have the following tensor network.

Ignoring outer edges, I can graph this as:

I compute a contraction path of the form [(2, 3), (4, 5), (0, 1), (0, 2), (1, 2), (3, 4), (5, 6)], which I want to transverse in reverse. I.e., first contract tensors 5 and 6, then 3 and 4, and so on. Is there a way to do this with tn.contract?

[jcmgray]

Hi @epelaaez, there are a number of ways to specify a contraction path, but mostly quimb is orientated around automated path finding. For converting/understanding your path, some information I'd need is what are you naming the tensor resulting from contracting e.g. (2, 3) -> i ? Both 2 and 3 appear later in that path. (Also, as a side note, the two graphs don't appear to match to me, even with dangling legs removed?)

I think your options if you don't want to use automated contraction are:

manual contraction using tags

1. use tags to contract pairs of tensors. I.e. if you uniquely identify each tensor with a tag like 'T2' or 'T3', then tn.contract_tags_(['T2', 'T3']) will contract those tensors and the resulting tensor will have both those tags, either of which you can use to identify further contractions.

Since each contraction involves modifying the tensor network there is a slight performance hit to this approach, but you can draw the TN at each stage etc.

manual low level specification of path

The 'raw' path format quimb supports (i.e. you can supply tn.contract(optimize=path)) is specified like so:

• assume you have the tn.tensors in a list, indexed 0...N-1
• contraction (2, 3) would imply popping tensors at locations 3 and 2, then appending the result to the end of the list.

This is not a very convenient format to work with directly (since many tensors' index changes each contraction) and is inherited from opt_einsum.

SSA (single static assignment) path

This is a more easily understandable path, similar to the above but you assume that when contracting (2, 3) you don't pop them from the list, so the intermediates are labelled N, N + 1, ... and don't change during the contraction. cotengra and opt_einsum have functions to convert an SSA path into the raw format above.

cotengra.ContractionTree

If you use cotengra you can construct the contraction tree directly. There the nodes are specified like
[frozenset([i]) for i in range(N)], and so the parent of frozenset([2]) | frozenset([3]) == frozenset([2, 3]). Once complete you can extract the raw path or supply the tree directly.

[epelaaez]

Also, as a side note, the two graphs don't appear to match to me, even with dangling legs removed?

Whoops, just noticed I pasted the wrong networkx.Graphwithout the edges.

Anyways, thank you! This is very helpful, I think I'm going to try the manual contraction using tags, as that seems enough for my current purpose.

[epelaaez]

For future reference to anyone that this might be useful to, I ended up writing the following simple function:

def contract_tn(tn, path: List[Tuple[int, int]], inplace=False):
    tn = tn if inplace else tn.copy()
    tags = [f"T{i}" for i in range(tn.num_tensors)]
    
    # use tags
    for i, tensor in enumerate(tn):
        tensor.add_tag(f"T{i}")
    
    for edge in path:
        tn.contract_tags_([f"T{edge[0]}", f"T{edge[1]}"])

    tn.drop_tags(tags + ["contract"])
    return tn