PurificationMPS¶
full name: tenpy.networks.purification_mps.PurificationMPS
parent module:
tenpy.networks.purification_mps
type: class
Inheritance Diagram
Methods

Initialize self. 

Return an MPS which represents 

Apply a local (one or multisite) operator to self. 

Return the average charge for the block on the left of a given bond. 

Bring self into canonical ‘B’ form, (re)calculate singular values. 
Bring a finite (or segment) MPS into canonical form (in place). 

Bring an infinite MPS into canonical form (in place). 


Return the charge variance on the left of a given bond. 

Compute the momentum quantum numbers of the entanglement spectrum for 2D states. 

Tranform self into different canonical form (by scaling the legs with singular values). 
Returns a copy of self. 


Correlation function 

Calculate the correlation length by diagonalizing the transfer matrix. 

Repeat the unit cell for infinite MPS boundary conditions; in place. 
Calculate the (halfchain) entanglement entropy for all nontrivial bonds. 

Calculate entanglement entropy for general geometry of the bipartition. 

return entanglement energy spectrum. 


Expectation value 
Expectation value 

Expectation value 

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


Construct a matrix product state from a set of numpy arrays Bflat and singular vals. 

Construct an MPS from a single tensor psi with one leg per physical site. 

Load instance from a HDF5 file. 

Initial state corresponding to infiniteTemperature ensemble. 
Construct an MPS from a product state given in lattice coordinates. 


Construct a matrix product state from a given product state. 

Create an MPS of entangled singlets. 

Gauge the legcharges of the virtual bonds such that the MPS has a total qtotal. 

Return (view of) B at site i in canonical form. 
Return singular values on the left of site i 

Return singular values on the right of site i 


contract blocklen subsequent tensors into a single one and return result as a new MPS. 

Given a list of operators, select the one corresponding to site i. 

Return reduced density matrix for a segment. 

Calculates the nsite wavefunction on 
Calculate and return the qtotal of the whole MPS (when contracted). 


Modify self inplace to group sites. 

Modify self inplace to split previously grouped sites. 

Modify self inplace to enlarge the MPS unit cell; in place. 

Calculate the twosite mutual information \(I(i:j)\). 
Check that self is in canonical form. 


Compute overlap 

Applies the permutation perm to the state (inplace). 
Return probabilites of charge value on the left of a given bond. 


Shift the section we define as unit cellof an infinite MPS; in place. 

Export self into a HDF5 file. 

Set B at site i. 

Set singular values on the left of site i 

Set singular values on the right of site i 

Swap the two neighboring sites i and i+1 (inplace). 
Sanity check, raises ValueErrors, if something is wrong. 
Class Attributes and Properties
Number of physical sites; for an iMPS the len of the MPS unit cell. 

Dimensions of the (nontrivial) virtual bonds. 

List of local physical dimensions. 

Distinguish MPS vs iMPS. 

Slice of the nontrivial bond indices, depending on 

class
tenpy.networks.purification_mps.
PurificationMPS
(sites, Bs, SVs, bc='finite', form='B', norm=1.0)[source]¶ Bases:
tenpy.networks.mps.MPS
An MPS representing a finitetemperature ensemble using purification.
Similar as an MPS, but each B has now the four legs
'vL', 'vR', 'p', 'q'
. From the point of algorithms, it is to be considered as a ususal MPS by combining the legs p and q, but all physical operators act only on the p part. For example, the rightcanonical form is defined as if the legs ‘p’ and ‘q’ would be combined, e.g. a rightcanonical B fullfills:npc.tensordot(B, B.conj(),axes=[['vR', 'p', 'q'], ['vR*', 'p*', 'q*']]) == \ npc.eye_like(B, axes='vL') # up to roundoff errors
For expectation values / correlation functions, all operators are to understood to act on p only, i.e. they act trivial on q, so we just trace over
'q', 'q*'
.See also the docstring of the module for details.

classmethod
from_infiniteT
(sites, bc='finite', form='B')[source]¶ Initial state corresponding to infiniteTemperature ensemble.
 Parameters
sites (list of
Site
) – The sites defining the local Hilbert space.bc ({'finite', 'segment', 'infinite'}) – MPS boundary conditions as described in
MPS
.form ((list of) {
'B'  'A'  'C'  'G'  None
 tuple(float, float)}) – The canonical form of the stored ‘matrices’, see table inmps
. A single choice holds for all of the entries.
 Returns
infiniteT_MPS – Describes the infinitetemperature (grand canonical) ensemble, i.e. expectation values give a trace over all basis states.
 Return type

entanglement_entropy_segment
(segment=[0], first_site=None, n=1, legs='p')[source]¶ Calculate entanglement entropy for general geometry of the bipartition.
This function is similar as
entanglement_entropy()
, but for more general geometry of the region A to be a segment of a few sites.This is acchieved by explicitly calculating the reduced density matrix of A and thus works only for small segments.
 Parameters
segment (list of int) – Given a first site i, the region
A_i
is defined to be[i+j for j in segment]
.first_site (
None
 (iterable of) int) – Calculate the entropy for segments starting at these sites.None
defaults torange(Lsegment[1])
for finite or range(L) for infinite boundary conditions.n (int  float) – Selects which entropy to calculate; n=1 (default) is the ususal vonNeumann entanglement entropy, otherwise the nth Renyi entropy.
leg ('p', 'q', 'pq') – Whether we look at the entanglement entropy in both (pq) or only one of auxiliar (q) and physical (p) space.
 Returns
entropies –
entropies[i]
contains the entropy for the the regionA_i
defined above. Return type
1D ndarray

mutinf_two_site
(max_range=None, n=1, legs='p')[source]¶ Calculate the twosite mutual information \(I(i:j)\).
Calculates \(I(i:j) = S(i) + S(j)  S(i,j)\), where \(S(i)\) is the single site entropy on site \(i\) and \(S(i,j)\) the twosite entropy on sites \(i,j\).
 Parameters
