Frameworks

const eager = Eager()

Singleton instance of Eager.

const lazy = Lazy()

Singleton instance of Lazy.

Tuple(data::Data)

Convert Data to Tuple.

Action

Abstract type for all actions.

Algorithm(name::Symbol, frontend::Frontend, parameters::Parameters=Parameters(frontend), map::Function=identity; dir::String=".", timer::TimerOutput=TimerOutput())

Construct an algorithm.

Algorithm{F<:Frontend, P<:Parameters, M<:Function} <: LatticeModel

An algorithm associated with a frontend.

(alg::Algorithm)(assign::Assignment, checkoptions::Bool=true; options...) -> Assignment
(assign::Assignment)(alg::Algorithm, checkoptions::Bool=true; options...) -> Assignment

Run an assignment based on an algorithm.

The difference between these two methods is that the first uses the parameters of assign as the current parameters while the second uses those of alg.

(alg::Algorithm)(name::Symbol, action::Action, dependencies::ZeroOrMore{Assignment}; dir::String=alg.dir, delay::Bool=false, options...) -> Assignment
(alg::Algorithm)(name::Symbol, action::Action, parameters::Parameters, dependencies::ZeroOrMore{Assignment}; dir::String=alg.dir, delay::Bool=false, options...) -> Assignment
(alg::Algorithm)(name::Symbol, action::Action, parameters::Parameters=Parameters(), map::Function=identity, dependencies::ZeroOrMore{Assignment}=(); dir::String=alg.dir, delay::Bool=false, options...) -> Assignment

Add an assignment on an algorithm by providing the contents of the assignment, and run this assignment.

Assignment{A<:Action, P<:Parameters, M<:Function, T<:Tuple, D<:Data} <: LatticeModel

An assignment associated with an action.

Boundary{Names}(values::AbstractVector{<:Number}, vectors::AbstractVector{<:AbstractVector{<:Number}}) where Names

Boundary twist of operators.

(bound::Boundary)(operator::Operator; origin::Union{AbstractVector, Nothing}=nothing) -> Operator

Get the boundary twisted operator.

CategorizedGenerator{V, C, A<:NamedTuple, B<:NamedTuple, P<:Parameters, D<:Boundary} <: ParametricGenerator{V}

Parameterized generator that groups the (representations of) quantum operators in a quantum lattice system into three categories, i.e., the constant, the alterable, and the boundary.

Data

Abstract type for the data of an action.

Eager <: ExpansionStyle

Eager expansion style with eager computation so that similar terms are combined in the final result.

ExpansionStyle

Expansion style of a generator of (representations of) quantum operators. It has two singleton subtypes, Eager and Lazy.

Formula{V, F<:Function, P<:Parameters}

Representation of a quantum lattice system with an explicit analytical formula.

(formula::Formula)(args...; kwargs...) -> valtype(formula)

Get the result of a Formula.

Frontend <: LatticeModel

Frontend of algorithms applied to a quantum lattice system.

Generator{V} <: LatticeModel

Abstract supertype for lattice models that are represented by generators of operators.

It has three branches: StaticGenerator, and ParametricGenerator (which includes CategorizedGenerator and OperatorGenerator).

Generator also serves as a constructor factory, dispatching to the appropriate concrete subtype based on the arguments.

Generator(ops::OperatorSet) -> StaticGenerator
Generator(constops, alterops::NamedTuple, boundops::NamedTuple, parameters::Parameters, boundary::Boundary) -> CategorizedGenerator
Generator(ops::CategorizedGenerator{<:Operators}, bonds::Vector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, half::Bool) -> OperatorGenerator
Generator(bonds::Vector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, boundary::Boundary=plain; half::Bool=false) -> OperatorGenerator

Factory constructor for Generator subtypes.

Dispatches on the argument types to construct the appropriate concrete representation. Unlike LatticeModel, this factory only constructs Generator subtypes (not Formula).

LatticeModel

Abstract supertype for all representations of a quantum lattice system.

Subtypes must implement valtype. Parameters and update! should also be implemented as applicable.

LatticeModel(expression::Function, parameters::Parameters) -> Formula
LatticeModel(ops::OperatorSet) -> StaticGenerator
LatticeModel(constops, alterops::NamedTuple, boundops::NamedTuple, parameters::Parameters, boundary::Boundary) -> CategorizedGenerator
LatticeModel(ops::CategorizedGenerator{<:Operators}, bonds::Vector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, half::Bool) -> OperatorGenerator
LatticeModel(bonds::Vector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, boundary::Boundary=plain; half::Bool=false) -> OperatorGenerator

Unified factory constructor for LatticeModel subtypes.

