What does compress_all() do?

[cotejer]

I've been using the TensorNetwork class and have been trying to do the equivalent of an MPS sweep after performing a contraction. Is this what compress_all does?

[jcmgray]

Hi @cotejer, compress_all is quite a basic function that assumes no particular geometry and simply takes every bond in the tensor network, in any order, and compresses between the two tensors. How well the compression works always depends on the environment of the tensors.

Depending on what geometry you have (?), e.g. a tree or MPS, then you would probably want to take a more systematic approach where you shift the 'orthogonality center' around, and therefore use the ideal environment for each compression. Here's a method (not pushed to quimb yet..) that could do that automatically.

    def compress_all_tree(self, inplace=False, **compress_opts):
        """Canonically compress this tensor network, assuming it to be a tree.
        This generates a tree spanning out from the most central tensor, then
        compresses all bonds inwards in a depth-first manner, using an infinite
        ``canonize_distance`` to shift the orthogonality center.
        """
        tn = self if inplace else self.copy()

        # order out spanning tree by depth first search
        def sorter(t, tn, distances, connectivity):
            return distances[t]

        tid0 = tn.most_central_tid()
        span = tn.get_tree_span([tid0], sorter=sorter)
        for tid1, tid2, _ in span:
            # absorb='right' shifts orthog center inwards
            tn._compress_between_tids(
                tid1, tid2, absorb='right',
                canonize_distance=float('inf'), **compress_opts)

        return tn

However if your TN is not a tree (i.e. has loops) then the best way to compress becomes quite a non-trivial problem.

[cotejer]

@jcmgray Thanks for the explanation.

In my case, I could have loops. If I understand correctly, is compress_all_tree something similar to what you implement in your recent paper (in particular, Figure 5)? Even if you don't have a tree in that case, you can still use the function (though it won't be optimal). Do I have this right?

[jcmgray]

No they are a little different:

1. compress_all_tree is an almost optimal way to compress all bonds in a TN given that it has a global tree geometry.
2. the 'tree gauge' in our paper is a simple way to gauge the environment of a single bond pre compression, by pretending it has a local tree structure.

If you compressed the bonds in a certain order, and took the 'tree gauge' distance to be $r=\infty$, then I think you can recover 1 from 2 however.

[cotejer]

Thanks for clarifying. I think with these two explanations I should be able to figure out how to approach my tensor network with arbitrary geometry.

[cotejer]

@jcmgray If I may ask, for the "tree gauge" approach in your paper, is this what the contract_around method is doing? I see that there's an option to set tree_gauge_distance, which seems like it's setting up the environment according to point 2 you had above.

[jcmgray]

Yes contract_around and contract_compressed both call the underlying algorithm as described in the paper, which inserts compressions into a contraction tree/order. tree_gauge_distance controls the distance to use for gauging the environment prior and after each compression, using a simple tree approximation.