max_range (int) – Maximal distance
ij
for which the mutual information should be calculated.None
defaults to L1.leg ('p', 'q', 'pq') – Whether we look at the entanglement entropy in both (pq) or only one of auxiliar (q) and physical (p) space.
 Returns
coords (2D array) – Coordinates for the mutinf array.
mutinf (1D array) –
mutinf[k]
is the mutual information \(I(i:j)\) between the sitesi, j = coords[k]
.

swap_sites
(i, swapOP='auto', trunc_par={})[source]¶ Swap the two neighboring sites i and i+1 (inplace).
Exchange two neighboring sites: form theta, ‘swap’ the physical legs and split with an svd. While the ‘swap’ is just a transposition/relabeling for bosons, one needs to be careful about the sign for fermions.
 Parameters
i (int) – Swap the two sites at positions i and i+1.
swap_op (
None
'auto'
Array
) – The operator used to swap the phyiscal legs of the twosite wave function theta. ForNone
, just transpose/relabel the legs, for'auto'
also take care of fermionic signs. Alternative give an npcArray
which represents the full operator used for the swap. Should have legs['p0', 'p1', 'p0*', 'p1*']
whith'p0', 'p1*'
contractible.trunc_par (dict) – Parameters for truncation, see
truncate()
. chi_max defaults tomax(self.chi)
.
 Returns
trunc_err – The error of the represented state introduced by the truncation after the swap.
 Return type

property
L
¶ Number of physical sites; for an iMPS the len of the MPS unit cell.

add
(other, alpha, beta, cutoff=1e15)[source]¶ Return an MPS which represents
alphaself> + beta others>
.Works only for ‘finite’, ‘segment’ boundary conditions. For ‘segment’ boundary conditions, the virtual legs on the very left/right are assumed to correspond to each other (i.e. self and other have the same state outside of the considered segment). Takes into account
norm
. Parameters
other (
MPS
) – Another MPS of the same length to be added with self.beta (alpha,) – Prefactors for self and other. We calculate
alpha * self> + beta * other>
cutoff (float  None) – Cutoff of singular values used in the SVDs.
 Returns
sum (
MPS
) – An MPS representingalphaself> + beta other>
. Has same total charge as self.U_L, V_R (
Array
) – Only returned for'segment'
boundary conditions. The unitaries defining the new left and right Schmidt states in terms of the old ones, with legs'vL', 'vR'
.

apply_local_op
(i, op, unitary=None, renormalize=False, cutoff=1e13)[source]¶ Apply a local (one or multisite) operator to self.
Note that this destroys the canonical form if the local operator is nonunitary. Therefore, this function calls
canonical_form()
if necessary. Parameters
i (int) – (Leftmost) index of the site(s) on which the operator should act.
op (str  npc.Array) – A physical operator acting on site i, with legs
'p', 'p*'
for a singlesite operator or with legs['p0', 'p1', ...], ['p0*', 'p1*', ...]
for an operator acting on n>=2 sites. Strings (like'Id', 'Sz'
) are translated into singlesite operators defined bysites
.unitary (None  bool) – Whether op is unitary, i.e., whether the canonical form is preserved (
True
) or whether we should callcanonical_form()
(False
).None
checks whethernorm(op dagger(op)  identity)
is smaller than cutoff.renormalize (bool) – Whether the final state should keep track of the norm (False, default) or be renormalized to have norm 1 (True).
cutoff (float) – Cutoff for singular values if op acts on more than one site (see
from_full()
). (And used as cutoff for a unspecified unitary.)

average_charge
(bond=0)[source]¶ Return the average charge for the block on the left of a given bond.
For example for particle number conservation, define \(N_b = sum_{i<b} n_i\) for a given bond b. Then this function returns \(<\psi N_b \psi>\).
 Parameters
bond (int) – The bond to be considered. The returned charges are summed over the sites left of bond.
 Returns
average_charge – For each type of charge in
chinfo
the average value when summing the charge values over sites left of the given bond. Return type
1D array

canonical_form
(renormalize=True)[source]¶ Bring self into canonical ‘B’ form, (re)calculate singular values.
Simply calls
canonical_form_finite()
orcanonical_form_infinite()
.

canonical_form_finite
(renormalize=True, cutoff=0.0)[source]¶ Bring a finite (or segment) MPS into canonical form (in place).
If any site is in
form
None
, it does not use any of the singular values S (for ‘finite’ boundary conditions, or only the very left S for ‘segment’ b.c.). If all sites have a form, it respects the form to ensure that one S is included per bond. The final state is always in rightcanonical ‘B’ form.Performs one sweep left to right doing QR decompositions, and one sweep right to left doing SVDs calculating the singular values.
 Parameters
renormalize (bool) – Whether a change in the norm should be discarded or used to update
norm
.cutoff (float  None) – Cutoff of singular values used in the SVDs.
 Returns
U_L, V_R – Only returned for
'segment'
boundary conditions. The unitaries defining the new left and right Schmidt states in terms of the old ones, with legs'vL', 'vR'
. Return type

canonical_form_infinite
(renormalize=True, tol_xi=1000000.0)[source]¶ Bring an infinite MPS into canonical form (in place).
If any site is in
form
None
, it does not use any of the singular values S. If all sites have a form, it respects the form to ensure that one S is included per bond. The final state is always in rightcanonical ‘B’ form.Proceeds in three steps, namely 1) diagonalize right and left transfermatrix on a given bond to bring that bond into canonical form, and then 2) sweep right to left, and 3) left to right to bringing other bonds into canonical form.

charge_variance
(bond=0)[source]¶ Return the charge variance on the left of a given bond.
For example for particle number conservation, define \(N_b = sum_{i<b} n_i\) for a given bond b. Then this function returns \(<\psi N_b^2 \psi>  (<\psi N_b \psi>)^2\).
 Parameters
bond (int) – The bond to be considered. The returned charges are summed over the sites left of bond.
 Returns
average_charge – For each type of charge in
chinfo
the variance of of the charge values left of the given bond. Return type
1D array

