Library documentation

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

Represents a dense periodic mpo

MPOHamiltonian

represents a general periodic quantum hamiltonian

really just a sparsempo, with some garantuees on its structure

Abstract environment for an infinite state

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

if above is set to nothing, above === below.

opp can be a vector of nothing, in which case it'll just be the overlap

calculates the expectation value of op, where op is a plain tensormap where the first index works on site at

calculates the expectation value of op = op1op2op3*... (ie an N site operator) starting at site at

calculates the expectation value for the given operator/hamiltonian

function timestep(psi, operator, dt, alg,envs = environments(psi,operator))

time evolves psi by timestep dt using algorithm alg

leading_boundary(state,opp,alg,envs=environments(state,ham))

approximate the leading eigenvector for opp

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

excitations(H, alg::QuasiparticleAnsatz, args...; kwargs...)

Compute the first excited states and their energy gap above a groundstate.

This is an implementation of the algorithm found here.

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.

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

expands the bond dimension by adding random unitary vectors

Truncate a given state using svd