MPOEnvironment¶

full name: tenpy.networks.mpo.MPOEnvironment
parent module: tenpy.networks.mpo
type: class

Inheritance Diagram

Methods

`MPOEnvironment.__init__`(bra, H, ket[, cache])
`MPOEnvironment.cache_optimize`([...])	Update short_term_keys for the cache and possibly preload tensors.
`MPOEnvironment.clear`()	Delete all partial contractions except the left-most LP and right-most RP.
`MPOEnvironment.del_LP`(i)	Delete stored part strictly to the left of site i.
`MPOEnvironment.del_RP`(i)	Delete stored part scrictly to the right of site i.
`MPOEnvironment.expectation_value_terms_sum`(...)	Calculate expectation values for a bunch of terms and sum them up.
`MPOEnvironment.full_contraction`(i0)	Calculate the energy by a full contraction of the network.
`MPOEnvironment.get_LP`(i[, store])	Calculate LP at given site from nearest available one (including i).
`MPOEnvironment.get_LP_age`(i)	Return number of physical sites in the contractions of get_LP(i).
`MPOEnvironment.get_RP`(i[, store])	Calculate RP at given site from nearest available one (including i).
`MPOEnvironment.get_RP_age`(i)	Return number of physical sites in the contractions of get_RP(i).
`MPOEnvironment.get_initialization_data`([...])	Return data for (re-)initialization of the environment.
`MPOEnvironment.has_LP`(i)	Return True if LP left of site i is stored.
`MPOEnvironment.has_RP`(i)	Return True if RP right of site i is stored.
`MPOEnvironment.init_LP`(i[, start_env_sites])	Build an initial left part `LP`.
`MPOEnvironment.init_RP`(i[, start_env_sites])	Build initial right part `RP` for an MPS/MPOEnvironment.
`MPOEnvironment.init_first_LP_last_RP`([...])	(Re)initialize first LP and last RP from the given data.
`MPOEnvironment.set_LP`(i, LP, age)	Store part to the left of site i.
`MPOEnvironment.set_RP`(i, RP, age)	Store part to the right of site i.
`MPOEnvironment.test_sanity`()	Sanity check, raises ValueErrors, if something is wrong.

class tenpy.networks.mpo.MPOEnvironment(bra, H, ket, cache=None, **init_env_data)[source]¶

Bases: BaseEnvironment

Stores partial contractions of $<bra|H|ket>$ for an MPO H.

The network for a contraction $<bra|H|ket>$ of an MPO H between two MPS looks like:

|     .------>-M[0]-->-M[1]-->-M[2]-->- ...  ->--.
|     |        |       |       |                 |
|     |        ^       ^       ^                 |
|     |        |       |       |                 |
|     LP[0] ->-W[0]-->-W[1]-->-W[2]-->- ...  ->- RP[-1]
|     |        |       |       |                 |
|     |        ^       ^       ^                 |
|     |        |       |       |                 |
|     .------<-N[0]*-<-N[1]*-<-N[2]*-<- ...  -<--.

We use the following label convention (where arrows indicate qconj):

|    .-->- vR           vL ->-.
|    |                        |
|    LP->- wR           wL ->-RP
|    |                        |
|    .--<- vR*         vL* -<-.

See BaseEnvironment for further details.

Parameters

bra (MPS) – The MPS to project on. Should be given in usual ‘ket’ form; we call conj() on the matrices directly.
H (MPO) – The MPO sandwiched between bra and ket. Should have ‘IdL’ and ‘IdR’ set on the first and last bond.
ket (MPS) – The MPS on which H acts. May be identical with bra.
**init_env_data – Further keyword arguments with initialization data, as returned by get_initialization_data(). See initialize_first_LP_last_RP() for details on these parameters.

H¶

The MPO sandwiched between bra and ket.

Type: MPO

init_first_LP_last_RP(init_LP=None, init_RP=None, age_LP=0, age_RP=0, start_env_sites=None)[source]¶

(Re)initialize first LP and last RP from the given data.

If init_LP and init_RP are not given, we try to find sensible initial values. Dummy environments can by built with init_LP() and init_RP(), especially for finite MPS.

For infinite MPS, we try to converge the environments with one of two methods:

If start_env_sites is given as an integer, contract that many sites into the environment from the given init_LP and init_RP or new trivial environments built with init_LP() / init_RP().
If start_env_sites is None, and bra is ket, get init_LP and init_RP with MPOTransferMatrix.find_init_LP_RP().

Parameters

init_LP (None | Array) – Initial very left part LP and very right part RP. If None, try to build (and converge) them as described above.
init_RP (None | Array) – Initial very left part LP and very right part RP. If None, try to build (and converge) them as described above.
age_LP (int) – The number of physical sites involved into the contraction of init_LP and init_RP.
age_RP (int) – The number of physical sites involved into the contraction of init_LP and init_RP.
start_env_sites (int | None) – Number of sites over which to converge the environment for infinite systems. See above.

test_sanity()[source]¶: Sanity check, raises ValueErrors, if something is wrong.

init_LP(i, start_env_sites=0)[source]¶

Build an initial left part LP.

For start_env_sites > 0, make the assumptions that bra is the same as ket and in canonical form, and that H is a Hamiltonian with the following block-form (up to a permutation of MPO indices; this is the case for any model defined in TeNPy),