property
chi
¶ Dimensions of the (nontrivial) virtual bonds.

compute_K
(perm, swap_op='auto', trunc_par=None, canonicalize=1e06, verbose=0)[source]¶ Compute the momentum quantum numbers of the entanglement spectrum for 2D states.
Works for an infinite MPS living on a cylinder, infinitely long in x direction and with periodic boundary conditions in y directions. If the state is invariant under ‘rotations’ around the cylinder axis, one can find the momentum quantum numbers of it. (The rotation is nothing more than a translation in y.) This function permutes some sites (on a copy of self) to enact the rotation, and then finds the dominant eigenvector of the mixed transfer matrix to get the quantum numbers, along the lines of [PollmannTurner2012], see also (the appendix and Fig. 11 in the arXiv version of) [CincioVidal2013].
 Parameters
perm (1D ndarray 
Lattice
) – Permuation to be applied to the physical indices, seepermute_sites()
. If a lattice is given, we use it to read out the lattice structure and shift each site by one latticevector in ydirection (assuming periodic boundary conditions). (If you have aCouplingModel
, give its lat attribute for this argument)swap_op (
None
'auto'
Array
) – The operator used to swap the phyiscal legs of a twosite wave function theta, seeswap_sites()
.trunc_par (dict) – Parameters for truncation, see
truncate()
. If not set, chi_max defaults tomax(self.chi)
.canonicalize (float) – Check that self is in canonical form; call
canonical_form()
ifnorm_test()
yieldsnp.linalg.norm(self.norm_test()) > canonicalize
.verbose (float) – Level of verbosity, print status messages if verbose > 0.
 Returns
U (
Array
) – Unitary representation of the applied permutation on left Schmidt states.W (ndarray) – 1D array of the form
S**2 exp(i K)
, where S are the Schmidt values on the left bond. You can usenp.abs()
andnp.angle()
to extract the Schmidt values S and momenta K from W.q (
LegCharge
) – LegCharge corresponding to W.ov (complex) – The eigenvalue of the mixed transfer matrix <psiTpsi> per
L
sites. An absolute value different smaller than 1 indicates that the state is not invariant under the permutation or that the truncation error trunc_err was too large!trunc_err (
TruncationError
) – The error of the represented state introduced by the truncation after swaps when performing the truncation.

convert_form
(new_form='B')[source]¶ Tranform self into different canonical form (by scaling the legs with singular values).
 Parameters
new_form ((list of) {
'B'  'A'  'C'  'G'  'Th'  None
 tuple(float, float)}) – The form the stored ‘matrices’. The table in module docstring. A single choice holds for all of the entries.
:raises ValueError : if trying to convert from a
None
form. Usecanonical_form()
instead!:

copy
()[source]¶ Returns a copy of self.
The copy still shares the sites, chinfo, and LegCharges of the B tensors, but the values of B and S are deeply copied.

correlation_function
(ops1, ops2, sites1=None, sites2=None, opstr=None, str_on_first=True, hermitian=False, autoJW=True)[source]¶ Correlation function
<psiop1_i op2_jpsi>/<psipsi>
of single site operators.Given the MPS in canonical form, it calculates 2site correlation functions. For examples the contraction for a twosite operator on site i would look like:
 .SB[i]B[i+1]...B[j].           op2    op1           .SB*[i]B*[i+1]...B*[j].
Onsite terms are taken in the order
<psi  op1 op2  psi>
.If opstr is given and
str_on_first=True
, it calculates: for i < j for i > j   .SB[i]B[i+1]... B[j]. .SB[j]B[j+1]... B[i].              opstr opstr op2   op2                 op1     opstr opstr op1              .SB*[i]B*[i+1]... B*[j]. .SB*[j]B*[j+1]... B*[i].
For
i==j
, no opstr is included. Forstr_on_first=False
, the opstr on sitemin(i, j)
is always left out.Strings (like
'Id', 'Sz'
) in the arguments are translated into singlesite operators defined by theSite
on which they act. Each operator should have the two legs'p', 'p*'
. Parameters
ops1 ((list of) {
Array
 str }) – First operator of the correlation function (acting after ops2). If a list is given,ops1[i]
acts on site i of the MPS.ops2 ((list of) {
Array
 str }) – Second operator of the correlation function (acting before ops1). If a list is given,ops2[j]
acts on site j of the MPS.sites1 (None  int  list of int) – List of site indices i; a single int is translated to
range(0, sites1)
.None
defaults to all sitesrange(0, L)
. Is sorted before use, i.e. the order is ignored.sites2 (None  int  list of int) – List of site indices; a single int is translated to
range(0, sites2)
.None
defaults to all sitesrange(0, L)
. Is sorted before use, i.e. the order is ignored.opstr (None  (list of) {
Array
 str }) – Ignored by default (None
). Operator(s) to be inserted betweenops1
andops2
. If less thanL
operators are given, we repeat them periodically. If given as a list,opstr[r]
is inserted at site r (independent of sites1 and sites2).str_on_first (bool) – Whether the opstr is included on the site
min(i, j)
. Note the order, which is chosen that way to handle fermionic JordanWigner strings correctly. (In other words: choosestr_on_first=True
for fermions!)hermitian (bool) – Optimization flag: if
sites1 == sites2
andOps1[i]^\dagger == Ops2[i]
(which is not checked explicitly!), the resultingC[x, y]
will be hermitian. We can use that to avoid calculations, sohermitian=True
will run faster.autoJW (bool) – Ignored if opstr is given. If True, autodetermine if a JordanWigner string is needed. Works only if exclusively strings were used for op1 and op2.
 Returns
