quimb.tensor.tnag.tebd¶

Tools for performing TEBD like algorithms on arbitrary lattices.

Classes¶

`TrotterGate`	A single local gate within a Trotterized product formula, as generated
`LocalHamGen`	Representation of a local hamiltonian defined on a general graph. This
`TEBDSweepMixin`	Generic class for performing time evolving block decimation on an
`ComputeEnergyMixin`
`ComputeEnergyClusterMixin`	Mixin class to add basic cluster energy computation to TEBD like
`GateBasicMixin`
`GateSimpleUpdateMixin`	Mixin class to use simple update style gating, with separately
`TEBDGen`	Basic arbitrary geometry TEBD class, combining the basic gate
`SimpleUpdateGen`	Simple update for arbitrary geometry hamiltonians, storing gauges

Functions¶

`edge_coloring`(edges[, strategy, interchange, group])	Generate an edge coloring for the graph given by `edges`, using
`trotter_schedule`(nlayers[, order])	Get the sequence of layer applications making up a single Trotter step

Module Contents¶

quimb.tensor.tnag.tebd.edge_coloring(edges, strategy='smallest_last', interchange=True, group=True)[source]¶

Generate an edge coloring for the graph given by edges, using networkx.coloring.greedy_color.

Parameters:

edges (sequence[tuple[hashable, hashable]]) – The edges of the graph.
strategy (str or callable, optional) –
The strategy to use for coloring the edges. Can be:
- ’largest_first’
- ’smallest_last’
- ’random_sequential’
…
interchange (bool, optional) – Whether to use the interchange heuristic. Usually generates better colorings but can be slower.
group (bool, optional) – Whether to group the edges by color or return a flat list.

quimb.tensor.tnag.tebd.trotter_schedule(nlayers, order=2)[source]¶

Get the sequence of layer applications making up a single Trotter step of a product formula of the given order, for a hamiltonian split into nlayers groups of commuting terms.

Parameters:

nlayers (int) – The number of commuting layers the hamiltonian is split into.
order ({2, 1, 4}, optional) – The order of the product formula. Order 1 applies each layer once, order 2 is the symmetric (palindromic) formula, and order 4 the standard Suzuki recursion built from five order 2 steps.

Returns:

Pairs of layer index and the fraction of the overall exponent to apply that layer with, in the order they should be applied.

Return type:

list[tuple[int, float]]

Examples

>>> trotter_schedule(2, order=2)
[(0, 0.5), (1, 1.0), (0, 0.5)]

class quimb.tensor.tnag.tebd.TrotterGate(U, where, frac, layer, step)[source]¶

A single local gate within a Trotterized product formula, as generated by LocalHamGen.get_trotter_gates(). It unpacks as the pair U, where, matching the argument order of the gate application methods, so that for U, where in gates: psi.gate_(U, where) works. The remaining information is available as attributes.

U¶

The gate itself, expm(frac * x * H_where).

Type:: array

where¶

The sites the gate acts on.

Type:: tuple[node]

frac¶

The fraction of the overall exponent x this gate applies.

Type:: float

layer¶

Which layer of the sequence this gate belongs to. Gates sharing a layer act on disjoint sites and commute.

Type:: int

step¶

Which Trotter step this gate belongs to. A gate fused across a step boundary is labelled with the earlier step.

Type:: int

__slots__ = ('U', 'frac', 'layer', 'step', 'where')¶

U¶

where¶

frac¶

layer¶

step¶

__iter__()[source]¶

__repr__()[source]¶

class quimb.tensor.tnag.tebd.LocalHamGen(H2, H1=None)[source]¶

Representation of a local hamiltonian defined on a general graph. This combines all two site and one site terms into a single interaction per lattice pair, and caches operations on the terms such as getting their exponential. The sites (nodes) should be hashable and comparable.

Parameters:

H2 (dict[tuple[node], array_like]) – The interaction terms, with each key being an tuple of nodes defining an edge and each value the local hamilotonian term for those two nodes.
H1 (array_like or dict[node, array_like], optional) – The one site term(s). If a single array is given, assume to be the default onsite term for all terms. If a dict is supplied, the keys should represent specific coordinates like (i, j) with the values the array representing the local term for that site. A default term for all remaining sites can still be supplied with the key None.

terms¶

The total effective local term for each interaction (with single site terms appropriately absorbed). Each key is a pair of coordinates site_a, site_b with site_a < site_b.

Type:: dict[tuple, array_like]

_op_cache¶

terms¶

sites¶

