Library documentation

mutable struct FiniteMPS{A<:GenericMPSTensor,B<:MPSBondTensor} <: AbstractMPS

Represents a finite matrix product state

When queried for AL/AR/AC/CL it will check if it is missing. If not, return If it is, calculate it, store it and return

struct InfiniteMPS{A<:GenericMPSTensor,B<:MPSBondTensor}

Represents an infinite matrix product state The state is stored in the centergauge where state.AL[i]state.CR[i] = state.AC[i] = state.CR[i-1]state.AR[i]

MPSComoving(leftstate,window,rightstate)

muteable window of tensors on top of an infinite chain

2d extension of InfiniteMPS

MPOHamiltonian

represents a general periodic quantum hamiltonian

ComAct(ham1,ham2)

Acts on an mpo with mpo hamiltonian 'ham1' from below + 'ham2' from above.
Can therefore represent the (anti) commutator.

Represents a periodic (in 2 directions) statmech mpo

Abstract environment for an infinite state
distinct from finite, because we have to recalculate everything when the state changes

This object manages the periodic mpo environments for an MPSMultiline

This object manages the hamiltonian environments for an InfiniteMPS

FinEnv keeps track of the environments for FiniteMPS / MPSComoving
It automatically checks if the queried environment is still correctly cached and if not - recalculates

SimpleEnv does nothing fancy to ensure the correctness of the environments it returns.
Supports setleftenv! and setrightenv!
Only used internally (in idmrg); no public constructor is provided

Zero-site derivative (the C matrix to the right of pos)

One-site derivative

Two-site derivative

calculates the expectation value for the given operator/hamiltonian

find_groundstate(state,ham,alg,pars=params(state,ham))

find the groundstate for ham using algorithm alg

function timestep(psi, operator, dt, alg,pars = params(psi,operator))

time evolves psi by timestep dt using algorithm alg

leading_boundary(state,opp,alg,pars=params(state,ham))

approximate the leading eigenvector for opp

https://arxiv.org/pdf/cond-mat/0203500.pdf

quasiparticle_excitation calculates the energy of the first excited state at momentum 'moment'

see https://arxiv.org/abs/1701.07035

onesite infinite dmrg

onesite dmrg

twosite dmrg

GradientGrassmann is an optimisation methdod that keeps the MPS in left-canonical form, and treats the tensors as points on Grassmann manifolds. It then applies one of the standard gradient optimisation methods, e.g. conjugate gradient, to the MPS, making use of the Riemannian manifold structure. A preconditioner is used, so that effectively the metric used on the manifold is that given by the Hilbert space inner product.

The arguments to the constructor are method = OptimKit.ConjugateGradient The gradient optimisation method to be used. Should either be an instance or a subtype of OptimKit.OptimizationAlgorithm. If it's an instance, this method is simply used to do the optimisation. If it's a subtype, then an instance is constructed as method(; maxiter=maxiter, verbosity=verbosity, gradtol=tol)

finalize! = OptimKit._finalize! A function that gets called once each iteration. See OptimKit for details.

tol = Defaults.tol maxiter = Defaults.maxiter verbosity = 2 Arguments passed to the method constructor. If method is an instance of OptimKit.OptimizationAlgorithm, these argument are ignored.

In other words, by default conjugate gradient is used. One can easily set tol, maxiter and verbosity for it, or switch to LBFGS or gradient descent by setting method. If more control is wanted over things like specifics of the linesearch, CG flavor or the m parameter of LBFGS, then the user should create the OptimKit.OptimizationAlgorithm instance manually and pass it as method.

onesite tdvp

twosite tdvp (works for finite mps's)

PowerMethod way of finding the leading boundary mps

expands the given mps using the algorithm given in the vumps paper

use an idmrg2 step to truncate/expand the bond dimension

Truncate a given state using svd