C – The correlation function
C[x, y] = <psiops1[i] ops2[j]psi>
, whereops1[i]
acts on sitei=sites1[x]
andops2[j]
on sitej=sites2[y]
. If opstr is given, it gives (forstr_on_first=True
):For
i < j
:C[x, y] = <psiops1[i] prod_{i <= r < j} opstr[r] ops2[j]psi>
.For
i > j
:C[x, y] = <psiprod_{j <= r < i} opstr[r] ops1[i] ops2[j]psi>
.For
i = j
:C[x, y] = <psiops1[i] ops2[j]psi>
.
The condition
<= r
is replaced by a strict< r
, ifstr_on_first=False
. Return type
2D ndarray
Examples
For a spin chain:
>>> psi.correlation_function("A", "B") [[A0B0, A0B1, ..., A0B{L1}], [A1B0, A1B1, ..., A1B{L1]], ..., [A{L1}B0, ALB1, ..., A{L1}B{L1}], ]
To evaluate the correlation function for a single i, you can use
sites1=[i]
:>>> psi.correlation_function("A", "B", [3]) [[A3B0, A3B1, ..., A3B{L1}]]
For fermions, it autodetermines that/whether a Jordan Wigner string is needed:
>>> CdC = psi.correlation_function("Cd", "C") # optionally: use `hermitian=True` >>> psi.correlation_function("C", "Cd")[1, 2] == CdC[1, 2] True >>> np.all(np.diag(CdC) == psi.expectation_value("Cd C")) # "Cd C" is equivalent to "N" True
See also
expectation_value_term()
best for a single combination of i and j.

correlation_length
(target=1, tol_ev0=1e08, charge_sector=0)[source]¶ Calculate the correlation length by diagonalizing the transfer matrix.
Assumes that self is in canonical form.
Works only for infinite MPS, where the transfer matrix is a useful concept. Assuming a singlesite unit cell, any correlation function splits into \(C(A_i, B_j) = A'_i T^{ji1} B'_j\) with some parts left and right and the \(ji1\)th power of the transfer matrix in between. The largest eigenvalue is 1 (if self is properly normalized) and gives the dominant contribution of \(A'_i E_1 * 1^{ji1} * E_1^T B'_j = <A> <B>\), and the second largest one gives a contribution \(\propto \lambda_2^{ji1}\). Thus \(\lambda_2 = \exp(\frac{1}{\xi})\).
More general for a Lsite unit cell we get \(\lambda_2 = \exp(\frac{L}{\xi})\), where the xi is given in units of 1 lattice spacing in the MPS.
Warning
For a higherdimensional lattice (which the MPS class doesn’t know about), the correct unit is the lattice spacing in xdirection, and the correct formula is \(\lambda_2 = \exp(\frac{L_x}{\xi})\), where L_x is the number of lattice spacings in the infinite direction within the MPS unit cell, e.g. the number of “rings” of a cylinder in the MPS unit cell. To get to these units, divide the returned xi by the number of sites within a “ring”, for a lattice given in
N_sites_per_ring
. Parameters
target (int) – We look for the target + 1 largest eigenvalues.
tol_ev0 (float) – Print warning if largest eigenvalue deviates from 1 by more than tol_ev0.
charge_sector (None  charges 
0
) – Selects the charge sector in which the dominant eigenvector of the TransferMatrix is.None
stands for all sectors,0
stands for the zerocharge sector. Defaults to0
, i.e., assumes the dominant eigenvector is in charge sector 0.
 Returns
xi – If target`=1, return just the correlation length, otherwise an array of the `target largest correlation lengths. It is measured in units of a single lattice spacing in the MPS language, see the warning above.
 Return type
float  1D array

property
dim
¶ List of local physical dimensions.

enlarge_mps_unit_cell
(factor=2)[source]¶ Repeat the unit cell for infinite MPS boundary conditions; in place.
 Parameters
factor (int) – The new number of sites in the unit cell will be increased from L to
factor*L
.

entanglement_entropy
(n=1, bonds=None, for_matrix_S=False)[source]¶ Calculate the (halfchain) entanglement entropy for all nontrivial bonds.
Consider a bipartition of the sytem into \(A = \{ j: j <= i_b \}\) and \(B = \{ j: j > i_b\}\) and the reduced density matrix \(\rho_A = tr_B(\rho)\). The vonNeumann entanglement entropy is defined as \(S(A, n=1) = tr(\rho_A \log(\rho_A)) = S(B, n=1)\). The generalization for
n != 1, n>0
are the Renyi entropies: \(S(A, n) = \frac{1}{1n} \log(tr(\rho_A^2)) = S(B, n=1)\)This function calculates the entropy for a cut at different bonds i, for which the the eigenvalues of the reduced density matrix \(\rho_A\) and \(\rho_B\) is given by the squared schmidt values S of the bond.
 Parameters
n (int/float) – Selects which entropy to calculate; n=1 (default) is the ususal vonNeumann entanglement entropy.
bonds (
None
 (iterable of) int) – Selects the bonds at which the entropy should be calculated.None
defaults torange(0, L+1)[self.nontrivial_bonds]
.for_matrix_S (bool) – Switch calculate the entanglement entropy even if the _S are matrices. Since \(O(\chi^3)\) is expensive compared to the ususal \(O(\chi)\), we raise an error by default.
 Returns
entropies – Entanglement entropies for halfcuts. entropies[j] contains the entropy for a cut at bond
bonds[j]
(i.e. left to sitebonds[j]
). Return type
1D ndarray

entanglement_spectrum
(by_charge=False)[source]¶ return entanglement energy spectrum.
 Parameters
by_charge (bool) – Wheter we should sort the spectrum on each bond by the possible charges.
 Returns
ent_spectrum – For each (nontrivial) bond the entanglement spectrum. If by_charge is
False
, return (for each bond) a sorted 1D ndarray with the convention \(S_i^2 = e^{\xi_i}\), where \(S_i\) labels a Schmidt value and \(\xi_i\) labels the entanglement ‘energy’ in the returned spectrum. If by_charge is True, return a a list of tuples(charge, sub_spectrum)
for each possible charge on that bond. Return type

