quimb.tensor.circuit.peps¶

PEPS simple-update circuit simulator.

Classes¶

CircuitPEPSSimpleUpdate

Quantum circuit simulation keeping the state as a generic tensor

Module Contents¶

class quimb.tensor.circuit.peps.CircuitPEPSSimpleUpdate(N=None, *, edges=None, gates=None, psi0=None, max_bond=None, cutoff=1e-10, renorm=False, gauge_smudge=1e-12, equilibrate_every=None, equilibrate_opts=None, gate_opts=None, dtype=None, to_backend=None, convert_eager=True, **circuit_opts)[source]¶

Bases: quimb.tensor.circuit.simple_update.CircuitSimpleUpdate

Quantum circuit simulation keeping the state as a generic tensor network (a “PEPS” defined by an arbitrary graph of edges) and applying gates with the simple update rule. The state always keeps a single tensor per site, with bonds only along the supplied edges; two-qubit gates are only supported on those edges. Bond singular values are tracked as Vidal-style gauges, which makes gate application and the computation of local expectations cheap and approximate.

This is useful for circuits on lattices that build up more than 1D worth of entanglement, where an exact or MPS simulation is intractable but a truncated, gauged tensor network state is a good approximation.

Parameters:

N (int, optional) – The number of qubits in the circuit. If not given it is inferred from the geometry. Supply it to pad the geometry up to N sites, including any that have no edges.
edges (sequence[tuple[int, int]], optional) – The edges defining the geometry of the PEPS. A bond is placed between each pair of sites, and two-qubit gates are only supported on these edges. Every site appearing in edges is included. If not given the geometry is taken from gates or psi0 instead.
gates (sequence, optional) – If edges is not given, infer the geometry from the two-qubit gates in this sequence. The gates are only inspected here, not applied, so you still pass them to apply_gates() afterwards.
psi0 (TensorNetworkGenVector, optional) – Supply the initial state directly instead of starting from the |00...0> product state. If edges is not given the geometry is read from the bonds of this state, and the bond gauges are seeded from it. Only a single seeding sweep is performed; unlike imaginary time simple update the gauge matters immediately, so for an arbitrary psi0 you may want to call equilibrate() once before applying gates.
max_bond (int, optional) – The maximum bond dimension to truncate to when applying gates.
cutoff (float, optional) – The singular value cutoff to use when truncating after applying gates.
renorm (bool, optional) – Whether to renormalize the singular values of a bond after each gate. The default False tracks the norm of the state rather than forcing it to one, which is the sensible choice for real time and general circuit dynamics. Set True to instead keep the state normalized after every gate, e.g. for the near-identity gates of imaginary time evolution.
gauge_smudge (float, optional) – Small value added to the gauges before they are multiplied in and inverted, for numerical stability with very small singular values.
equilibrate_every (int, optional) – If given, automatically call equilibrate() after every this many gates have been applied.
equilibrate_opts (dict, optional) – Default options forwarded to equilibrate().
gate_opts (dict, optional) – Default options to pass to gate_simple_ such as max_bond and cutoff.
dtype (str, optional) – If given, ensure the state tensors are cast to this data type.
to_backend (callable, optional) – If given, apply this function to the state tensors to convert them to a particular array backend.
convert_eager (bool, optional) – Whether to apply the dtype and to_backend conversions eagerly as each gate is applied. The default True matches the other running simulators (e.g. CircuitMPS), since the simple update rule contracts each gate into the state immediately rather than building a lazy network to contract later.

edges¶

The unique edges defining the PEPS geometry.

Type:: tuple[tuple[hashable, hashable]]

sites¶

The sites (qubit labels) of the PEPS.

Type:: tuple[hashable]

gauges¶

The current Vidal-style bond gauges (singular values), keyed by bond index, updated in place as gates are applied.

Type:: dict[str, array]

Notes

The gates applied must address qubits using the same labels that appear in edges. Two-qubit gates are only supported along an existing edge.

Examples

>>> import quimb.tensor as qtn
>>> edges = [(0, 1), (1, 2), (0, 3), (1, 4), (2, 5), (3, 4), (4, 5)]
>>> circ = qtn.CircuitPEPSSimpleUpdate(edges=edges, max_bond=8)
>>> circ.apply_gates(gates)
>>> peps = circ.psi