BaseEnvironment

full name: tenpy.networks.mps.BaseEnvironment
parent module: tenpy.networks.mps
type: class

Inheritance Diagram

Methods

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

Class Attributes and Properties

`BaseEnvironment.L`	Number of physical sites; for an iMPS the len of the MPS unit cell.
`BaseEnvironment.N_sites_per_hor_spacing`	Number of sites per horizontal lattice spacing.
`BaseEnvironment.dim`	List of local physical dimensions.
`BaseEnvironment.finite`	Distinguish MPS vs iMPS.
`BaseEnvironment.nontrivial_bonds`	Slice of the non-trivial bond indices, depending on `self.bc`.

class tenpy.networks.mps.BaseEnvironment(bra, ket, cache=None, **init_env_data)[source]

Bases: MPSGeometry

Base class for MPSEnvironment storing partial contractions between MPS.

When bra and ket are the same, a suitable canonical form simplifies LP and RP tensors to identities, but for different bra and ket, or if we sandwich a whole MPO between the bra and ket (even if they are the same), the partial contractions are non-trivial.

This class stores the partial contractions up to each bond.

The MPS bra and ket have to be in canonical form. All the environments are constructed without the singular values on the open bond. In other words, we contract left-canonical A to the left parts LP and right-canonical B to the right parts RP. Thus, the special case ket=bra should yield identity matrices for LP and RP.

Parameters:

bra (MPS) – The MPS to project on. Should be given in usual ‘ket’ form; we call conj() on the matrices directly. Stored in place, without making copies. If necessary to match charges, we call gauge_total_charge().
ket (MPO | None) – The MPS on which the local operator acts. Stored in place, without making copies. If None, use bra.
cache (DictCache | None) – Cache in which the tensors should be saved. If None, a new DictCache is generated.
**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.

bra, ket

The two MPS for the contraction.

Type:: MPS

dtype

The data type.

Type:: type

cache

Cache for saving the environment tensors.

Type:: DictCache

_LP_keys, _RP_keys

Map indices to keys for the cache.

Type:: list of str

_LP

Left parts of the environment, len L. LP[i] contains the contraction strictly left of site i (or None, if we don’t have it calculated).

Type:: list of {None | }

_RP

Right parts of the environment, len L. RP[i] contains the contraction strictly right of site i (or None, if we don’t have it calculated).

Type:: list of {None | Array}

_LP_age

Used for book-keeping, how large the DMRG system grew: _LP_age[i] stores the number of physical sites involved into the contraction network which yields self.get_LP(i).

Type:: list of int | None

_RP_age

Used for book-keeping, how large the DMRG system grew: _RP_age[i] stores the number of physical sites involved into the contraction network which yields self._RP[i].

Type:: list of int | None

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

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

Parameters:

init_LP (None | Array) – Initial very left part LP. If None, build one with init_LP().
init_RP (None | Array) – Initial very right part RP. If None, build one with init_RP().
age_LP (int) – The number of physical sites involved into the contraction of init_LP.
age_RP (int) – The number of physical sites involved into the contraction of init_RP.
start_env_sites (int) – If init_LP and init_RP are not specified, contract each start_env_sites for them.

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

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

Build initial left part LP.

If bra and ket are the same and in left canonical form, this is the environment you get contracting the overlaps from the left infinity up to bond left of site i.

For segment MPS, the segment_boundaries are read out (if set).

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 – Identity contractible with the vL leg of ket.get_B(i), labels 'vR*', 'vR'.

Return type:

Array

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

Build initial right part RP for an MPS/MPOEnvironment.

If bra and ket are the same and in right canonical form, this is the environment you get contracting from the right infinity up to bond right of site i.

For segment MPS, the segment_boundaries are read out (if set).

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 – Identity contractible with the vR leg of ket.get_B(i), labels 'vL*', 'vL'.

Return type:

Array

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

Calculate LP at given site from nearest available one.

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]   |             |
|     |       |             |
|     .-------N[0]*-- ... --N[i-1]*--<-   'vR*'

Takes care of shifting as described in Dipole Conservation.

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*', 'vR' for bra, ket.

Return type:

Array

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

Calculate RP at given site from nearest available one.

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]----.
|                |              |         |
|                |              |         RP[L-1]
|                |              |         |
|     'vL*' -<---N[i+1]*- ... --N[L-1]*---.

Takes care of shifting as described in Dipole Conservation.

Parameters:

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

Returns:

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

Return type:

Array

get_LP_age(i)[source]

Return number of physical sites in the contractions of get_LP(i).

Might be None.

get_RP_age(i)[source]

Return number of physical sites in the contractions of get_RP(i).

Might be None.

set_LP(i, LP, age)[source]

Store part to the left of site i. No copy is made!

Takes care of shifting as described in Dipole Conservation.

set_RP(i, RP, age)[source]

Store part to the right of site i. No copy is made!

Takes care of shifting as described in Dipole Conservation.

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

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

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

has_LP(i)[source]: Return True if LP left of site i is stored.

has_RP(i)[source]: Return True if RP right of site i is stored.

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 corresponding get_LP() and get_RP() call, respectively, from disk.
preload_RP (int | None) – If not None, preload the tensors for the corresponding get_LP() and get_RP() call, respectively, from disk.

get_initialization_data(first=0, last=None, include_bra=False, include_ket=False)[source]

Return data for (re-)initialization of the environment.

Parameters:

first (int) – The first and last site, to the left and right of which we should return the environments. Defaults to 0 and L - 1.
last (int) – The first and last site, to the left and right of which we should return the environments. Defaults to 0 and L - 1.
include_bra (bool) – Whether to also return the bra and ket, respectively.
include_ket (bool) – Whether to also return the bra and ket, respectively.

Returns:

init_env_data – A dictionary with the following entries.

init_LP, init_RPArray: LP on the left of site first and RP on the right of site last, which can be used as init_LP and init_RP for the initialization of a new environment.
age_LP, age_RPint: The number of physical sites involved into the contraction yielding init_LP and init_RP, respectively.
bra, ketMPS: References of bra and ket. Only included if include_bra and include_ket are True, respectively.

Return type:

dict

abstractmethod full_contraction(i0)[source]

Calculate the overlap by a full contraction of the network.

This function contracts get_LP(i0+1, store=False) and get_RP(i0, store=False) with appropriate singular values in between.

Conventions for MPSEnvironment and MPOEnvironment are slightly different: the MPSEnvironment multiplies with taking into account MPS.norm of both bra and ket, the MPOEnvironment not.

Parameters:: i0 (int) – Site index.

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 efficiency, 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 ((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