MPSKit.jl

Appearance

States ​

Reference for the matrix product state types. The full, canonical docstrings for the whole package live in the Library index.

Matrix product states ​

MPSKit.FiniteMPS Type
julia
struct FiniteMPS{A<:(TensorKit.AbstractTensorMap{T, S, N, 1} where {S, N, T}), B<:(TensorKit.AbstractTensorMap{T, S, 1, 1} where {S, T})} <: MPSKit.AbstractFiniteMPS

Type that represents a finite Matrix Product State.

Constructors

julia
FiniteMPS([f, eltype], physicalspaces::Vector{<:Union{S, CompositeSpace{S}}},
          maxvirtualspaces::Union{S, Vector{S}};
          normalize = true, left = unitspace(S), right = unitspace(S)) where {S <: ElementarySpace}
FiniteMPS([f, eltype], N::Int, physicalspace::Union{S, CompositeSpace{S}},
          maxvirtualspaces::Union{S, Vector{S}};
          normalize = true, left = unitspace(S), right = unitspace(S)) where {S <: ElementarySpace}
FiniteMPS(As::Vector{<:GenericMPSTensor}; normalize = false, overwrite = false)

Construct an MPS via a specification of physical and virtual spaces, or from a list of tensors As. All cases reduce to the latter. In particular, a state with a non-trivial total charge can be constructed by passing a non-trivially charged vector space as the left or right virtual spaces.

Arguments

  • As: vector of site tensors

  • f = rand: initializer function for the tensor data

  • eltype = ComplexF64: scalar type of the tensors

  • physicalspaces: list of physical spaces

  • N: number of sites

  • physicalspace: local physical space, repeated for every site

  • maxvirtualspaces: maximal virtual space(s), truncated to what symmetry allows

Keyword Arguments

  • normalize: normalize the constructed state

  • overwrite = false: overwrite the given input tensors

  • left = unitspace(S): left-most virtual space

  • right = unitspace(S): right-most virtual space

Properties

  • AL: left-gauged MPS tensors

  • AR: right-gauged MPS tensors

  • AC: center-gauged MPS tensors

  • C: gauge (bond) tensors

  • center: location of the gauge center

The center property returns a center::HalfInt that indicates the location of the MPS center:

  • isinteger(center) → center is a whole number and indicates the location of the first AC tensor present in the underlying ψ.ACs field.

  • ishalfodd(center) → center is a half-odd-integer, meaning that there are no AC tensors, and indicating between which sites the bond tensor lives.

For example, mps.center = 7/2 means that the bond tensor is to the right of the 3rd site and can be accessed via mps.C[3].

Notes

By convention, we have that:

  • AL[i] * C[i] = AC[i] = C[i-1] * AR[i]

  • AL[i]' * AL[i] = 1

  • AR[i] * AR[i]' = 1

source
MPSKit.InfiniteMPS Type
julia
struct InfiniteMPS{A<:(TensorKit.AbstractTensorMap{T, S, N, 1} where {S, N, T}), B<:(TensorKit.AbstractTensorMap{T, S, 1, 1} where {S, T})} <: MPSKit.AbstractMPS

Type that represents an infinite Matrix Product State.

Constructors

julia
InfiniteMPS([f, eltype], physicalspaces::Vector{<:Union{S, CompositeSpace{S}}},
            virtualspaces::Vector{<:Union{S, CompositeSpace{S}}};
            kwargs...) where {S <: ElementarySpace}
InfiniteMPS(As::AbstractVector{<:GenericMPSTensor}; kwargs...)
InfiniteMPS(ALs::AbstractVector{<:GenericMPSTensor}, C₀::MPSBondTensor; kwargs...)

Construct an MPS via a specification of physical and virtual spaces, or from a list of tensors As, or a list of left-gauged tensors ALs.

Arguments

  • As: vector of site tensors

  • ALs: vector of left-gauged site tensors

  • C₀: initial gauge tensor

  • f = rand: initializer function for the tensor data

  • eltype = ComplexF64: scalar type of the tensors

  • physicalspaces: list of physical spaces

  • virtualspaces: list of virtual spaces

Keyword Arguments

  • tol: gauge fixing tolerance

  • maxiter: gauge fixing maximum iterations

Properties

  • AL: left-gauged MPS tensors

  • AR: right-gauged MPS tensors

  • AC: center-gauged MPS tensors

  • C: gauge (bond) tensors

Notes

By convention, we have that:

  • AL[i] * C[i] = AC[i] = C[i-1] * AR[i]

  • AL[i]' * AL[i] = 1

  • AR[i] * AR[i]' = 1

source
MPSKit.WindowMPS Type
julia
struct WindowMPS{A<:(TensorKit.AbstractTensorMap{T, S, N, 1} where {S, N, T}), B<:(TensorKit.AbstractTensorMap{T, S, 1, 1} where {S, T})} <: MPSKit.AbstractFiniteMPS

Type that represents a finite Matrix Product State embedded in an infinite Matrix Product State.

Constructors