\[\begin{split}W = \begin{pmatrix} 1 & C & D \\ 0 & A & B \\ 0 & 0 & 1 \end{pmatrix}\end{split}\]

Given that, we can converge the environment even in the thermodynamic limit: LP[IdL, :, :] just contains the energy for the left part of the Hamiltonian, contributing just a constant we can ignore (since we only look at relative energies) LP[IdR, :, :] = eye(:, :) is just the MPS environment. The remaining part is the harder one: we need to converge $C + CA + CAA + CAAA + … $ sandwiched between the MPS. However, H often has finite range, which makes A nil-potent, such that we only need to contract the environment a few times from the left.

Todo

Right now, for infinite/long range it just limits the number of iterations. In general, we could calculate the exact $X = C + CA + CAA +…$ with the geometric series by solving the set of linear equation $ X(1-A) = C$ for X, (and analogously $(1-A)X = B$ for the right environment RP).

Parameters

i (int) – Build LP left of site i.
start_env_sites (int) – How many sites to contract to converge the init_LP; the initial age_LP.

Returns

init_LP – Environment left of site i with labels 'vR*', 'wR', 'vR'.

Return type

Array

init_RP(i, start_env_sites=0)[source]¶

Build initial right part RP for an MPS/MPOEnvironment.

Parameters

i (int) – Build RP right of site i.
start_env_sites (int) – How many sites to contract to converge the init_RP; the initial age_RP.

Returns

init_RP – Environment right of site i with labels 'vL*', 'wL', 'vL'.

Return type

Array

get_LP(i, store=True)[source]¶

Calculate LP at given site from nearest available one (including i).

The returned LP_i corresponds to the following contraction, where the M’s and the N’s are in the ‘A’ form:

|     .-------M[0]--- ... --M[i-1]--->-   'vR'
|     |       |             |
|     LP[0]---W[0]--- ... --W[i-1]--->-   'wR'
|     |       |             |
|     .-------N[0]*-- ... --N[i-1]*--<-   'vR*'

Parameters

i (int) – The returned LP will contain the contraction strictly left of site i.
store (bool) – Whether to store the calculated LP in self (True) or discard them (False).

Returns

LP_i – Contraction of everything left of site i, with labels 'vR*', 'wR', 'vR' for bra, H, ket.

Return type

Array

get_RP(i, store=True)[source]¶

Calculate RP at given site from nearest available one (including i).

The returned RP_i corresponds to the following contraction, where the M’s and the N’s are in the ‘B’ form:

|     'vL'  ->---M[i+1]-- ... --M[L-1]----.
|                |              |         |
|     'wL'  ->---W[i+1]-- ... --W[L-1]----RP[-1]
|                |              |         |
|     'vL*' -<---N[i+1]*- ... --N[L-1]*---.

Parameters

i (int) – The returned RP will contain the contraction strictly rigth of site i.
store (bool) – Whether to store the calculated RP in self (True) or discard them (False).

Returns

RP_i – Contraction of everything right of site i, with labels 'vL*', 'wL', 'vL' for bra, H, ket.

Return type

Array

full_contraction(i0)[source]¶

Calculate the energy by a full contraction of the network.

The full contraction of the environments gives the value <bra|H|ket> `` ignoring the :attr:`~tenpy.networks.mps.MPS.norm` of the `bra` and `ket`, i.e. the total energy (even if bra and ket are not normalized). For this purpose, this function contracts ``get_LP(i0+1, store=False) and get_RP(i0, store=False) with appropriate singular values in between.

Parameters: i0 (int) – Site index.

cache_optimize(short_term_LP=[], short_term_RP=[], preload_LP=None, preload_RP=None)[source]¶

Update short_term_keys for the cache and possibly preload tensors.

Parameters

short_term_LP (list of int) – i indices for get_LP() and get_RP(), respectively, for which a repeated look-up could happen, i.e., for which tensors should be kept in RAM until the next call to this function.
short_term_RP (list of int) – i indices for get_LP() and get_RP(), respectively, for which a repeated look-up could happen, i.e., for which tensors should be kept in RAM until the next call to this function.
preload_LP (int | None) – If not None, preload the tensors for the corrsponding get_LP() and get_RP() call, respectively, from disk.
preload_RP (int | None) – If not None, preload the tensors for the corrsponding get_LP() and get_RP() call, respectively, from disk.

clear()[source]¶: Delete all partial contractions except the left-most LP and right-most RP.

del_LP(i)[source]¶: Delete stored part strictly to the left of site i.

del_RP(i)[source]¶: Delete stored part scrictly to the right of site i.

expectation_value_terms_sum(term_list)[source]¶

Calculate expectation values for a bunch of terms and sum them up.

This is equivalent to the following expression:

sum([self.expectation_value_term(term)*strength for term, strength in term_list])

However, for effiency, the term_list is converted to an MPO and the expectation value of the MPO is evaluated.

Warning

This function works only for finite bra and ket and does not include normalization factors.

Parameters

term_list (TermList) – The terms and prefactors (strength) to be summed up.

Returns

terms_sum (list of (complex) float) – Equivalent to the expression sum([self.expectation_value_term(term)*strength for term, strength in term_list]).
_mpo – Intermediate results: the generated MPO. For a finite MPS, terms_sum = _mpo.expectation_value(self), for an infinite MPS terms_sum = _mpo.expectation_value(self) * self.L