• View
• Edit
• Rename
• History
• Print
• Backlinks

Overview

An infinite MPS (iMPS) is described by a set of {$L$} A-matrices, {% A^{s_1} A^{s_2} \ldots A^{s_L} \; . %}

{$L$} is the unit cell size of the iMPS. These matrices describe a translationally invariant infinite system, where the unit cell is repeated on both the left and right.

It is important to distinguish the unit cell size of the wavefunction versus the unit cell size of the Hamiltonian. The unit cell size of the wavefunction is an integer multiple of the Hamiltonian unit cell. Generally, we want to choose a wavefunction unit cell that is as small as possible, but it is sometimes not possible to have the wavefunction as just a single Hamiltonian unit cell. This is because the wavefunction may break translation symmetry in a larger unit cell than the Hamiltonian. An example is the spin-1/2 Heisenberg chain, where the usual form of the Hamiltonian is such that the groundstate has momentum {$\pi$}, and hence is only translationally invariant under 2-site shifts, although the Hamiltonian itself is invariant under a 1-site translation.

Lattice sites and operators

By convention, sites within the unit cell are denoted with square brackets. For example the Sp operator (toolkit notation for the {$S^+$} operator) acting on the 2^nd site of a unit cell is denoted Sp[2]. If the operator is acting on a specific unit cell, then the unit cell number is denoted in round brackets, for example the 0^th unit cell, Sp(0)[2]. The site number within the unit cell, and the unit cell number, are both zero-based, so (0)[0] will normally denote the left-most site in a system. But in most cases, the cell number for an iMPS is arbitrary because of translational invariance.

Tip: if the unit cell size is 1 site, then the [0] can be omitted.

The toolkit uses several different types of operators. Many kinds of operator expressions are allowed, for details see Main.OperatorExpressions.

• Local operators

Local operators are defined on a single site of a lattice. These are rarely used on their own, rather they are building blocks of other operators. The local operators are defined in the LatticeSite object of a model, for example the models/spin-u1.h defines a LatticeSite that contains operators Sz, Sp, Sm, I, R, P.

Most commonly, we will refer to a local operator acting on a specific site and unit cell, as, for example, Sp(2)[0], or Sz(5) (if the unit cell is 1-site).

• Finite operators

These operators act on a finite support. For example, the operator Sp(0)[0] * Sm(5)[1] is a finite operator that spans 6 unit cells, from 0 .. 5, and represents the operator that decreases the spin at site 1 of the 5th unit cell, and increases the spin at site 0 of the 0th unit cell.

To calculate expectation values of finite operators, use mp-iexpectation. An example is

mp-iexpectation psi lattice:"Sz(0)*exp(i*pi*Sz(1))*Sz(2)"

This command will calculate a string correlation function between unit cells 0 and 2. Since there is no cell index specified, it is assumed that the unit cell is only 1 site.

Finite operators can be defined in the lattice file too. In this case, the operator is always attached to the unit cell. In the the C++ code this is denoted using a UnitCellOperator. For example,

UnitCell Cell(MyLatticeSite);
UnitCellOperator Sz(Cell, "Sz");
UnitCellOperator U(Cell, "U");
U = exp(complex_i * pi * Sz(0));

In this example, Sz is a pre-existing local operator, and the new operator (or we overwrite it, if it already existed) U is defined as {$\exp[i\pi Sz(0)]$}. With this definition, we could, for example, simply the previous mp-iexpectation command to

mp-iexpectation psi lattice:"Sz(0)*U(1)*Sz(2)"

Note that a UnitCellOperator can have arbitrary finite support. So we could, for example, define

UnitCellOperator B(Cell, "B");
UnitCellOperator BH(Cell, "BH");
UnitCellOperator BondCurrent(Cell, "BondCurrent");
BondCurrent = complex_i * (BH(0)*B(1) - B(0)*BH(1));

and then mp-expectation psi lattice:"BondCurrent(0)" will calculate the expectation value of the bond current operator at the bond between unit cells 0 and 1.

