MPSKit.jl

Appearance

Ground-state algorithms ​

Reference for the ground-state search interface and its algorithms. For a task-oriented walkthrough see the how-to guides; the full, canonical docstrings for the whole package live in the Library index.

Interface ​

MPSKit.find_groundstate Function
julia
find_groundstate(ψ₀, H, [environments]; kwargs...) -> (ψ, environments, ϵ)
find_groundstate(ψ₀, H, algorithm, [environments]) -> (ψ, environments, ϵ)

Compute the ground state for Hamiltonian H with initial guess ψ₀. If no algorithm is specified, one is selected automatically from the type of ψ₀ and the supplied keywords (see the automatic-selection notes below).

Arguments

  • ψ₀::AbstractMPS: initial guess

  • H::AbstractMPO: operator for which to find the ground state

  • [environments]: MPS environment manager

  • algorithm: optimization algorithm

Keyword Arguments

  • tol::Float64 = 1.0e-10: tolerance for the convergence criterion

  • maxiter::Int = 200: maximum number of iterations

  • verbosity::Int = 3: display progress information

  • trscheme = nothing: if supplied, a truncation scheme that enables bond-dimension growth through a two-site algorithm (see below)

Automatic algorithm selection

When no algorithm is passed, the choice depends on the type of ψ₀:

  • InfiniteMPS: VUMPS (with its tolerance floored at 1e-4), refined by GradientGrassmann when tol < 1e-4. If trscheme is given, an IDMRG2 stage is prepended to grow the bond dimension.

  • AbstractFiniteMPS: DMRG. If trscheme is given, a DMRG2 stage is prepended to grow the bond dimension.

Because single-site DMRG preserves the bond dimension of ψ₀, passing a trscheme (or an explicit two-site algorithm) is the usual way to converge from a low-bond-dimension initial guess such as a product state.

Returns

  • ψ::AbstractMPS: converged ground state

  • environments: environments corresponding to the converged state

  • ϵ::Float64: final convergence error upon terminating the algorithm

Examples

Ground state of a 4-site transverse-field Ising chain, H = -∑ XₖXₖ₊₁ - ∑ Zₖ, starting from a product state and letting DMRG2 grow the bond dimension:

julia
julia> X = TensorMap(Float64[0 1; 1 0], ℂ^2, ℂ^2);

julia> Z = TensorMap(Float64[1 0; 0 -1], ℂ^2, ℂ^2);

julia> L = 4; lattice = fill(ℂ^2, L);

julia> H = FiniteMPOHamiltonian(lattice, ((i, i + 1) => -(X ⊗ X) for i in 1:(L - 1))) +
           FiniteMPOHamiltonian(lattice, ((i,) => -Z for i in 1:L));

julia> ψ₀ = FiniteMPS(ones(Float64, (ℂ^2)^L));

julia> ψ, envs, ϵ = find_groundstate(ψ₀, H; verbosity = 0, trscheme = truncrank(16));

julia> round(real(expectation_value(ψ, H)); digits = 4)
-4.7588
source

Algorithms ​

MPSKit.DMRG Type
julia
struct DMRG{A, F, E, G} <: MPSKit.Algorithm

Density Matrix Renormalization Group algorithm for finding the dominant eigenvector.

Each site update is, in order: (1) an optional bond expansion (alg_expand), (2) a single-site eigensolve, and (3) a gauge step (alg_gauge). With the defaults (alg_expand = nothing and alg_gauge = nothing, a non-truncating QR gauge derived from trscheme = notrunc()) this is textbook single-site DMRG, which cannot change the bond dimension. Setting alg_expand to a bond-expansion algorithm (e.g. OptimalExpand, RandExpand, SketchedExpand) enriches the bond with directions orthogonal to the current state ahead of each eigensolve, recovering Controlled Bond Expansion (CBE) DMRG. Setting alg_gauge to a bond-expanding gauge algorithm (e.g. DMRG3S) instead enriches the bond as part of the gauge step, after the eigensolve. Either way, a truncating gauge (see below) is then desirable to cut the enlarged bond back down.

Choosing the gauge

By default, alg_gauge is built for you from trscheme/alg_svd/alg_orth: trscheme = notrunc() (the default) gives a QR decomposition (alg_orth, Householder by default), any other trscheme gives a truncated SVD (alg_svd with that trscheme).

julia
DMRG()                            # QR gauge, no truncation
DMRG(; trscheme = truncdim(50))   # truncated SVD gauge

To use a bond-expanding gauge such as DMRG3S, pass it directly as alg_gauge; trscheme etc. are still routed through to build the inner gauge it wraps, exactly as above:

julia
DMRG(; alg_gauge = DMRG3S(0.1, ExponentialDecay(0.7)), trscheme = truncdim(50))

