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.

(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.

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)(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, N, D<:Data} <: Function

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(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.

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.

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

A NamedTuple that contains the key-value pairs.

Parameters(algorithm::Algorithm)

Get the parameters of an algorithm.

Parameters(assignment::Assignment) -> Parameters

Get the parameters of an assignment.

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(formula::Formula) -> Parameters

Get the parameters of a Formula.

Parameters(gen::OperatorGenerator) -> Parameters

Get the parameters of an OperatorGenerator.

Parameters(gen::StaticGenerator) -> Parameters

Get the parameters of a static generator, which are always empty.

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(obj::Union{Assignment, Algorithm}; prefix::String="", suffix::String="", extension::String="qld") -> String

Get the basename of the data file of an assignment/algorithm.

dirname(obj::Union{Assignment, Algorithm}) -> String

Get the dirname of the data file of an assignment/algorithm.

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(obj::Union{Assignment, Algorithm}; prefix::String="", suffix::String="", extension::String="qld") -> String

Get the path of the data file of an assignment/algorithm.

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

Show an algorithm.

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

Show an assignment.

show(io::IO, ::MIME"text/plain", alg::Algorithm)

Show an algorithm.

Optionally, some parameters of the algorithm can be filtered by specifying the :select context in io. Besides, the maximum number of decimals of the parameters can also be specified by the :ndecimal context in io.

show(io::IO, ::MIME"text/plain", assign::Assignment)

Show an assignment.

Optionally, some parameters of the algorithm can be filtered by specifying the :select context in io. Besides, the maximum number of decimals of the parameters can also be specified by the :ndecimal context in io.

summary(alg::Algorithm)

Provide a summary of an algorithm.

valtype(assign::Assignment)
valtype(::Type{<:Assignment})

Type of the data (result) of an assignment.

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.

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.

fingerprint(obj; ndecimal::Int=10) -> String

Generate a deterministic string fingerprint for an object, combining the string representation of id(obj) with that of Parameters(obj) (with numeric values rounded to ndecimal digits). When id(obj)/Parameters(obj) are not defined, the type name and an empty parameter list are used as fallbacks respectively.

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.

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

Load data from a qld 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.

qldsave(filename::String, args...; mode::String="a+")

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

qldsave(obj::Union{Assignment, Algorithm}, objs::Union{Assignment, Algorithm}...; mode::String="a+", prefix::String="", suffix::String="", ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="")

Save a series of assignments/algorithms to qld files.

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

Run an assignment based on an algorithm.

seriestype(data::Data) -> Union{Symbol, Nothing}

Determine the plot seriestype for data. Returns :path, :heatmap, or nothing.

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.

id(obj::Union{Assignment, Algorithm})

Get the identifier of an assignment/algorithm.

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(params::Parameters; ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="") -> String

Convert a set of Parameters to a string with each number rounded to at most ndecimal decimal places. The select function can be used to filter which key-value pairs to include.

str(obj::Union{Assignment, Algorithm}; prefix::String="", suffix::String="", ndecimal::Int=10, select::Function=name::Symbol->true, front::String="", rear::String="") -> String

Get the string representation of an assignment/algorithm.

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.