expectation_value
(ops, sites=None, axes=None)[source]¶ Expectation value
<psiopspsi>/<psipsi>
of (nsite) operator(s).Given the MPS in canonical form, it calculates nsite expectation values. For example the contraction for a twosite (n = 2) operator on site i would look like:
 .SB[i]B[i+1].             op             .SB*[i]B*[i+1].
 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 self.L operators are given, we repeat them periodically. Strings (like'Id', 'Sz'
) are translated into singlesite operators defined bysites
.sites (None  list of int) – List of site indices. Expectation values are evaluated there. If
None
(default), the entire chain is taken (clipping for finite b.c.)axes (None  (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 nonconjugated B.
None
defaults to(['p'], ['p*'])
for single site operators (n = 1), or(['p0', 'p1', ... 'p{n1}'], ['p0*', 'p1*', .... 'p{n1}*'])
for n > 1.
 Returns
exp_vals – Expectation values,
exp_vals[i] = <psiops[i]psi>
, whereops[i]
acts on site(s)j, j+1, ..., j+{n1}
withj=sites[i]
. Return type
1D ndarray
Examples
One site examples (n=1):
>>> psi.expectation_value('Sz') [Sz0, Sz1, ..., Sz{L1}] >>> psi.expectation_value(['Sz', 'Sx']) [Sz0, Sx1, Sz2, Sx3, ... ] >>> psi.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*'])) >>> psi.expectation_value(SzSx) [Sz0Sx1, Sz1Sx2, Sz2Sx3, ... ] # with len L1 for finite bc, or L for infinite
Example measuring <psiSzSxpsi2> 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.L1, 2)] >>> psi.expectation_value(SzSx_list, range(0, psi.L1, 2)) [Sz0Sx1, Sz2Sx3, Sz4Sx5, ...]

expectation_value_multi_sites
(operators, i0)[source]¶ Expectation value
<psiop0_{i0}op1_{i0+1}...opN_{i0+N}psi>/<psipsi>
.Calculates the expectation value of a tensor product of singlesite operators acting on different sites next to each other. In other words, evaluate the expectation value of a term
op0_i0 op1_{i0+1} op2_{i0+2} ...
.Warning
This function does not automatically add JordanWigner strings! For correct handling of fermions, use
expectation_value_term()
instead. Parameters
 Returns
exp_val – The expectation value of the tensorproduct of the given onsite operators,
<psioperators[0]_{i0} operators[1]_{i0+1} ... psi>/<psipsi>
, wherepsi>
is the represented MPS. Return type
float/complex

expectation_value_term
(term, autoJW=True)[source]¶ Expectation value
<psiop_{i0}op_{i1}...op_{iN}psi>/<psipsi>
.Calculates the expectation value of a tensor product of singlesite operators acting on different sites i0, i1, … (not necessarily next to each other). In other words, evaluate the expectation value of a term
op0_i0 op1_i1 op2_i2 ...
.For example the contraction of three onesite operators on sites i0, i1=i0+1, i2=i0+3 would look like:
 .SB[i0]B[i0+1]B[i0+2]B[i0+3].          op1 op2  op3          .SB*[i0]B*[i0+1]B*[i0+2]B*[i0+3].
 Parameters
term (list of (str, int)) – List of tuples
op, i
where i is the MPS index of the site the operator named op acts on. The order inside term determines the order in which they act (in the mathematical convention: the last operator in term is rightmost, so it acts first on a Ket).autoJW (bool) – If True (default), automatically insert Jordan Wigner strings for Fermions as needed.
 Returns
exp_val – The expectation value of the tensorproduct of the given onsite operators,
<psiop_i0 op_i1 ... op_iN psi>/<psipsi>
, wherepsi>
is the represented MPS. Return type
float/complex
See also
correlation_function()
efficient way to evaluate many correlation functions.
Examples
>>> a = psi.expectation_value_term([('Sx', 2), ('Sz', 4)]) >>> b = psi.expectation_value_term([('Sz', 4), ('Sx', 2)]) >>> c = psi.expectation_value_multi_sites(['Sz', 'Id', 'Sz'], i0=2) >>> assert a == b == c