Because of wavefunction translational invariance, the cell number is only meaningful modulo the wavefunction unit cell size. So if the wavefunction has the same unit cell size as the lattice itself, then the cell index is irrelevant; BondCurrent(0) means exactly the same thing as BondCurrent(4), or even BondCurrent(-10). But if, for example, the wavefunction is larger, and is defined on N lattice unit cells, then expectation values will also be periodic with period N.

• Triangular operators

So-called triangular operators have infinite support, and represent the sum of terms acting on all unit cells. They can also represent arbitrary polynomials of these operators. The name 'triangular operator' arises because the Matrix Product Operator representation of these operators is of the form of an upper-triangular matrix.

The simplest triangular operator is the sum of some local term. The basic way of constructing a triangular operator (in either C++ or the expression parser) is with the sum_unit() function. The sum_unit() function takes a finite operator, and constructs a triangular operator that represents the sum of all possible translations of that finite operator.

For example, sum_unit(Sz(0)) represents the infinite sum {$\sum_i S^{z}(i)$}, which is the z-component of magnetization operator.

sum_unit() will calculate the sum of an arbitrary finite operator. This makes it useful for constructing Hamiltonians. For example, the Hamiltonian of the Heisenberg spin chain is {%H = \sum_i S^z(i) S^z(i+1) + \frac{1}{2} \left( S^+(i) S^-(i+1) + S^-(i) S^+_(i+1) \right)%} and we would construct this operator using

sum_unit( Sz(0)*Sz(1) + 0.5*( Sp(0)*Sm(1) + Sm(0)*Sp(1) ) )

Triangular operators can be added to a C++ Lattice object directly, for example

Lattice["H"] = sum_unit( Sz(0)*Sz(1) + 0.5*( Sp(0)*Sm(1) + Sm(0)*Sp(1) ) )

and the command-line parser also allows many kinds of expressions on triangular operators.

The basic tool for calculating expectation values of triangular operators is mp-imoments. This is named because it can calculate moments of an operator, {$\langle X^n \rangle$}, up to some arbitrary power {$n$} (limited by computation time). For example,

mp-imoments psi lattice:"sum_unit( Sz(0)*Sz(1) + 0.5*( Sp(0)*Sm(1) + Sm(0)*Sp(1) ) )"

will calculate the energy of a Heisenberg Hamiltonian for the wavefunction psi.

Expectation values of triangular operators are defined per unit cell. So for example, we have the energy per unit cell, or the magnetization per unit cell. More generally, products of triangular operators have expectation values that are polynomial functions per unit cell. For example, if we add the --power 2 option to mp-imoments (or simply square the operator), then it is calculating the expectation value {$\langle H^2 \rangle$}, which is a polynomial in the number of unit cells L, {%\langle H^2 \rangle_L = L^2 \epsilon^2 + L \sigma^2%} where {$\epsilon$} is the energy per unit cell, and {$\sigma^2$} is the variance per unit cell.

Tip: calculating the expectation value of H^2 in this way is very useful as the variance is an excellent measure of the convergence of the wavefunction.

• Product operators

The final type of operator that is used in the toolkit denotes an infinite product of operators. These operators are typically used for string correlation functions, or Jordan-Wigner strings, or evolution operators, for example from the Suzuki-Trotter decomposition of exp(H).

Analogously to sum_unit for triangular operators, product operators are constructed using prod_unit. For example, prod_unit(exp(i*pi*Sz(0))) represents the operator {%\mbox{prod_unit(exp(i*pi*Sz(0)))} \equiv \Pi_i (-1)^{S^z(i)} \equiv \exp \left[ i \pi \sum_i S^z(i) \right]%}

Product operators are used in several contexts. To calculate the expectation value of a product operator, use the mp-ioverlap command. This command calculates the overlap between two wavefunctions (or a wavefunction and itself), and takes an optional argument where you can supply a product operator, --string <operator>. Expectation values of product operators are defined per unit cell, in a multiplicative sense. If the expectation value is {$d$} per unit cell, then on {$L$} unit cells the expectation value is {$d^L$}. In the typical case, the product operator is unitary, and it therefore makes sense to also describe the expectation value in terms of a correlation length {$\xi = - 1 / \ln d$}.