Dispatches on the argument types to construct the appropriate concrete representation. Frontend subtypes and Algorithm are not constructed via this factory.

Lazy <: ExpansionStyle

Lazy expansion style with lazy computation so that similar terms are not combined in the final result.

OperatorGenerator{V<:Operators, CG<:CategorizedGenerator{V}, B<:Bond, H<:Hilbert, TS<:ZeroAtLeast{Term}} <: ParametricGenerator{V}

A generator of operators based on the terms, bonds and Hilbert space of a quantum lattice system.

OperatorGenerator(bonds::Vector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, boundary::Boundary=plain; half::Bool=false)

Construct a generator of quantum operators based on the input bonds, Hilbert space, terms and (twisted) boundary condition.

When the boundary condition is plain, the boundary operators will be set to be empty for simplicity and efficiency.

Parameters{Names}(values::Number...) where Names

A NamedTuple that contains the key-value pairs.

Parameters(bound::Boundary)

Get the parameters of the twisted boundary condition.

Parameters(cat::CategorizedGenerator)

Get the complete set of parameters of a categorized generator of (representations of) quantum operators.

Parameters(model::LatticeModel) -> NamedTuple

Get the parameters of a lattice model.

Returns model.parameters if the type has a :parameters field, otherwise an empty NamedTuple.

Parameters(gen::OperatorGenerator) -> Parameters

Get the parameters of an OperatorGenerator.

ParametricGenerator{V} <: Generator{V}

Abstract supertype for generators that carry parameters and support update!.

Its concrete subtypes are CategorizedGenerator and OperatorGenerator.

StaticGenerator{M<:OperatorSet} <: Generator{M}

A LatticeModel that wraps a static OperatorSet.

Unlike ParametricGenerator, the operators have no parameter-update mechanism — they are treated as a fixed set.

(transformation::LinearTransformation)(cat::CategorizedGenerator; kwargs...) -> CategorizedGenerator

Apply a linear transformation to a categorized generator of (representations of) quantum operators.

(transformation::LinearTransformation)(gen::OperatorGenerator; kwargs...) -> CategorizedGenerator

Get the transformation applied to a generator of quantum operators.

(transformation::LinearTransformation)(gen::StaticGenerator; kwargs...) -> StaticGenerator

Apply a linear transformation to a static generator of (representations of) quantum operators.

basename(model::LatticeModel, target::Symbol=:void; prefix::String="", suffix::String="") -> String

Get the basename of a lattice model file, formed as "prefix-string(model)-suffix.ext".

• target::Symbol: :data → .qld, :cache → .qlc, :void (default) → no extension.
• prefix, suffix: prepended/appended to the base name. The separator "-" is omitted when the corresponding part is empty.

dirname(model::LatticeModel) -> String

Get the dirname of the data/cache file of a lattice model.

Defaults to "." if the type has no dir field.

eltype(model::LatticeModel)
eltype(::Type{T}) where {T<:LatticeModel}

Get the eltype of a LatticeModel.

empty(cat::CategorizedGenerator) -> CategorizedGenerator
empty!(cat::CategorizedGenerator) -> CategorizedGenerator

Get an empty copy of a categorized generator or empty a categorized generator of (representations of) quantum operators.

empty(gen::OperatorGenerator) -> OperatorGenerator
empty!(gen::OperatorGenerator) -> OperatorGenerator

Get an empty copy of or empty an operator generator.

empty(gen::StaticGenerator) -> StaticGenerator
empty!(gen::StaticGenerator) -> StaticGenerator

Get an empty copy of a static generator or empty it in place.

isempty(gen::Generator) -> Bool

Judge whether a Generator is empty after lazy expansion.

iterate(gen::Generator)
iterate(::Generator, state)

Iterate over a Generator lazily.

keys(bound::Boundary) -> ZeroAtLeast{Symbol}
keys(::Type{<:Boundary{Names}}) where Names -> Names

Get the names of the boundary parameters.

length(gen::Generator) -> Int

Get the number of operators after lazy expansion.

match(params₁::Parameters, params₂::Parameters; atol=atol, rtol=rtol) -> Bool

Judge whether the second set of parameters matches the first.

merge!(bound::Boundary, another::Boundary) -> typeof(bound)

Merge the values and vectors of the twisted boundary condition from another one.

pathof(model::LatticeModel, target::Symbol; prefix::String="", suffix::String="") -> String

Get the full path of a lattice model file.

Equivalent to joinpath(dirname(model), basename(model, target; prefix, suffix)).

show(io::IO, alg::Algorithm)

Show an algorithm.

show(io::IO, assign::Assignment)

