Terms

AbstractGenerator{TS<:NamedContainer{Term}, BS<:Bonds, C<:Config, T<:Table, B<:Boundary, OS<:GenOperators}

Abstract generator.

By protocol, a concrete generator should have the following predefined contents:

• terms::TS: the terms contained in a generator
• bonds::BS: the bonds on which the terms are defined
• config::C: the configuration of the interanl degrees of freedom
• half::Bool: true for generating an Hermitian half of the operators and false for generating the whole
• table::Table: the index-sequence table
• boundary::B: boundary twist for the generated operators, nothing for no twist
• operators::OS: the generated operators

Coupling{V, I<:ID{SimpleID}} <: Element{V, I}

The coupling intra/inter interanl degrees of freedom at different lattice points.

Couplings(cps::Coupling...)

A pack of couplings intra/inter interanl degrees of freedom at different lattice points.

Alias for Elements{<:ID{SimpleID}, <:Coupling}.

GenOperators(terms::Tuple{Vararg{Term}}, bonds::Bonds, config::Config, half::Bool; table::Union{Nothing, Table}=nothing)

A set of operators. This is the core of AbstractGenerator.

Generator(terms::Tuple{Vararg{Term}}, bonds::Bonds, config::Config, half::Bool, table::Table, boundary::Boundary=plain)

A generator of operators based on terms, configuration of internal degrees of freedom, and boundary twist.

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

A NamedTuple that contain the key-value pairs.

Parameters(gen::AbstractGenerator) -> Parameters

Get the parameters of the terms of a generator.

SubID{O<:Tuple, C<:Tuple, S<:Tuple{Vararg{Int}}} <: SimpleID

The id of a subscript set.

Subscripts{DS, RS, OP<:Tuple, CP<:AbstractString, M<:Tuple{Vararg{Function}}, C<:Tuple{Vararg{Function}}} <: CompositeTuple{OP}

A subscript set of a certain internal degree of freedom.

Subscripts(N::Int)
Subscripts(opattern::Tuple{Vararg{Union{Integer, Symbol}}})
Subscripts(opattern::Tuple{Vararg{Union{Integer, Symbol}}}, cpattern::AbstractString)

Construct a subscript set of a certain internal degree of freedom.

(subscripts::Subscripts)(values::Tuple{Vararg{Int}}) -> NTuple{dimension(subscripts), Int}

Construct a subscript set from an independent variable set.

Term{K, R, I}(value, bondkind, couplings::TermCouplings, amplitude::TermAmplitude, modulate::TermModulate, factor) where {K, R, I}
Term{K, R}(id::Symbol, value, bondkind;
    couplings::Union{Function, Coupling, Couplings, TermCouplings},
    amplitude::Union{Function, TermAmplitude, Nothing}=nothing,
    modulate::Union{Function, TermModulate, Bool}=false
    ) where {ST, K, R}

A term of a quantum lattice system.

TermAmplitude(amplitude::Union{Function, Nothing}=nothing)

The function for the amplitude of a term.

TermCouplings(coupling::Coupling)
TermCouplings(couplings::Couplings)
TermCouplings(couplings::Function)

The function for the couplings of a term.

TermFunction <: Function

Abstract type for concrete term functions.

TermModulate(id::Symbol, modulate::Function)
TermModulate(id::Symbol, modulate::Bool)

The function for the modulation of a term.

@couplings cps -> Couplings

Convert an expression/literal to a set of couplings.

@subscripts expr::Expr -> Subscripts

Construct a subscript set from an opattern and optionally with a constrain.

subscripts"..." -> Subscripts

Construct a subscript set from a literal string.

*(subs₁::Subscripts, subs₂::Subscripts) -> Subscripts

Get the multiplication between two subscript sets.

+(term::Term) -> Term
-(term::Term) -> Term
*(term::Term, factor) -> Term
*(factor, term::Term) -> Term
/(term::Term, factor) -> Term

Allowed arithmetic operations for a term.

==(gen₁::AbstractGenerator, gen₂::AbstractGenerator) -> Bool

Judge whether generators are equivalent to each other.

==(genops1::GenOperators, genops2::GenOperators) -> Bool

Judge whether two sets of operators are equivalent to each other.

==(term1::Term, term2::Term) -> Bool

Judge whether two terms are equivalent to each other.

==(subs₁::Subscripts, subs₂::Subscripts) -> Bool

Judge whether two subscript sets are equivalent to each other.

eltype(ops::GenOperators)
eltype(::Type{<:GenOperators})

Get the eltype of a set of operators, which is defined to be the common operator type of all operators it contains.

empty!(ops::GenOperators) -> GenOperators

Empty a set of operators.

empty!(gen::Generator) -> Generator

Empty the :bonds, :config, :table and :operators of a generator.

empty(ops::GenOperators) -> GenOperators

Get an empty copy of a set of operators.

empty(gen::Generator) -> Generator

Get an empty copy of a generator.

isequal(gen₁::AbstractGenerator, gen₂::AbstractGenerator) -> Bool

Judge whether generators are equivalent to each other.

isequal(genops1::GenOperators, genops2::GenOperators) -> Bool

Judge whether two sets of operators are equivalent to each other.

isequal(term1::Term, term2::Term) -> Bool

Judge whether two terms are equivalent to each other.

isequal(subs₁::Subscripts, subs₂::Subscripts) -> Bool

