MPSEnvironment

• full name: tenpy.networks.mps.MPSEnvironment

• parent module: tenpy.networks.mps

• type: class

class tenpy.networks.mps.MPSEnvironment(bra, ket, init_LP=None, init_RP=None, age_LP=0, age_RP=0)

Bases: object

Stores partial contractions of \(<bra|Op|ket>\) for local operators Op.

The network for a contraction \(<bra|Op|ket>\) of a local operator Op, say exemplary at sites i, i+1 looks like:

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

Of course, we can also calculate the overlap <bra|ket> by using the special case Op = Id.

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

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

To avoid recalculations of the whole network e.g. in the DMRG sweeps, we store the contractions up to some site index in this class. For bc='finite','segment', the very left and right part LP[0] and RP[-1] are trivial and don’t change, but for bc='infinite' they are might be updated (by inserting another unit cell to the left/right).

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

braMPS

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().

ketMPO | None

The MPS on which the local operator acts. Stored in place, without making copies. If None, use bra.

init_LPNone | Array

Initial very left part LP. If None, build trivial one with init_LP().

init_RPNone | Array

Initial very right part RP. If None, build trivial one with init_RP().

age_LPint

The number of physical sites involved into the contraction yielding firstLP.

age_RPint

The number of physical sites involved into the contraction yielding lastRP.

Attributes

Lint

Number of physical sites involved into the Environment, i.e. the least common multiple of bra.L and ket.L.

bra, ketMPS

The two MPS for the contraction.

dtypetype

The data type.

_finitebool

Whether the boundary conditions of the MPS are finite.

_LPlist of {None | Array}

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).

_RPlist of {None | Array}

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).

_LP_agelist of int | None

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

_RP_agelist of int | None

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

Methods

del_LP(self, i)	Delete stored part strictly to the left of site i.
del_RP(self, i)	Delete storde part scrictly to the right of site i.
expectation_value(self, ops[, sites, axes])	Expectation value <bra|ops|ket> of (n-site) operator(s).
full_contraction(self, i0)	Calculate the overlap by a full contraction of the network.
get_LP(self, i[, store])	Calculate LP at given site from nearest available one (including i).
get_LP_age(self, i)	Return number of physical sites in the contractions of get_LP(i).
get_RP(self, i[, store])	Calculate RP at given site from nearest available one (including i).
get_RP_age(self, i)	Return number of physical sites in the contractions of get_RP(i).
init_LP(self, i)	Build initial left part LP.
init_RP(self, i)	Build initial right part RP for an MPS/MPOEnvironment.
set_LP(self, i, LP, age)	Store part to the left of site i.
set_RP(self, i, RP, age)	Store part to the right of site i.
test_sanity(self)	Sanity check, raises ValueErrors, if something is wrong.

test_sanity(self)

Sanity check, raises ValueErrors, if something is wrong.

init_LP(self, i)

Build initial left part LP.

Parameters

iint

Build LP left of site i.

Returns

init_LPArray

Identity contractible with the vL leg of ket.get_B(i), labels 'vR*', 'vR'.

init_RP(self, i)

Build initial right part RP for an MPS/MPOEnvironment.

Parameters

iint

Build RP right of site i.

Returns

init_RPArray

Identity contractible with the vR leg of ket.get_B(i), labels 'vL*', 'vL'.

get_LP(self, i, store=True)

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

Parameters

iint

The returned LP will contain the contraction strictly left of site i.

storebool

Wheter to store the calculated LP in self (True) or discard them (False).

Returns

LP_iArray

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

get_RP(self, i, store=True)

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

Parameters

iint

The returned RP will contain the contraction strictly right of site i.

storebool

Wheter to store the calculated RP in self (True) or discard them (False).

Returns

RP_iArray

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

get_LP_age(self, i)

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

Might be None.

get_RP_age(self, i)

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

Might be None.

set_LP(self, i, LP, age)

Store part to the left of site i.

set_RP(self, i, RP, age)

Store part to the right of site i.

del_LP(self, i)

Delete stored part strictly to the left of site i.

del_RP(self, i)

Delete storde part scrictly to the right of site i.

full_contraction(self, i0)

Calculate the overlap by a full contraction of the network.

The full contraction of the environments gives the overlap <bra|ket>, taking into account MPS.norm of both bra and ket. 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

i0int

Site index.

expectation_value(self, ops, sites=None, axes=None)

Expectation value <bra|ops|ket> of (n-site) operator(s).

Calculates n-site expectation values of operators sandwiched between bra and ket. For examples the contraction for a two-site operator on site i would look like:

|          .--S--B[i]--B[i+1]--.
|          |     |     |       |
|          |     |-----|       |
|          LP[i] | op  |       RP[i+1]
|          |     |-----|       |
|          |     |     |       |
|          .--S--B*[i]-B*[i+1]-.

Here, the B are taken from ket, the B* from bra. The call structure is the same as for MPS.expectation_value().

Parameters

ops(list of) { Array | str }

The operators, for wich the expectation value should be taken, All operators should all have the same number of legs (namely 2 n). If less than len(sites) operators are given, we repeat them periodically. Strings (like 'Id', 'Sz') are translated into single-site operators defined by sites.

siteslist

List of site indices. Expectation values are evaluated there. If None (default), the entire chain is taken (clipping for finite b.c.)

axesNone | (list of str, list of str)

Two lists of each n leg labels giving the physical legs of the operator used for contraction. The first n legs are contracted with conjugated B, the second n legs with the non-conjugated B. None defaults to (['p'], ['p*']) for single site (n=1), or (['p0', 'p1', ... 'p{n-1}'], ['p0*', 'p1*', .... 'p{n-1}*']) for n > 1.

Returns

exp_vals1D ndarray

Expectation values, exp_vals[i] = <bra|ops[i]|ket>, where ops[i] acts on site(s) j, j+1, ..., j+{n-1} with j=sites[i].

Examples

One site examples (n=1):

>>> env.expectation_value('Sz')
[Sz0, Sz1, ..., Sz{L-1}]
>>> env.expectation_value(['Sz', 'Sx'])
[Sz0, Sx1, Sz2, Sx3, ... ]
>>> env.expectation_value('Sz', sites=[0, 3, 4])
[Sz0, Sz3, Sz4]

Two site example (n=2), assuming homogeneous sites:

>>> SzSx = npc.outer(psi.sites[0].Sz.replace_labels(['p', 'p*'], ['p0', 'p0*']),
                     psi.sites[1].Sx.replace_labels(['p', 'p*'], ['p1', 'p1*']))
>>> env.expectation_value(SzSx)
[Sz0Sx1, Sz1Sx2, Sz2Sx3, ... ]   # with len L-1 for finite bc, or L for infinite

Example measuring <bra|SzSx|ket> on each second site, for inhomogeneous sites:

>>> SzSx_list = [npc.outer(psi.sites[i].Sz.replace_labels(['p', 'p*'], ['p0', 'p0*']),
                           psi.sites[i+1].Sx.replace_labels(['p', 'p*'], ['p1', 'p1*']))
                 for i in range(0, psi.L-1, 2)]
>>> env.expectation_value(SzSx_list, range(0, psi.L-1, 2))
[Sz0Sx1, Sz2Sx3, Sz4Sx5, ...]