Feature idea: apply local PEPOs to PEPS

[benjaminlanthier]

Hi @jcmgray,

Recently, I started exploring the classes MatrixProductState, MatrixProductOperator, PEPS, and PEPO to better understand the differences between the 1D and 2D tensor network representations in the library.

While doing so, I noticed a feature difference between the MatrixProductState and PEPS classes: in the MPS/MPO framework, it's straightforward to apply a sub-MPO to an MPS (withqtn.MatrixProductState.gate_with_submpo()). However, in the PEPS/PEPO framework, there doesn't seem to be an analogous built-in method for applying a sub-PEPO to a larger PEPS (unless I missed it in the documentation).
Some use cases could be:

• Some quantum operator (which can be written in MPO format) that acts on 2 or more (non-)local sites,
• Applying a 2×2 plaquette operator on a 4×4 lattice.

I was wondering whether there are any technical or design reasons for this limitation, or if it might be something worth considering for future development ?

[jcmgray]

Hi @benjaminlanthier, yes it would be great to have such a function! It doesn't exist yet just form lack of need and developer time.

More technically, in 1D there is usually an obvious way to do these things, whereas with loops everything becomes more complicated and there is no canonical way to do it.

I think a good starting point would be applying sub-MPO to strings of explicit given sites, optionally with simple update gauging, this has an obvious implementation (aside from gauging just looks like a 1D problem) and would be useful for long range gates.

[benjaminlanthier]

Thanks for the response!

If I may ask, which method would you recommend for simple update gauging in this case? My first idea would be to iteratively call the tensor_compress_bond(T1, T2, absorb="right", cutoff=cutoff) method, where T1 and T2 are tensors along the path between the two sites on which the operator is applied.

[jcmgray]

You'd want to gauge the bonds connecting the string to the environment, e.g. with gauge_simple_temp, the method gate_simple_ would be a template. Along the string one could use tensor_network_1d_compress and any of the methods it supports.

[benjaminlanthier]

Just to make sure that my understanding is correct, what does the string represent ?

Let's say in the case of an operator that acts on sites (i,j) and (i+2,j+1) Does it correspond to the bonds that connect those two sites along a certain path (e.g.: ((i,j), (i,j+1), (i+1,j+1), (i+2,j+1))) ? If so, then gauging the bonds connecting this string to the environment would mean that all the sites in the PEPS are canonicalized in the direction of this string, correct ? Once this is done, the last step would be to apply the operator like it would be applied on an MPS -- using the tensor_network_1d_compress ?

Following this idea, in the case where the sites are all closest neighbours, would it be equivalent to call canonize_around on site (i,j) and then use tensor_network_1D_compress() along the string ?

[jcmgray]

The string is a sequence of sites connecting e.g. sitea and siteb for a two site operator. For a 1D or tree like network, there is only one choice of this string. But for a loopy TN there will be some arbitrary choice, but presumably one of the shortest paths, like the one you gave. quimb has functions for generating these already see e.g. get_path_between_tids.

Yes gauging could be done it various ways, but the key thing is the bonds connecting the string to the remaining environment, the simplest choice would be the 'tree-gauge': like calling canonize_around on the target string area. The simple update style gauges would be another simple choice.

One then would then yes apply the gate as a non-local MPO, compress along the string using tensor_network_1d_compress. This would handle gauging the string internally.

Finally, depending on the choice of gauge, one might have to 'undo' its effect.

[benjaminlanthier]

Excellent, thank you for this detailed answer!