If alg_gauge is instead given with its inner gauge already set (e.g. DMRG3S(0.1, sched, some_gauge)), trscheme/alg_svd/alg_orth must be left at their defaults — passing both is an error, since it leaves two conflicting sources for the same setting.

Fields

  • tol::Float64: tolerance for convergence criterium

  • maxiter::Int64: maximal amount of iterations

  • verbosity::Int64: setting for how much information is displayed

  • alg_eigsolve::Any: algorithm used for the eigenvalue solvers

  • finalize::Any: callback function applied after each iteration, of signature finalize(iter, ψ, H, envs) -> ψ, envs

  • alg_expand::Any: algorithm used to expand the bond ahead of each local update, or nothing for none

  • alg_gauge::Any: gauge algorithm applied after each local update: NoExpand for a plain gauge step (a QR algorithm with no truncation, or a truncated SVD), or an algorithm that additionally expands the bond beforehand (e.g. DMRG3S)

See also

Used as the algorithm argument of find_groundstate and approximate.

source
MPSKit.DMRG2 Type
julia
struct DMRG2{A, G, F} <: MPSKit.Algorithm

Two-site DMRG algorithm for finding the dominant eigenvector.

Fields

  • tol::Float64: tolerance for convergence criterium

  • maxiter::Int64: maximal amount of iterations

  • verbosity::Int64: setting for how much information is displayed

  • alg_eigsolve::Any: algorithm used for the eigenvalue solvers

  • alg_gauge::Any: factorization used for the post-update gauge: a truncated SVD (alg_svd with trscheme)

  • finalize::Any: callback function applied after each iteration, of signature finalize(iter, ψ, H, envs) -> ψ, envs

See also

Used as the algorithm argument of find_groundstate and approximate.

source
MPSKit.VUMPS Type
julia
struct VUMPS{F} <: MPSKit.Algorithm

Variational optimization algorithm for uniform matrix product states, based on the combination of DMRG with matrix product state tangent space concepts.

Fields

  • tol::Float64: tolerance for convergence criterium

  • maxiter::Int64: maximal amount of iterations

  • verbosity::Int64: setting for how much information is displayed

  • alg_gauge::Any: algorithm used for gauging the InfiniteMPS

  • alg_eigsolve::Any: algorithm used for the eigenvalue solvers

  • alg_environments::Any: algorithm used for the MPS environments

  • finalize::Any: callback function applied after each iteration, of signature finalize(iter, ψ, H, envs) -> ψ, envs

See also

Used as the algorithm argument of find_groundstate and leading_boundary.

References

source
MPSKit.IDMRG Type
julia
struct IDMRG{A} <: MPSKit.Algorithm

Single site infinite DMRG algorithm for finding the dominant eigenvector.

Fields

  • tol::Float64: tolerance for convergence criterium

  • maxiter::Int64: maximal amount of iterations

  • verbosity::Int64: setting for how much information is displayed

  • alg_gauge::Any: algorithm used for gauging the MPS

  • alg_eigsolve::Any: algorithm used for the eigenvalue solvers

See also

Used as the algorithm argument of find_groundstate, leading_boundary, and approximate.

source
MPSKit.IDMRG2 Type
julia
struct IDMRG2{A, S} <: MPSKit.Algorithm

Two-site infinite DMRG algorithm for finding the dominant eigenvector.

Fields

  • tol::Float64: tolerance for convergence criterium

  • maxiter::Int64: maximal amount of iterations

  • verbosity::Int64: setting for how much information is displayed

  • alg_gauge::Any: algorithm used for gauging the MPS

  • alg_eigsolve::Any: algorithm used for the eigenvalue solvers

  • alg_svd::Any: algorithm used for the singular value decomposition

  • trscheme::MatrixAlgebraKit.TruncationStrategy: algorithm used for truncation of the two-site update

See also

Used as the algorithm argument of find_groundstate, leading_boundary, and approximate.

source
MPSKit.GradientGrassmann Type
julia
struct GradientGrassmann{O<:OptimKit.OptimizationAlgorithm, F} <: MPSKit.Algorithm

Variational gradient-based optimization algorithm that keeps the MPS in left-canonical form, as points on a Grassmann manifold. The optimization is then a Riemannian gradient descent with a preconditioner to induce the metric from the Hilbert space inner product.

Constructors

julia
GradientGrassmann(; kwargs...)

Keyword Arguments

  • method = ConjugateGradient: instance of optimization algorithm, or type of optimization algorithm to construct

  • finalize!: finalizer algorithm

  • tol = Defaults.tol: tolerance for convergence criterium

  • maxiter = Defaults.maxiter: maximum amount of iterations

  • verbosity = Defaults.verbosity - 1: level of information display

Fields

  • method::OptimKit.OptimizationAlgorithm: optimization algorithm

  • finalize!::Any: callback function applied after each iteration, of signature finalize!(x, f, g, numiter) -> x, f, g

See also

Used as the algorithm argument of find_groundstate and leading_boundary.

References

source