Judge whether two subscript sets are equivalent to each other.

isvalid(subscripts::Subscripts, values::Tuple{Vararg{Int}}) -> Bool

Judge whether an independent variable set are valid to construct a subscript set.

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

Judge whether the second set of parameters matches the first.

one(term::Term) -> Term

Get a unit term.

replace(term::Term; kwargs...) -> Term

Replace some attributes of a term with key word arguments.

repr(term::Term, bond::AbstractBond, config::Config) -> String

Get the repr representation of a term on a bond with a given config.

show(io::IO, subscripts::Subscripts)

Show a subscript set.

show(io::IO, term::Term)

Show a term.

split(subscripts::Subscripts) -> Tuple{Vararg{Subscripts}}

Split a subscript set into individual independent segments.

valtype(term::Term)
valtype(::Type{<:Term)

Get the value type of a term.

zero(term::Term) -> Term

Get a zero term.

isHermitian(term::Term) -> Bool
isHermitian(::Type{<:Term}) -> Bool

abbr(term::Term) -> Symbol
abbr(::Type{<:Term}) -> Symbol

Get the abbreviation of the kind of a term.

couplingcenters(coupling::Coupling, bond::AbstractBond, info::Val) -> NTuple{rank(coupling), Int}

Get the centers of the coupling on a bond.

couplinginternals(coupling::Coupling, bond::AbstractBond, config::Config, info::Val) -> NTuple{rank(coupling), valtype(config)}

Get the interanl spaces that correspond to where each order of the coupling acts on.

couplingpoints(coupling::Coupling, bond::AbstractBond, info::Val) -> NTuple{rank(coupling), eltype(bond)}

Get the points that correspond to where each order of the coupling acts on.

ismodulatable(term::Term) -> Bool
ismodulatable(::Type{<:Term}) -> Bool

Judge whether a term could be modulated by its modulate function.

otype(T::Type{<:Term}, C::Type{<:Config}, B::Type{<:AbstractBond})

Get the compatible operator type from the type of a term, a configuration of the internal degrees of freedom and a bond.

otype(gen::AbstractGenerator)
otype(::Type{<:AbstractGenerator})

Get the operator type of the generated opeators.

kind(term::Term) -> Symbol
kind(::Type{<:Term) -> Symbol

Get the kind of a term.

reset!(genops::GenOperators, terms::Tuple{Vararg{Term}}, bonds::Bonds, config::Config, half::Bool; table::Union{Nothing, Table}=nothing) -> GenOperators

Reset a set of operators by new terms, bonds, config, etc..

reset!(gen::Generator, lattice::AbstractLattice) -> Generator

Reset a generator by a new lattice.

update!(term::Term, args...; kwargs...) -> Term

Update the value of a term by its modulate function.

update!(gen::AbstractGenerator; kwargs...) -> typeof(gen)

Update the coefficients of the terms in a generator.

dimension(subscripts::Subscripts, i::Int) -> Int
dimension(::Type{<:Subscripts}, i::Int) -> Int

Get the total number of the whole variables of the ith segment of a subscript set.

dimension(subscripts::Subscripts) -> Int
dimension(::Type{<:Subscripts}) -> Int

Get the total number of the whole variables of a subscript set.

expand(term::Term, bond::AbstractBond, config::Config, half::Bool=false; table::Union{Nothing, Table}=nothing) -> Operators
expand(term::Term, bonds::Bonds, config::Config, half::Bool=false; table::Union{Nothing, Table}=nothing) -> Operators

Expand the operators of a term on a bond/set-of-bonds with a given config.

expand!(operators::Operators, term::Term, bond::AbstractBond, config::Config, half::Bool=false; table::Union{Nothing, Table}=nothing) -> Operators
expand!(operators::Operators, term::Term, bonds::Bonds, config::Config, half::Bool=false; table::Union{Nothing, Table}=nothing) -> Operators

Expand the operators of a term on a bond/set-of-bonds with a given config.

The half parameter determines the behavior of generating operators, which falls into the following two categories

• true: "Hermitian half" of the generated operators
• false: "Hermitian whole" of the generated operators

expand!(operators::Operators, gen::AbstractGenerator) -> Operators

Expand the operators of a generator.

expand!(operators::Operators, ops::GenOperators, boundary::Boundary; kwargs...) -> Operators

Expand the operators with the given boundary twist and term coefficients.

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

Expand the operators of a generator:

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

expand(subscripts::Subscripts, dimensions::Tuple{Vararg{Int}}) -> SbExpand

Expand a subscript set with the given variable ranges.

id(term::Term) -> Symbol
id(::Type{<:Term) -> Symbol

Get the id of a term.

id(subs::Subscripts) -> SubID

Get the id of a subscript set.

rank(subscripts::Subscripts, i::Int) -> Int
rank(::Type{<:Subscripts}, i::Int) -> Int

Get the number of the independent variables of the ith segment of a subscript set.

rank(subscripts::Subscripts) -> Int
rank(::Type{<:Subscripts}) -> Int

Get the total number of the independent variables of a subscript set.

rank(term::Term) -> Int
rank(::Type{<:Term) -> Int

Get the rank of a term.

idtype(ops::GenOperators)
idtype(::Type{<:GenOperators})

Get the idtype of a set of operators, which is defined to be the common idtype of all operators it contains.