Show an assignment.

summary(alg::Algorithm)

Provide a summary of an algorithm.

valtype(model::LatticeModel)
valtype(::Type{<:LatticeModel})

Get the valtype of a LatticeModel. Subtypes must implement the type-level method.

checkoptions(::Type{A}; options...) where {A<:Assignment}

Check whether the keyword arguments are legal options of a certain type of Assignment.

config(alg::Algorithm) -> String

Get the configuration label of an algorithm, inherited from its frontend.

config(model::LatticeModel) -> String

Get the configuration fingerprint: the SHA-512 digest of contenttoconfig.

contenttocache(model::LatticeModel) -> NamedTuple

Return the cacheable content of a lattice model as a NamedTuple.

Returns an empty NamedTuple by default. Subtypes should override this to specify what should be cached.

contenttoconfig(model::LatticeModel) -> Tuple

Return the structural components that characterize a lattice model.

Together with Parameters, these components determine the model's identity. Defaults to an empty Tuple. Subtypes should override this to specify which structural components to include.

datatype(::Type{A}, ::Type{F}) where {A<:Action, F<:Frontend}

Get the concrete subtype of Data according to the types of an Action and a Frontend.

hasoption(::Type{A}, option::Symbol) where {A<:Assignment} -> Bool

Judge whether a certain type of Assignment has an option.

options(::Type{<:Assignment}) -> NamedTuple

Get the options of a certain type of Assignment.

optionsinfo(::Type{A}; level::Int=1) where {A<:Assignment} -> String

Get the complete info of the options of a certain type of Assignment, including that of its dependencies.

plain

Plain boundary condition without any twist.

qlcclean(dir::String="."; kwargs...) -> Int

Shortcut for qlclean(:cache, dir; kwargs...).

qlclean(filename::String; age::Real=Inf, maxcount::Int=typemax(Int)) -> Int
qlclean(target::Symbol, dir::String="."; age::Real=Inf, maxcount::Int=typemax(Int)) -> Int

Clean up entries in qld/qlc files.

• filename: clean a single file.
• target=:data/:cache: clean all .qld/.qlc files in dir.
• age: delete entries whose touchtime is older than age seconds (default Inf).
• maxcount: keep at most maxcount most recent entries per file (default typemax(Int)).

Files that become empty after cleaning are removed. Returns the number of entries deleted.

qlcsave(model::LatticeModel, models::LatticeModel...; kwargs...) -> String

Shortcut for qlsave(:cache, model, models...; kwargs...).

qldclean(dir::String="."; kwargs...) -> Int

Shortcut for qlclean(:data, dir; kwargs...).

qldsave(model::LatticeModel, models::LatticeModel...; kwargs...) -> String

Shortcut for qlsave(:data, model, models...; kwargs...).

qlload(filename::String) -> Dict{String, Any}
qlload(filename::String, name::String) -> Any
qlload(filename::String, name₁::String, name₂::String, names::String...) -> Tuple

Load data from a qld/qlc file.

With a single filename argument, returns all entries as a flat Dict. With a key, returns that single entry. With multiple keys, returns a Tuple.

qlsave(filename::String, args...)

Save arbitrary data as key-value pairs to a file.

If the file does not exist, it is created. If a key already exists, it is replaced.

qlsave(target::Symbol, model::LatticeModel, models::LatticeModel...; prefix::String="", suffix::String="", ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="")

Save lattice models to data (.qld) or cache (.qlc) files.

• target::Symbol: :data or :cache.
• prefix, suffix: passed to pathof → basename.
• ndecimal, select, front, rear: passed to stamp → str(::Parameters).

run!(alg::Algorithm, assign::Assignment; options...)

Run an assignment based on an algorithm.

stamp(model::LatticeModel; ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="") -> String

Generate a deterministic stamp for a lattice model, formed as "config[-parameters]".

The stamp serves as the internal key in data/cache files. ndecimal, select, front, and rear are passed to str(::Parameters). When str(::Parameters) returns an empty string, the intermediate "-" is omitted.

scalartype(model::LatticeModel)
scalartype(::Type{T}) where {T<:LatticeModel}

Get the scalar type of a LatticeModel.

dlmsave(assignment::Assignment, delim='	'; prefix::String="", suffix::String="", ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="")

Save the data of an assignment to a delimited file.

expand!(result, gen::Generator) -> typeof(result)

Expand the generator lazily and add the operators to result.

expand(gen::Generator) -> valtype(gen)
expand(gen::Generator, ::Eager) -> valtype(gen)
expand(gen::Generator, ::Lazy) -> valtype(gen)