_sites_to_covering_terms¶

property nsites¶: The number of sites in the system.

keys()[source]¶: Iterate over all terms in the hamiltonian. This is mostly for convenient compatibility with compute_local_expectation.

values()[source]¶: Iterate over all terms in the hamiltonian. This is mostly for convenient compatibility with compute_local_expectation.

items()[source]¶: Iterate over all terms in the hamiltonian. This is mostly for convenient compatibility with compute_local_expectation.

__iter__()[source]¶: Iterate over all terms in the hamiltonian. This is mostly for convenient compatibility with compute_local_expectation.

_convert_from_qarray_cached(x)[source]¶

_flip_cached(x)[source]¶

_add_cached(x, y)[source]¶

_div_cached(x, y)[source]¶

_op_id_cached(x)[source]¶

_id_op_cached(x)[source]¶

_expm_cached(G, x)[source]¶

get_gate(where)[source]¶: Get the local term for pair where, cached.

get_gate_expm(where, x)[source]¶: Get the local term for pair where, matrix exponentiated by x, and cached.

apply_to_arrays(fn)[source]¶: Apply the function fn to all the arrays representing terms.

get_auto_ordering(order='sort', group=False, **kwargs)[source]¶

Get an ordering of the terms to use with TEBD, for example. The default is to sort the coordinates then greedily group them into commuting sets.

Parameters:

order ({'sort', None, 'random', str}) –
How to order the terms before greedily grouping them into commuting (non-coordinate overlapping) sets:
- 'sort' will sort the coordinate pairs first.
- None will use the current order of terms which should match the order they were supplied to this LocalHam2D instance.
- 'random' will randomly shuffle the coordinate pairs before grouping them - not the same as returning a completely random order.
- 'random-ungrouped' will randomly shuffle the coordinate pairs but not group them at all with respect to commutation. With group=True the shuffled pairs are aggregated only with commuting neighbors.
Any other option will be passed as a strategy to networkx.coloring.greedy_color() to generate the ordering.
group (bool, optional) – If True, return a list of commuting layers (tuples of pairs), otherwise return a flat list of pairs.

Returns:

Sequence of coordinate pairs, or of layers of pairs if group.

Return type:

list[tuple[node]] or list[tuple[tuple[node]]]

get_trotter_gates(x, order=2, steps=1, ordering='sort', fuse_adjacent=True, alternate=True)[source]¶

Get the sequence of local gates for a Trotter approximation to \(\exp(x H)\) of the given order, repeated steps times. The terms are grouped into layers of commuting (non site overlapping) gates, then each layer is exponentiated for the fraction of x the product formula calls for.

Parameters:

x (float or complex) – The overall exponent, such that the sequence approximates expm(x * H). Note this does not include the imaginary prefactor of the Schrodinger equation, so real x corresponds to imaginary time evolution, and x = -1j * t to real time.
order ({2, 1, 4}, optional) – The order of the product formula. Order 1 applies each layer once per step, order 2 is the symmetric (palindromic) formula, and order 4 the standard Suzuki recursion built from five order 2 steps.
steps (int, optional) – How many Trotter steps to generate, each of exponent x. Note the total exponent is thus steps * x.
ordering (str, None or sequence[sequence[tuple[node]]], optional) – How to group the terms into commuting layers. A string or None is passed to get_auto_ordering(), else an explicit sequence of layers of pairs can be given.
fuse_adjacent (bool, optional) – Whether to merge consecutive applications of the same layer into a single gate. For order 2 this means the half layers appear only at the very start and end of the whole sequence, rather than at every step boundary. The merged gate is taken directly from the cached local exponential at the summed fraction, not by multiplying the two separate gates.
alternate (bool, optional) – Whether to flip the direction the pairs within each layer are iterated over, every other layer. Gates within a layer commute so this changes nothing numerically, but it keeps, for example, an MPS canonical center sweeping back and forth rather than jumping back each layer.

Returns:

Each gate unpacks as the pair U, where, with frac, layer and step available as attributes.

Return type:

tuple[TrotterGate]

Examples

Real time evolve an MPS by t = 1.0 in 100 steps:

>>> import quimb as qu
>>> import quimb.tensor as qtn
>>> H = qtn.LocalHam1D(L=16, H2=qu.ham_heis(2))
>>> psi = qtn.MPS_neel_state(16, dtype=complex)
>>> for U, where in H.get_trotter_gates(-1j * 0.01, steps=100):
...     psi.gate_split_(U, where, cutoff=1e-8)