julia
WindowMPS(left_gs::InfiniteMPS, window_state::FiniteMPS, [right_gs::InfiniteMPS])
WindowMPS(left_gs::InfiniteMPS, window_tensors::AbstractVector, [right_gs::InfiniteMPS])
WindowMPS([f, eltype], physicalspaces::Vector{<:Union{S, CompositeSpace{S}}},
          virtualspaces::Vector{<:Union{S, CompositeSpace{S}}}, left_gs::InfiniteMPS,
          [right_gs::InfiniteMPS])
WindowMPS([f, eltype], physicalspaces::Vector{<:Union{S, CompositeSpace{S}}},
          maxvirtualspace::S, left_gs::InfiniteMPS, [right_gs::InfiniteMPS])
WindowMPS(ψ::InfiniteMPS, L::Int)

Construct a WindowMPS via a specification of left and right infinite environment, and either a window state or a vector of tensors to construct the window. Alternatively, it is possible to supply the same arguments as for the constructor of FiniteMPS, followed by a left (and right) environment to construct the WindowMPS in one step. Finally, a WindowMPS can be constructed from an InfiniteMPS by promoting a region of length L to a FiniteMPS.

Note

By default, the right environment is chosen to be equal to the left, however no copy is made. In this case, changing the left state will also affect the right state.

Properties

  • left_gs::InfiniteMPS: left infinite environment

  • window::FiniteMPS: finite window Matrix Product State

  • right_gs::InfiniteMPS: right infinite environment

  • AL: left-gauged MPS tensors

  • AR: right-gauged MPS tensors

  • AC: center-gauged MPS tensors

  • C: gauge (bond) tensors

source
MPSKit.MultilineMPS Type
julia
const MultilineMPS = Multiline{<:InfiniteMPS}

Type that represents multiple lines of InfiniteMPS objects.

Constructors

julia
MultilineMPS(mpss::AbstractVector{<:InfiniteMPS})
MultilineMPS([f, eltype], physicalspaces::Matrix{<:Union{S, CompositeSpace{S}}},
             virtualspaces::Matrix{<:Union{S, CompositeSpace{S}}}) where {S <: ElementarySpace}
MultilineMPS(As::AbstractMatrix{<:GenericMPSTensor}; kwargs...)
MultilineMPS(ALs::AbstractMatrix{<:GenericMPSTensor},
             C₀::AbstractVector{<:MPSBondTensor}; kwargs...)

Properties

  • AL: left-gauged MPS tensors

  • AR: right-gauged MPS tensors

  • AC: center-gauged MPS tensors

  • C: gauge (bond) tensors

See also

Multiline

source

Quasiparticle states ​

Excitation ansätze produced by excitations. These behave as vectors and are normally obtained from excitations rather than constructed directly.

MPSKit.QP Type
julia
QP{S, T1, T2}

Union of the quasiparticle excitation ansätze LeftGaugedQP and RightGaugedQP. It is used for dispatch and to share their gauge-independent interface; it is not a concrete type and cannot be constructed on its own. The internal aliases FiniteQP and InfiniteQP further restrict the ground-state type to FiniteMPS or InfiniteMPS respectively.

source
MPSKit.LeftGaugedQP Type
julia
struct LeftGaugedQP{S, T1, T2, E<:Number}

Left-gauged quasiparticle excitation ansatz on top of a matrix product state ground state. The excitation is parametrized through the left-gauge nullspace of the ground-state tensors, and the object behaves as a vector so it can be handed directly to the iterative eigensolvers used by excitations.

For a FiniteMPS ground state this represents a finite (localized) quasiparticle; for an InfiniteMPS ground state it represents a momentum eigenstate with the given momentum. When left_gs !== right_gs the ansatz describes a domain wall between the two ground states.

Constructors

julia
LeftGaugedQP(datfun, left_gs, right_gs = left_gs; sector, momentum = 0.0)

These states are normally produced by excitations with a QuasiparticleAnsatz rather than constructed directly. When constructing manually, datfun initializes the variational tensors (e.g. rand/randn), sector selects the charge sector of the excitation, and momentum sets the momentum for infinite ground states.

Fields

  • left_gs, right_gs: the ground state(s) the excitation lives on; distinct values yield a domain wall.

  • VLs: left-nullspace tensors of the ground-state AL (satisfying AL' * VL == 0).

  • Xs: the variational parameters of the ansatz.

  • momentum: the excitation momentum (used for infinite ground states).

See also

RightGaugedQP, QP

source
MPSKit.RightGaugedQP Type
julia
struct RightGaugedQP{S, T1, T2, E<:Number}

Right-gauged counterpart of LeftGaugedQP: the same quasiparticle excitation ansatz, but parametrized through the right-gauge nullspace of the ground-state tensors. It is most often obtained via convert(RightGaugedQP, ϕ) from a LeftGaugedQP rather than constructed directly.

Constructors

julia
RightGaugedQP(datfun, left_gs, right_gs = left_gs; sector, momentum = 0.0)

Fields

  • left_gs, right_gs: the ground state(s) the excitation lives on; distinct values yield a domain wall.

  • Xs: the variational parameters of the ansatz.

  • VRs: right-nullspace tensors of the ground-state AR.

  • momentum: the excitation momentum (used for infinite ground states).

See also

LeftGaugedQP, QP

source