TeNPy layer-based backend (qiskit_addon_mpf.backends.tenpy_layers)

A layer-wise time-evolution backend using tenpy.

Caution

The optional dependency TeNPy was previously offered under a GPLv3 license. As of the release of v1.0.4 on October 2nd, 2024, it has been offered under the Apache v2 license. The license of this package is only compatible with Apache-licensed versions of TeNPy.

Warning

This backend is only available if the optional dependencies have been installed:

pip install "qiskit-addon-mpf[tenpy]"

LayerwiseEvolver	A special case of the TEBDEvolver based on layer-wise evolution models.
LayerModel	A model for representing a layer of time-evolution interactions.

Underlying method

This module provides a time-evolution backend similar to the TEBD-based one provided by the tenpy_tebd module. The main difference is that this module gives the user full flexibility for defining their product formulas, thereby not limiting them to the options built into the tenpy library.

At its core, the algorithm provided by this module is still a TEBD [1] algorithm. However, rather than enforcing the alternating updates to the even and odd bonds of the time-evolution state (see also evolve_step()) this implementation outsources the responsibility of updating bonds in alternating fashion to the definition of multiple time-evolution layers.

This is best explained with an example. Let us assume, we have some generic Hamiltonian acting on a 1-dimensional chain of sites.

Hint

Below we are very deliberate about the order of the Hamiltonian’s Pauli terms because this directly impacts the structure of the time-evolution circuit later on.

>>> from qiskit.quantum_info import SparsePauliOp
>>> hamil = SparsePauliOp.from_sparse_list(
...     [("ZZ", (i, i+1), 1.0) for i in range(1, 9, 2)] +
...     [("Z", (i,), 0.5) for i in range(10)] +
...     [("ZZ", (i, i+1), 1.0) for i in range(0, 9, 2)],
...     num_qubits=10,
... )

Let us now inspect the time-evolution circuit of this Hamiltonian using a second-order Suzuki-Trotter formula.

>>> from qiskit.synthesis import SuzukiTrotter
>>> from qiskit_addon_utils.problem_generators import generate_time_evolution_circuit
>>> circuit = generate_time_evolution_circuit(hamil, time=1.0, synthesis=SuzukiTrotter(order=2))
>>> circuit.draw("mpl")  
<Figure size 956...x869... with 1 Axes>

(png, hires.png, pdf)

In the circuit above, we can clearly identify its layer-wise structure. We can emphasize this further, by splitting the circuit into multiple layers as shown below (we recombine the layers into a single circuit with barriers between them to ease the visualization).

>>> from qiskit_addon_utils.slicing import combine_slices, slice_by_gate_types
>>> layers = slice_by_gate_types(circuit)
>>> combine_slices(layers, include_barriers=True).draw("mpl")  
<Figure size 1374...x869... with 1 Axes>

(png, hires.png, pdf)

Hint

The asymmetry of the central layers is a result of the implementation of Qiskit’s SuzukiTrotter formula. In its second-order form, it combines the two half-time evolutions of the final term in the Hamiltonian into a single one of twice the length. We could transpile this circuit to collapse all such subequent gates in the central two layers (just like the last one), but for the sake of simplicity of this example, we will not do that here.

It is not possible to instruct TeNPy’s TEBD algorithm to simulate the exact structure of the circuit shown above. The reason for that is a limitation in its interface, as it only accepts the full Hamiltonian to be provided which is then time-evolved using pre-defined Trotter formulas. However, in doing so it does not treat the order of the Pauli terms in a Hamiltonian with any significance (like we do here).

If one wants to compute the dynamic MPF coefficients of a time-evolution employing a product formula structure other than the ones implemented in TeNPy (like the example above), then one can use the time-evolution algorithm provided by this module. Rather than taking a single monolithic Hamiltonian whose time-evolution is to be modeled, the LayerwiseEvolver accepts a list of LayerModel objects, each one describing an individual layer of the product formula. This gives the user full flexibility in defining the Trotter decomposition down to the most granular level.

However, caution must be applied to ensure that the property of TEBD to update even and odd bonds in an alternating manner is still guaranteed. Luckily, for quantum circuits consisting of at most two-qubit gates, this property is satisfied by construction.

Code example

In this section, we build up on the example above and show how to take a custom Trotter formula and use it to construct a LayerwiseEvolver which can be used to replace the tenpy_tebd.TEBDEvolver in the workflow described in tenpy_tebd.

Hint

The overall workflow of using this module is the same as of the tenpy_tebd module, so be sure to read those instructions as well.

Simply put, we must convert each one of the circuit layers (see above) into a LayerModel instance. For this purpose, we can use its from_quantum_circuit() method.

>>> from qiskit_addon_mpf.backends.tenpy_layers import LayerModel
>>> model0 = LayerModel.from_quantum_circuit(layers[0])
>>> layer_models = [model0]

In the code above you can see how simple the conversion is for layers which contain only two-qubit gates acting on mutually exclusive qubits (which layers of depth 1 guarantee).

However, we must be more careful with layers including single-qubit gates. The reason for that is that the TEBD algorithm underlying the LayerwiseEvolver must update even and odd bonds in an alternating manner. And because single-qubit gates are not applied on a site, but instead are split in half and applied to the bonds on either side, a layer of single-qubit gates acting on all qubits would break this assumption.

To circumvent this problem, we can take any layer consisting of only single-qubit gates, and apply it twice (once on the even and once on the odd bonds) while scaling each one with a factor of 0.5.

>>> model1a = LayerModel.from_quantum_circuit(layers[1], keep_only_odd=True, scaling_factor=0.5)
>>> model1b = LayerModel.from_quantum_circuit(layers[1], keep_only_odd=False, scaling_factor=0.5)
>>> layer_models.extend([model1a, model1b])

Now that we know how to treat layers consisting of two-qubit and single-qubit gates, we can transform the remaining layers.

>>> for layer in layers[2:]:
...     num_qubits = len(layer.data[0].qubits)
...     if num_qubits == 2:
...         layer_models.append(LayerModel.from_quantum_circuit(layer))
...     else:
...         layer_models.append(
...             LayerModel.from_quantum_circuit(layer, keep_only_odd=True, scaling_factor=0.5)
...         )
...         layer_models.append(
...             LayerModel.from_quantum_circuit(layer, keep_only_odd=False, scaling_factor=0.5)
...         )
>>> assert len(layer_models) == 8

In the end, we have 8 LayerModel’s, one for each of the 4 two-qubit layers, and two for each of the 2 single-qubit layers.

Finally, we can define our ApproxEvolverFactory protocol to be used within the setup_dynamic_lse() function.

>>> from functools import partial
>>> from qiskit_addon_mpf.backends.tenpy_layers import LayerwiseEvolver
>>> approx_evolver_factory = partial(
...     LayerwiseEvolver,
...     layers=layer_models,
...     options={
...         "preserve_norm": False,
...         "trunc_params": {
...             "chi_max": 10,
...             "svd_min": 1e-5,
...             "trunc_cut": None,
...         },
...     },
... )

Caution

It should be noted, that in this workflow we have not yet fixed the time step used by the Trotter formula. We have also only set up a single repetition of the Trotter formula as the rest will be done by the internal DynamicMPF algorithm, executed during setup_dynamic_lse().

Of course, you could also use this to specify a ExactEvolverFactory. But you can also mix-and-match a tenpy_layers.LayerwiseEvolver with a tenpy_tebd.TEBDEvolver.

Resources

[1]: https://en.wikipedia.org/wiki/Time-evolving_block_decimation