Expand a Generator. Defaults to eager expansion which combines similar terms; pass lazy to preserve separate terms.

Subtypes must implement expand(gen, ::Lazy).

expand(gen::OperatorGenerator, name::Symbol) -> Operators
expand(gen::OperatorGenerator, i::Int) -> Operators
expand(gen::OperatorGenerator, name::Symbol, i::Int) -> Operators

Expand an operator generator to get:

1. the operators of a specific term;
2. the operators on a specific bond;
3. the operators of a specific term on a specific bond.

reset!(bound::Boundary, values::AbstractVector{<:Number}) -> Boundary
reset!(bound::Boundary, vectors::AbstractVector{<:AbstractVector{<:Number}}) -> Boundary
reset!(bound::Boundary, values::AbstractVector{<:Number}, vectors::AbstractVector{<:AbstractVector{<:Number}}) -> Boundary

Reset the values or vectors of a twisted boundary condition in-place.

reset!(cat::CategorizedGenerator, transformation::LinearTransformation, source::CategorizedGenerator; kwargs...)

Reset a categorized generator by its source categorized generator of (representations of) quantum operators and the corresponding linear transformation.

reset!(cat::CategorizedGenerator, transformation::LinearTransformation, source::OperatorGenerator; kwargs...)

Reset a categorized generator by its source operator generator of (representations of) quantum operators and the corresponding linear transformation.

reset!(gen::OperatorGenerator, bonds::AbstractVector{<:Bond}, hilbert::Hilbert; vectors::AbstractVector{<:AbstractVector}=gen.operators.boundary.vectors) -> OperatorGenerator

Reset an operator generator by a new lattice and the corresponding hilbert space.

reset!(gen::StaticGenerator, transformation::LinearTransformation, source::StaticGenerator; kwargs...) -> StaticGenerator

Reset a static generator from a source by applying the linear transformation to the source operators.

str(model::LatticeModel; prefix::String="", suffix::String="", ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="") -> String

Get the string representation of a lattice model, formed as basename[-parameters].

• prefix and suffix: passed to basename(::LatticeModel).
• ndecimal, select, front, rear: passed to str(::Parameters).

str(params::Parameters; ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="") -> String

Convert a set of Parameters to a string of the form "front-name₁(value₁)name₂(value₂)-rear".

Each parameter nameᵢ(valueᵢ) is included only when select(nameᵢ) returns true. Numeric values are rounded to ndecimal decimal places. If front or rear is empty, the leading/trailing "-" is omitted.

update!(action::Action; parameters...) -> Action

Update the parameters of an action.

update!(alg::Algorithm; parameters...) -> Algorithm

Update the parameters of an algorithm and its associated frontend.

update!(assign::Assignment; parameters...) -> Assignment

Update the parameters of an assignment and the status of its associated action.

update!(bound::Boundary; parameters...) -> Boundary

Update the values of the boundary twisted phase.

update!(cat::CategorizedGenerator, transformation::LinearTransformation, source::CategorizedGenerator; kwargs...) -> CategorizedGenerator

Update the parameters (including the boundary parameters) of a categorized generator based on its source categorized generator of (representations of) quantum operators and the corresponding linear transformation.

!!! Note The coefficients of boundops are also updated due to the change of the boundary parameters.

update!(cat::CategorizedGenerator, transformation::LinearTransformation, source::OperatorGenerator; kwargs...) -> CategorizedGenerator

Update the parameters (including the boundary parameters) of a categorized generator based on its source operator generator of (representations of) quantum operators and the corresponding linear transformation.

!!! Note The coefficients of boundops are also updated due to the change of the boundary parameters.

update!(cat::CategorizedGenerator{<:OperatorSum}; parameters...) -> CategorizedGenerator

Update the parameters (including the boundary parameters) of a categorized generator of (representations of) quantum operators.

!!! Note The coefficients of boundops are also updated due to the change of the boundary parameters.

update!(formula::Formula; parameters...) -> Formula

Update the parameters of a Formula in place and return itself after update.

update!(gen::OperatorGenerator; parameters...) -> typeof(gen)

Update the coefficients of the terms in a generator.

update!(gen::StaticGenerator, transformation::LinearTransformation, source::StaticGenerator; kwargs...) -> StaticGenerator

Update the parameters of a static generator from a source. Since a static generator has no parameters, this is a no-op that returns the generator unchanged.

update!(gen::StaticGenerator; parameters...) -> StaticGenerator

Update the parameters of a static generator. Since a static generator has no parameters, this is a no-op that returns the generator unchanged.

update(params::NamedTuple; parameters...) -> Parameters

Update a set of Parameters and return the updated one.