expectation_value_terms_sum
(term_list, prefactors=None)[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.
Note
Due to the way MPO expectation values are evaluated for infinite systems, it works only if all terms in the term_list start within the MPS unit cell.
Deprecated since version 0.4.0: prefactor will be removed in version 1.0.0. Instead, directly give just
TermList(term_list, prefactors)
as argument. Parameters
 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 MPSterms_sum = _mpo.expectation_value(self) * self.L
See also
expectation_value_term()
evaluates a single term.
tenpy.networks.mpo.MPO.expectation_value()
expectation value density of an MPO.

property
finite
¶ Distinguish MPS vs iMPS.
True for an MPS (
bc='finite', 'segment'
), False for an iMPS (bc='infinite'
).

classmethod
from_Bflat
(sites, Bflat, SVs=None, bc='finite', dtype=None, permute=True, form='B', legL=None)[source]¶ Construct a matrix product state from a set of numpy arrays Bflat and singular vals.
 Parameters
sites (list of
Site
) – The sites defining the local Hilbert space.Bflat (iterable of numpy ndarrays) – The matrix defining the MPS on each site, with legs
'p', 'vL', 'vR'
(physical, virtual left/right).SVs (list of 1D array 
None
) – The singular values on each bond. Should always have length L+1. By default (None
), set all singular values to the same value. Entries out ofnontrivial_bonds
are ignored.bc ({'infinite', 'finite', 'segmemt'}) – MPS boundary conditions. See docstring of
MPS
.dtype (type or string) – The data type of the array entries. Defaults to the common dtype of Bflat.
permute (bool) – The
Site
might permute the local basis states if charge conservation gets enabled. If permute is True (default), we permute the given Bflat locally according to each site’sperm
. The p_state argument should then always be given as if conserve=None in the Site.form ((list of) {
'B'  'A'  'C'  'G'  None
 tuple(float, float)}) – Defines the canonical form of Bflat. See module docstring. A single choice holds for all of the entries.leg_L (LegCharge 
None
) – Leg charges at bond 0, which are purely conventional. IfNone
, use trivial charges.
 Returns
mps – An MPS with the matrices Bflat converted to npc arrays.
 Return type
MPS

classmethod
from_full
(sites, psi, form=None, cutoff=1e16, normalize=True, bc='finite', outer_S=None)[source]¶ Construct an MPS from a single tensor psi with one leg per physical site.
Performs a sequence of SVDs of psi to split off the B matrices and obtain the singular values, the result will be in canonical form. Obviously, this is only welldefined for finite or segment boundary conditions.
 Parameters
sites (list of
Site
) – The sites defining the local Hilbert space.psi (
Array
) – The full wave function to be represented as an MPS. Should have labels'p0', 'p1', ..., 'p{L1}'
. Additionally, it may have (or must have for ‘segment’ bc) the legs'vL', 'vR'
, which are trivial for ‘finite’ bc.form (
'B'  'A'  'C'  'G'  None
) – The canonical form of the resulting MPS, see module docstring.None
defaults to ‘A’ form on the first site and ‘B’ form on all following sites.cutoff (float) – Cutoff of singular values used in the SVDs.
normalize (bool) – Whether the resulting MPS should have ‘norm’ 1.
bc ('finite'  'segment') – Boundary conditions.
outer_S (None  (array, array)) – For ‘semgent’ bc the singular values on the left and right of the considered segment, None for ‘finite’ boundary conditions.
 Returns
psi_mps – MPS representation of psi, in canonical form and possibly normalized.
 Return type
MPS

classmethod
from_hdf5
(hdf5_loader, h5gr, subpath)[source]¶ Load instance from a HDF5 file.
This method reconstructs a class instance from the data saved with
save_hdf5()
. Parameters
hdf5_loader (
Hdf5Loader
) – Instance of the loading engine.h5gr (
Group
) – HDF5 group which is represent the object to be constructed.subpath (str) – The name of h5gr with a
'/'
in the end.
 Returns
obj – Newly generated class instance containing the required data.
 Return type
cls

classmethod
from_lat_product_state
(lat, p_state, **kwargs)[source]¶ Construct an MPS from a product state given in lattice coordinates.
This is a wrapper around
from_product_state()
. The purpuse is to make the p_state argument independent of the order of the Lattice, and specify it in terms of lattice indices instead. Parameters
lat (
Lattice
) – The underlying lattice defining the geometry and Hilbert Space.p_state (array_like of {int  str  1D array}) – Defines the product state to be represented. Should be of dimension lat.dim`+1, entries are indexed by lattice indices. Entries of the array as for the `p_state argument of
from_product_state()
. It gets tiled to the shapelat.shape
, if it is smaller.**kwargs – Other keyword arguments as definied in
from_product_state()
. bc is set by default fromlat.bc_MPS
.
 Returns
product_mps – An MPS representing the specified product state.
 Return type
MPS
Examples
Let’s first consider a
Ladder
composed of aSpinHalfSite
and aFermionSite
.>>> spin_half = tenpy.networks.site.SpinHalfSite() >>> fermion = tenpy.networks.site.FermionSite() >>> ladder_i = tenpy.models.lattice.Ladder(2, [spin_half, fermion], bc_MPS="infinite")
To initialize a state of upspins on the spin sites and halffilled ferions, you can use:
>>> p_state = [["up", "empty"], ["up", "full"]] >>> psi = tenpy.networks.MPS.from_lat_product_state(ladder_i, p_state)
Note that the same p_state works for a finite lattice of even length, say
L=10
, as well. We then just “tile” in xdirection, i.e., repeat the specified state 5 times:>>> ladder_f = tenpy.models.lattice.Ladder(10, [spin_half, fermion], bc_MPS="finite") >>> psi = tenpy.networks.MPS.from_lat_product_state(ladder_f, p_state)
You can also easily halffill a
Honeycomb
, for example with only the A sites occupied, or as stripe parallel to the xdirection (stripe_x, alternating along y axis), or as stripes parallel to the ydirection (stripe_y, alternating along x axis).>>> honeycomb = tenpy.models.lattice.Honeycomb([4, 4], [fermion, fermion], bc_MPS="finite") >>> p_state_only_A = [[["empty", "full"]]] >>> psi_only_A = tenpy.networks.MPS.from_lat_product_state(honeycomb, p_state_only_A) >>> p_state_stripe_x = [[["empty", "empty"], ... ["full", "full"]]] >>> psi_stripe_x = tenpy.networks.MPS.from_lat_product_state(honeycomb, p_state_stripe_x) >>> p_state_stripe_y = [[["empty", "empty"]], ... [["full", "full"]]] >>> psi_stripe_y = tenpy.networks.MPS.from_lat_product_state(honeycomb, p_state_stripe_y)

classmethod
from_product_state
(sites, p_state, bc='finite', dtype=<class 'numpy.float64'>, permute=True, form='B', chargeL=None)[source]¶ Construct a matrix product state from a given product state.
 Parameters
sites (list of
Site
) – The sites defining the local Hilbert space.p_state (list of {int  str  1D array}) – Defines the product state to be represented; one entry for each site of the MPS. An entry of str type is translated to an int with the help of
state_labels()
. An entry of int type represents the physical index of the state to be used. An entry which is a 1D array defines the complete wavefunction on that site; this allows to make a (local) superposition.bc ({'infinite', 'finite', 'segmemt'}) – MPS boundary conditions. See docstring of
MPS
.dtype (type or string) – The data type of the array entries.
permute (bool) – The
Site
might permute the local basis states if charge conservation gets enabled. If permute is True (default), we permute the given p_state locally according to each site’sperm
. The p_state entries should then always be given as if conserve=None in the Site.form ((list of) {
'B'  'A'  'C'  'G'  None
 tuple(float, float)}) – Defines the canonical form. See module docstring. A single choice holds for all of the entries.chargeL (charges) – Leg charges at bond 0, which are purely conventional.
 Returns
product_mps – An MPS representing the specified product state.
 Return type
MPS
Examples
Example to get a Neel state for a
TIChain
:>>> M = TFIChain({'L': 10}) >>> p_state = ["up", "down"] * (L//2) # repeats entries L/2 times >>> psi = MPS.from_product_state(M.lat.mps_sites(), p_state, bc=M.lat.bc_MPS)
The meaning of the labels
"up","down"
is defined by theSite
, in this example aSpinHalfSite
.Extending the example, we can replace the spin in the center with one with arbitrary angles
theta, phi
in the bloch sphere:>>> M = TFIChain({'L': 8, 'conserve': None}) >>> p_state = ["up", "down"] * (L//2) # repeats entries L/2 times >>> bloch_sphere_state = np.array([np.cos(theta/2), np.exp(1.j*phi)*np.sin(theta/2)]) >>> p_state[L//2] = bloch_sphere_state # replace one spin in center >>> psi = MPS.from_product_state(M.lat.mps_sites(), p_state, bc=M.lat.bc_MPS, dtype=np.complex)
Note that for the more general
SpinChain
, the order of the two entries for thebloch_sphere_state
would be exactly the opposite (when we keep the the northpole of the bloch sphere being the upstate). The reason is that the SpinChain uses the generalSpinSite
, where the states are orderd ascending from'down'
to'up'
. TheSpinHalfSite
on the other hand uses the order'up', 'down'
where that the Pauli matrices look as usual.Moreover, note that you can not write this bloch state (for
theta != 0, pi
) when conserving symmetries, as the two physical basis states correspond to different symmetry sectors.

classmethod
from_singlets
(site, L, pairs, up='up', down='down', lonely=[], lonely_state='up', bc='finite')[source]¶ Create an MPS of entangled singlets.
 Parameters
site (
Site
) – The site defining the local Hilbert space, taken uniformly for all sites.L (int) – The number of sites.
pairs (list of (int, int)) – Pairs of sites to be entangled; the returned MPS will have a singlet for each pair in pairs.
down (up,) – A singlet is defined as
(up down>  down up>)/2**0.5
,up
anddown
give state indices or labels defined on the corresponding site.lonely (list of int) – Sites which are not included into a singlet pair.
lonely_state (int  str) – The state for the lonely sites.
bc ({'infinite', 'finite', 'segmemt'}) – MPS boundary conditions. See docstring of
MPS
.
 Returns
singlet_mps – An MPS representing singlets on the specified pairs of sites.
 Return type
MPS

gauge_total_charge
(qtotal=None, vL_leg=None, vR_leg=None)[source]¶ Gauge the legcharges of the virtual bonds such that the MPS has a total qtotal.
 Parameters
qtotal ((list of) charges) – If a single set of charges is given, it is the desired total charge of the MPS (which
get_total_charge()
will return afterwards). By default (None
), use 0 charges, unless vL_leg and vR_leg are specified, in which case we adjust the total charge to match these legs.vL_leg (None  LegCharge) – Desired new virtual leg on the very left. Needs to have the same block strucuture as current leg, but can have shifted charge entries.
vR_leg (None  LegCharge) – Desired new virtual leg on the very right. Needs to have the same block strucuture as current leg, but can have shifted charge entries. Should be vL_leg.conj() for infinite MPS, if qtotal is not given.

get_B
(i, form='B', copy=False, cutoff=1e16, label_p=None)[source]¶ Return (view of) B at site i in canonical form.
 Parameters
i (int) – Index choosing the site.
form (
'B'  'A'  'C'  'G'  'Th'  None
 tuple(float, float)) – The (canonical) form of the returned B. ForNone
, return the matrix in whatever form it is. If any of the tuple entry is None, also don’t scale on the corresponding axis.copy (bool) – Whether to return a copy even if form matches the current form.
cutoff (float) – During DMRG with a mixer, S may be a matrix for which we need the inverse. This is calculated as the Penrose pseudoinverse, which uses a cutoff for the singular values.
label_p (None  str) – Ignored by default (
None
). Otherwise replace the physical label'p'
with'p'+label_p'
. (For derived classes with more than one “physical” leg, replace all the physical leg labels accordingly.)
 Returns
B – The MPS ‘matrix’ B at site i with leg labels
'vL', 'p', 'vR'
. May be a view of the matrix (ifcopy=False
), or a copy (if the form changed orcopy=True
). Return type
:raises ValueError : if self is not in canoncial form and form is not None.:

get_grouped_mps
(blocklen)[source]¶ contract blocklen subsequent tensors into a single one and return result as a new MPS.
blocklen = number of subsequent sites to be combined.
 Returns
 Return type
new MPS object with bunched sites.

get_op
(op_list, i)[source]¶ Given a list of operators, select the one corresponding to site i.
 Parameters
 Returns
op – One of the entries in op_list, not copied.
 Return type
npc.array

get_rho_segment
(segment)[source]¶ Return reduced density matrix for a segment.
Note that the dimension of rho_A scales exponentially in the length of the segment.
 Parameters
segment (iterable of int) – Sites for which the reduced density matrix is to be calculated. Assumed to be sorted.
 Returns
rho – Reduced density matrix of the segment sites. Labels
'p0', 'p1', ..., 'pk', 'p0*', 'p1*', ..., 'pk*'
withk=len(segment)
. Return type

get_theta
(i, n=2, cutoff=1e16, formL=1.0, formR=1.0)[source]¶ Calculates the nsite wavefunction on
sites[i:i+n]
. Parameters
i (int) – Site index.
n (int) – Number of sites. The result lives on
sites[i:i+n]
.cutoff (float) – During DMRG with a mixer, S may be a matrix for which we need the inverse. This is calculated as the Penrose pseudoinverse, which uses a cutoff for the singular values.
formL (float) – Exponent for the singular values to the left.
formR (float) – Exponent for the singular values to the right.
 Returns
theta – The nsite wave function with leg labels
vL, p0, p1, .... p{n1}, vR
. In Vidal’s notation (with s=lambda, G=Gamma):theta = s**form_L G_i s G_{i+1} s ... G_{i+n1} s**form_R
. Return type

get_total_charge
(only_physical_legs=False)[source]¶ Calculate and return the qtotal of the whole MPS (when contracted).
 Parameters
only_physical_legs (bool) – For
'finite'
boundary conditions, the total charge can be gauged away by changing the LegCharge of the trivial legs on the left and right of the MPS. This option allows to project out the trivial legs to get the actual “physical” total charge. Returns
qtotal – The sum of the qtotal of the individual B tensors.
 Return type
charges

group_sites
(n=2, grouped_sites=None)[source]¶ Modify self inplace to group sites.
Group each n sites together using the
GroupedSite
. This might allow to do TEBD with a Trotter decomposition, or help the convergence of DMRG (in case of too long range interactions). Parameters
n (int) – Number of sites to be grouped together.
grouped_sites (None  list of
GroupedSite
) – The sites grouped together.
See also
group_split()
Reverts the grouping.

group_split
(trunc_par=None)[source]¶ Modify self inplace to split previously grouped sites.
 Parameters
trunc_par (dict) – Parameters for truncation, see
truncate()
. Defaults to{'chi_max': max(self.chi)}
. Returns
trunc_err – The error introduced by the truncation for the splitting.
 Return type
See also
group_sites()
Should have been used before to combine sites.

increase_L
(new_L=None)[source]¶ Modify self inplace to enlarge the MPS unit cell; in place.
Deprecated since version 0.5.1: This method will be removed in version 1.0.0. Use the equivalent
psi.enlarge_mps_unit_cell(new_L//psi.L)
instead ofpsi.increase_L(new_L)
.

property
nontrivial_bonds
¶ Slice of the nontrivial bond indices, depending on
self.bc
.

norm_test
()[source]¶ Check that self is in canonical form.
 Returns
norm_error – For each site the norm error to the left and right. The error
norm_error[i, 0]
is defined as the normdifference between the following networks: theta[i]. s[i].    vs   theta*[i]. s[i].
Similarly,
norm_errror[i, 1]
is the normdifference of: .theta[i] .s[i+1]    vs   .theta*[i] .s[i+1]
 Return type
array, shape (L, 2)

overlap
(other, charge_sector=None, ignore_form=False, **kwargs)[source]¶ Compute overlap
<selfother>
. Parameters
other (
MPS
) – An MPS with the same physical sites.charge_sector (None  charges 
0
) – Selects the charge sector in which the dominant eigenvector of the TransferMatrix is.None
stands for all sectors,0
stands for the sector of zero charges. If a sector is given, it assumes the dominant eigenvector is in that charge sector.ignore_form (bool) – If
False
(default), take into account the canonical formform
at each site. IfTrue
, we ignore the canonical form (i.e., whether the MPS is in left, right, mixed or no canonical form) and just contract all the_B
as they are. (This can give different results!)**kwargs – Further keyword arguments given to
TransferMatrix.eigenvectors()
; only used for infinite boundary conditions.
 Returns
overlap – The contraction
<selfother> * self.norm * other.norm
(i.e., taking into account thenorm
of both MPS). For an infinite MPS,<selfother>
is the overlap per unit cell, i.e., the largest eigenvalue of the TransferMatrix. Return type
dtype.type

permute_sites
(perm, swap_op='auto', trunc_par={}, verbose=0)[source]¶ Applies the permutation perm to the state (inplace).
 Parameters
perm (ndarray[ndim=1, int]) – The applied permutation, such that
psi.permute_sites(perm)[i] = psi[perm[i]]
(where[i]
indicates the ith site).swap_op (
None
'auto'
Array
) – The operator used to swap the phyiscal legs of a twosite wave function theta, seeswap_sites()
.trunc_par (dict) – Parameters for truncation, see
truncate()
. chi_max defaults tomax(self.chi)
.verbose (float) – Level of verbosity, print status messages if verbose > 0.
 Returns
trunc_err – The error of the represented state introduced by the truncation after the swaps.
 Return type

probability_per_charge
(bond=0)[source]¶ Return probabilites of charge value on the left of a given bond.
For example for particle number conservation, define \(N_b = sum_{i<b} n_i\) for a given bond b. This function returns the possible values of N_b as rows of charge_values, and for each row the probabilty that this combination occurs in the given state.
 Parameters
bond (int) – The bond to be considered. The returned charges are summed on the left of this bond.
 Returns
charge_values (2D array) – Columns correspond to the different charges in self.chinfo. Rows are the different charge fluctuations at this bond
probabilities (1D array) – For each row of charge_values the probablity for these values of charge fluctuations.

roll_mps_unit_cell
(shift=1)[source]¶ Shift the section we define as unit cellof an infinite MPS; in place.
Suppose we have a unit cell with tensors
[A, B, C, D]
(repeated on both sites). Withshift = 1
, the new unit cell will be[D, A, B, C]
, whereasshift = 1
will give[B, C, D, A]
. Parameters
shift (int) – By how many sites to move the tensors to the right.

save_hdf5
(hdf5_saver, h5gr, subpath)[source]¶ Export self into a HDF5 file.
This method saves all the data it needs to reconstruct self with
from_hdf5()
.Specifically, it saves
sites
,chinfo
(under these names),_B
as"tensors"
,_S
as"singular_values"
,bc
as"boundary_condition"
, andform
converted to a single array of shape (L, 2) as"canonical_form"
, Moreover, it savesnorm
,L
,grouped
and_transfermatrix_keep
(as “transfermatrix_keep”) as HDF5 attributes, as well as the maximum ofchi
under the name “max_bond_dimension”.

set_B
(i, B, form='B')[source]¶ Set B at site i.
 Parameters
i (int) – Index choosing the site.
B (
Array
) – The ‘matrix’ at site i. No copy is made! Should have leg labels'vL', 'p', 'vR'
(not necessarily in that order).form (
'B'  'A'  'C'  'G'  'Th'  None
 tuple(float, float)) – The (canonical) form of the B to set.None
stands for noncanonical form.

classmethod