# quimb.tensor.tensor_3d_tebd¶

Tools for performing TEBD like algorithms on a 3D lattice.

## Classes¶

 `LocalHamGen` Representation of a local hamiltonian defined on a general graph. This `LocalHam3D` Representation of a local hamiltonian defined on a general graph. This

## Functions¶

 `gen_3d_bonds`(Lx, Ly, Lz[, steppers, coo_filter, cyclic]) Convenience function for tiling pairs of bond coordinates on a 3D

## Module Contents¶

quimb.tensor.tensor_3d_tebd.gen_3d_bonds(Lx, Ly, Lz, steppers=None, coo_filter=None, cyclic=False)[source]

Convenience function for tiling pairs of bond coordinates on a 3D lattice given a function like `lambda i, j, k: (i + 1, j + 1, k + 1)`.

Parameters:
• Lx (int) – The number of x-slices.

• Ly (int) – The number of y-slices.

• Lz (int) – The number of z-slices.

• steppers (callable or sequence of callable) – Function(s) that take args `(i, j, k)` and generate another coordinate, thus defining a bond. Only valid steps are taken. If not given, defaults to nearest neighbor bonds.

• coo_filter (callable) – Function that takes args `(i, j, k)` and only returns `True` if this is to be a valid starting coordinate.

Yields:

bond (tuple[tuple[int, int, int], tuple[int, int, int]]) – A pair of coordinates.

Examples

Generate nearest neighbor bonds:

```>>> for bond in gen_3d_bonds(2, 2, 2, [lambda i, j, k: (i + 1, j, k),
...                                    lambda i, j, k: (i, j + 1, k),
...                                    lambda i, j, k: (i, j, k + 1)]):
...     print(bond)
((0, 0, 0), (1, 0, 0))
((0, 0, 0), (0, 1, 0))
((0, 0, 0), (0, 0, 1))
((0, 0, 1), (1, 0, 1))
((0, 0, 1), (0, 1, 1))
((0, 1, 0), (1, 1, 0))
((0, 1, 0), (0, 1, 1))
((0, 1, 1), (1, 1, 1))
((1, 0, 0), (1, 1, 0))
((1, 0, 0), (1, 0, 1))
((1, 0, 1), (1, 1, 1))
((1, 1, 0), (1, 1, 1))
```
class quimb.tensor.tensor_3d_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]

property nsites
The number of sites in the system.
items()[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]
_div_cached(x, y)[source]
_op_id_cached(x)[source]
_id_op_cached(x)[source]
_expm_cached(x, y)[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.

_nx_color_ordering(strategy='smallest_first', interchange=True)[source]

Generate a term ordering based on a coloring on the line graph.

get_auto_ordering(order='sort', **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.

Any other option will be passed as a strategy to `networkx.coloring.greedy_color` to generate the ordering.

Returns:

Sequence of coordinate pairs.

Return type:

list[tuple[node]]

__repr__()[source]

Return repr(self).

draw(ordering='sort', show_norm=True, figsize=None, fontsize=8, legend=True, ax=None, **kwargs)[source]

Plot this Hamiltonian as a network.

Parameters:
• ordering ({'sort', None, 'random'}, optional) – An ordering of the termns, or an argument to be supplied to `quimb.tensor.tensor_arbgeom_tebd.LocalHamGen.get_auto_ordering()` to generate this automatically.

• show_norm (bool, optional) – Show the norm of each term as edge labels.

• figsize (None or tuple[int], optional) – Size of the figure, defaults to size of Hamiltonian.

• fontsize (int, optional) – Font size for norm labels.

• legend (bool, optional) – Whether to show the legend of which terms are in which group.

• ax (None or matplotlib.Axes, optional) – Add to a existing set of axes.

graph[source]
class quimb.tensor.tensor_3d_tebd.LocalHam3D(Lx, Ly, Lz, H2, H1=None, cyclic=False)[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]

property nsites
The number of sites in the system.
__repr__()[source]

Return repr(self).