Degrees of freedom

AbstractCompositeIndex{I<:Index} <: OperatorUnit

The abstract type of a composite index.

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.

Component{T₁, T₂} <: VectorSpace{Tuple{T₁, T₁, T₂}}

A component of a MatrixCoupling, i.e., a matrix acting on a separated internal space.

CompositeIID{T<:Tuple{Vararg{SimpleIID}}} <: IID

The composition of several single internal ids.

CompositeIID(contents::SimpleIID...)

Construct a composite iid from a set of simple iids.

CompositeIndex{I<:Index, V<:SVector} <: AbstractCompositeIndex{I}

Composite index of a quantum operator.

CompositeIndex(index::Index, rcoordinate, icoordinate)
CompositeIndex(index::Index; rcoordinate, icoordinate)

Construct an operator id.

CompositeInternal{K, T<:Tuple{Vararg{SimpleInternal}}} <: Internal{IID}

The composition of several single internal spaces.

CompositeInternal{K}(contents::SimpleInternal...) where K

Construct a composite internal space from a set of simple internal spaces.

Constraint{RS, N, C<:NTuple{N, Function}}

The constraint of the indexes of internal degrees of freedom in a coupling.

Constraint(indexes::Index...)
Constraint(indexes::NTuple{N, Index}) where N

Construct a constraint based on the pattern of the input indexes.

Constraint{R}() where R
Constraint{R}(condition::Union{Pattern, Diagonal}) where R
Constraint{R}(representation::String, condition::Function) where R

Construct a constraint with only one condition.

Coupling{V, I<:ID{Index}, C<:Constraint} <: OperatorPack{V, Tuple{I, C}}

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

Coupling(indexes::Index...)
Coupling(value, indexes::Index...)
Coupling(value, indexes::Tuple{Vararg{Index}})

Construct a Coupling with the input indexes as the pattern.

Coupling(sites::Union{NTuple{N, Int}, Colon}, ::Type{I}, fields::Union{NTuple{N}, Colon}...) where {N, I<:SimpleIID}
Coupling(value, sites::Union{NTuple{N, Int}, Colon}, ::Type{I}, fields::Union{NTuple{N}, Colon}...) where {N, I<:SimpleIID}
Coupling{N}(sites::Union{NTuple{N, Int}, Colon}, ::Type{I}, fields::Union{NTuple{N}, Colon}...) where {N, I<:SimpleIID}
Coupling{N}(value, sites::Union{NTuple{N, Int}, Colon}, ::Type{I}, fields::Union{NTuple{N}, Colon}...) where {N, I<:SimpleIID}

Construct a Coupling with the input sites and the fields of a kind of simple iid.

Diagonal{Fields} <: Function

Construct a pattern for a set of homogenous Indexes that all the specified fields of their contained iids should be diagonal, respectively.

Hilbert{I<:Internal} <: CompositeDict{Int, I}

Hilbert space at a lattice.

Hilbert(internal::Internal, num::Int)

Construct a Hilbert space with all internal spaces the same.

Hilbert(internals::Internal...)
Hilbert(internals::Tuple{Vararg{Internal}})
Hilbert(internals::AbstractVector{<:Internal})

Construct a Hilbert space with the given internals.

Hilbert(ps::Pair...)
Hilbert(kv)

Construct a Hilbert space the same way as a Dict.

IID <: OperatorUnit

The id of an internal degree of freedom.

IIDSpace{I<:IID, V<:Internal} <: VectorSpace{IID}

The space expanded by a "labeled" iid.

Index{S<:Union{Int, Colon}, I<:SimpleIID} <: OperatorUnit

The index of a degree of freedom, which consist of the spatial part and the internal part.

Internal{I<:IID} <: VectorSpace{I}

The whole internal degrees of freedom at a single point.

MatrixCoupling{I<:SimpleIID, C<:Tuple{Vararg{Component}}} <: VectorSpace{Coupling}

A set of Couplings whose coefficients are specified by matrices acting on separated internal spaces.

MatrixCouplingProd{V<:Number, C<:Tuple{Vararg{MatrixCoupling}}} <: VectorSpace{Coupling}

The product of a set of Couplings whose coefficients are specified by matrices.

MatrixCouplingSum{C<:MatrixCouplingProd, N} <: VectorSpace{Coupling}

The sum of a set of Couplings whose coefficients are specified by matrices.

Metric <: Function

The rules for measuring an operator unit so that different operator units can be compared.

As a function, every instance should accept only one positional argument, i.e. the operator unit to be measured.

OperatorUnitToTuple{Fields} <: Metric

A rule that converts an operator unit to a tuple by iterating over a set of selected fields in a specific order.

(operatorunittotuple::OperatorUnitToTuple)(index::Index) -> Tuple

Convert an index to a tuple.

OperatorUnitToTuple(::Type{I}) where {I<:Index}

Construct the metric rule from the information of the Index type.

Pattern <: Function

Construct a pattern for a set of Indexes.

SimpleIID <: IID

The id of a simple internal degree of freedom.

SimpleInternal{I<:SimpleIID} <: Internal{I}

The simple internal degrees of freedom at a single point.

Table(operatorunits::AbstractVector{<:OperatorUnit}, by::Metric=OperatorUnitToTuple(eltype(operatorunits)))

Convert a set of operator units to the corresponding table of operator unit vs. sequence pairs.

The input operator units are measured by the input by function with the duplicates removed. The resulting unique values are sorted, which determines the sequence of the input operatorunits. Note that two operator units have the same sequence if their converted values are equal to each other.

Table{I, B<:Metric} <: CompositeDict{I, Int}

The table of operator unit vs. sequence pairs.

Table(hilbert::Hilbert, by::Metric=OperatorUnitToTuple(typeof(hilbert))) -> Table

Get the index-sequence table of a Hilbert space.

Term{K, I, V, B, C<:TermCoupling, A<:TermAmplitude, M<:TermModulate}

A term of a quantum lattice system.

Term{K}(id::Symbol, value, bondkind, coupling, ishermitian::Bool; amplitude::Union{Function, Nothing}=nothing, modulate::Union{Function, Bool}=true) where K

Construct a term.

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

The function for the amplitude of a term.

TermCoupling{E<:Coupling, C} <: TermFunction

The function for the coupling 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.

@indexes index₁ index₂ ...
@indexes(index₁, index₂, ...; constraint=...)

Construct an set of indexes and its constraint according to the input index pattern and an optional constraint.

*(cp₁::Coupling, cp₂::Coupling) -> Coupling

Get the multiplication between two coupling.

*(mc₁::MatrixCoupling, mc₂::MatrixCoupling) -> MatrixCouplingProd
*(mc::MatrixCoupling, mcp::MatrixCouplingProd) -> MatrixCouplingProd
*(mcp::MatrixCouplingProd, mc::MatrixCoupling) -> MatrixCouplingProd
*(mcp₁::MatrixCouplingProd, mcp₂::MatrixCouplingProd) -> MatrixCouplingProd
*(mc::MatrixCoupling, factor::Number) -> MatrixCouplingProd
*(factor::Number, mc::MatrixCoupling) -> MatrixCouplingProd
*(factor::Number, mcp::MatrixCouplingProd) -> MatrixCouplingProd
*(mcp::MatrixCouplingProd, factor::Number) -> MatrixCouplingProd
*(mcs::MatrixCouplingSum, element::Union{Number, MatrixCoupling, MatrixCouplingProd}) -> MatrixCouplingSum
*(element::Union{Number, MatrixCoupling, MatrixCouplingProd}, mcs::MatrixCouplingSum) -> MatrixCouplingSum
*(mcs₁::MatrixCouplingSum, mcs₂::MatrixCouplingSum) -> MatrixCouplingSum

The product between MatrixCouplings and MatrixCouplingProds.

*(constraint₁::Constraint, constraint₂::Constraint) -> Constraint

Get the combination of two sets of constraints.

+(mc₁::Union{MatrixCoupling, MatrixCouplingProd}, mc₂::Union{MatrixCoupling, MatrixCouplingProd}) -> MatrixCouplingSum
+(mc::Union{MatrixCoupling, MatrixCouplingProd}, mcs::MatrixCouplingSum) -> MatrixCouplingSum
+(mcs::MatrixCouplingSum, mc::Union{MatrixCoupling, MatrixCouplingProd}) -> MatrixCouplingSum
+(mcs₁::MatrixCouplingSum, mcs₂::MatrixCouplingSum) -> MatrixCouplingSum

The addition between MatrixCouplings and MatrixCouplingProds.

/(mcp::MatrixCouplingProd, factor::Number) -> MatrixCouplingProd
/(mcs::MatrixCouplingSum, factor::Number) -> MatrixCouplingSum
/(mc::MatrixCoupling, factor::Number) -> MatrixCouplingProd
//(mcp::MatrixCouplingProd, factor::Number) -> MatrixCouplingProd
//(mcs::MatrixCouplingSum, factor::Number) -> MatrixCouplingSum
//(mc::MatrixCoupling, factor::Number) -> MatrixCouplingProd
-(mc::MatrixCoupling) -> MatrixCouplingProd
-(mcp::MatrixCouplingProd) -> MatrixCouplingProd
-(mcs::MatrixCouplingSum) -> MatrixCouplingSum
-(mc₁::Union{MatrixCoupling, MatrixCouplingProd}, mc₂::Union{MatrixCoupling, MatrixCouplingProd}) -> MatrixCouplingSum
-(mc::Union{MatrixCoupling, MatrixCouplingProd}, mcs::MatrixCouplingSum) -> MatrixCouplingSum
-(mcs::MatrixCouplingSum, mc::Union{MatrixCoupling, MatrixCouplingProd}) -> MatrixCouplingSum
-(mcs₁::MatrixCouplingSum, mcs₂::MatrixCouplingSum) -> MatrixCouplingSum

Define right-division, minus and subtraction operator.

^(mc::Union{MatrixCoupling, MatrixCouplingProd, MatrixCouplingSum}, n::Int) -> Union{MatrixCoupling, MatrixCouplingProd, MatrixCouplingSum}

Get the nth power of a MatrixCoupling/MatrixCouplingProd/MatrixCouplingSum.

adjoint(index::CompositeIndex) -> typeof(index)

Get the adjoint of an operator id.

adjoint(index::Index) -> typeof(index)

Get the adjoint of an index.

filter(iid::SimpleIID, ci::CompositeInternal) -> Union{Nothing, SimpleInternal, CompositeInternal}
filter(::Type{I}, ci::CompositeInternal) where {I<:SimpleIID} -> Union{Nothing, SimpleInternal, CompositeInternal}

Filter the composite internal space and select those that matches I or the type of iid.

filter(iid::SimpleIID, i::SimpleInternal) -> Union{Nothing, typeof(i)}
filter(::Type{I}, i::SimpleInternal) where {I<:SimpleIID} -> Union{Nothing, typeof(i)}

Filter a simple internal space with respect to the input iid or type I.

filter(iid::SimpleIID, ::Type{C}) where {C<:CompositeInternal}
filter(::Type{I}, ::Type{C}) where {I<:SimpleIID, C<:CompositeInternal}

Filter the type of a composite internal space and select those that matches I or the type of iid.

filter(iid::SimpleIID, ::Type{T}) where {T<:SimpleInternal}
filter(::Type{I}, ::Type{T}) where {I<:SimpleIID, T<:SimpleInternal}

Filter the type of a simple internal space with respect to the input iid or type I.

getindex(table::Table, operatorunit::OperatorUnit) -> Int

Inquiry the sequence of an operator unit.

haskey(table::Table, operatorunit::OperatorUnit) -> Bool
haskey(table::Table, operatorunits::ID{OperatorUnit}) -> Tuple{Vararg{Bool}}

Judge whether a single operator unit or a set of operator units have been assigned with sequences in table.

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

Get the names of the boundary parameters.

keys(::OperatorUnitToTuple{Fields}) where Fields -> Fields
keys(::Type{<:OperatorUnitToTuple{Fields}}) where Fields -> Fields

Get the names of the selected fields.

match(iid::SimpleIID, i::SimpleInternal) -> Bool
match(::Type{I}, ::Type{SI}) where {I<:SimpleIID, SI<:SimpleInternal}

Judge whether a simple iid or a simple iid type matches a simple internal space or a simple internal space type.

Here, "match" means that the eltype of the simple internal space has the same type name with the simple iid.

match(constraint::Constraint, indexes::Tuple{Vararg{Index}}) -> Bool

Judge whether a composite iid fulfills a constraint.

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

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

one(term::Term) -> Term

Get a unit term.

replace(bound::Boundary; values=bound.values, vectors=bound.vectors) -> Boundary

Replace the values or vectors of a twisted boundary condition and get the new one.

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

Replace some attributes of a term with key word arguments.

repr(term::Term, bond::Bond, hilbert::Hilbert) -> String

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

union(tables::Table...) -> Table

Unite several operator unit vs. sequence tables.

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

Get the value type of a term.

valtype(::Type{<:OperatorUnitToTuple}, ::Type{<:Index})

Get the valtype of applying an OperatorUnitToTuple rule to an Index.

zero(term::Term) -> Term

Get a zero term.

latexstring(coupling::Coupling) -> String

Convert a Coupling to the latex format.

rank(ciid::CompositeIID) -> Int
rank(::Type{<:CompositeIID{T}}) where {T<:Tuple{Vararg{SimpleIID}}} -> Int

Get the number of simple iids in a composite iid.

rank(ci::CompositeInternal) -> Int
rank(::Type{<:CompositeInternal{K, T}}) where {K, T<:Tuple{Vararg{SimpleInternal}}} -> Int

Get the number of simple internal spaces in a composite internal space.

rank(constraint::Constraint, i::Integer) -> Int
rank(::Type{<:Constraint{RS}}, i::Integer) where RS -> Int

Get the rank of the ith homogenous segment of the coupling indexes that a constraint can apply.

rank(constraint::Constraint) -> Int
rank(::Type{<:Constraint{RS}}) where RS -> Int

Get the rank of the coupling indexes that a constraint can apply.

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

Get the rank of a term.

⊕(i₁::SimpleInternal, i₂::SimpleInternal) -> CompositeInternal{:⊕}
⊕(i::SimpleInternal, ci::CompositeInternal{:⊕}) -> CompositeInternal{:⊕}
⊕(ci::CompositeInternal{:⊕}, i::SimpleInternal) -> CompositeInternal{:⊕}
⊕(ci₁::CompositeInternal{:⊕}, ci₂::CompositeInternal{:⊕}) -> CompositeInternal{:⊕}

Direct product between simple internal spaces and composite internal spaces.

⊗(iid₁::SimpleIID, iid₂::SimpleIID) -> CompositeIID
⊗(iid::SimpleIID, ciid::CompositeIID) -> CompositeIID
⊗(ciid::CompositeIID, iid::SimpleIID) -> CompositeIID
⊗(ciid₁::CompositeIID, ciid₂::CompositeIID) -> CompositeIID

Direct product between simple iids and composite iids.

⊗(i₁::SimpleInternal, i₂::SimpleInternal) -> CompositeInternal{:⊗}
⊗(i::SimpleInternal, ci::CompositeInternal{:⊗}) -> CompositeInternal{:⊗}
⊗(ci::CompositeInternal{:⊗}, i::SimpleInternal) -> CompositeInternal{:⊗}
⊗(ci₁::CompositeInternal{:⊗}, ci₂::CompositeInternal{:⊗}) -> CompositeInternal{:⊗}

Direct product between simple internal spaces and composite internal spaces.

iidtype(ciid::CompositeIID, i::Integer)
iidtype(::Type{<:CompositeIID{T}}, i::Integer) where {T<:Tuple{Vararg{SimpleIID}}}

Get the type of the ith simple iid in a composite iid.

iidtype(index::Index)
iidtype(::Type{I}) where {I<:Index}

Get the type of the internal part of an index.

indextype(::AbstractCompositeIndex)
indextype(::Type{<:AbstractCompositeIndex})

Get the index type of a composite index.

indextype(I::Type{<:SimpleInternal}, P::Type{<:Point}, ::Val)

Get the compatible composite index type based on the information of its internal part.

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

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

plain

Plain boundary condition without any twist.

sitestructure(::Val{termkind}, ::Val{termrank}, bondlength::Integer) where {termkind, termrank} -> NTuple{termrank, Int}

Get the site structure, i.e. the acting centers of the coupling on a bond, of a certain kind of term.

statistics(index::Index) -> Symbol
statistics(::Type{<:Index{I}}) where {I<:SimpleIID} -> Symbol

Get the statistics of an index.

statistics(index::AbstractCompositeIndex) -> Symbol
statistics(::Type{<:AbstractCompositeIndex{I}}) where {I<:Index} -> Symbol

Get the statistics of a composite operator id.

statistics(i::SimpleInternal) -> Symbol
statistics(::Type{<:SimpleInternal{I}}) where {I<:SimpleIID} -> Symbol

Get the statistics of a simple internal space.

optype(::Type{T}, ::Type{H}, ::Type{B}) where {T<:Term, H<:Hilbert, B<:Bond}

Get the compatible Operator type from the type of a term, a Hilbert space and a bond.

script(::Val{:integercoordinate}, index::CompositeIndex; vectors, kwargs...)

Get the integral script of the icoordinate of an composite index.

script(::Val{:rcoordinate}, index::CompositeIndex; kwargs...) -> String
script(::Val{:icoordinate}, index::CompositeIndex; kwargs...) -> String

Get the rcoordinate/icoordinate script of a composite index.

script(::Val{:site}, index::Index; kwargs...) -> String
script(attr::Val, index::Index; kwargs...) -> String

Get the required script of a spin index.

script(::Val{attr}, index::CompositeIndex; kwargs...) where attr

Get the attr script of an index, which is contained in its index.

icoordinate(opt::Operator{<:Number, <:ID{CompositeIndex}}) -> SVector

Get the whole icoordinate of an operator.

rcoordinate(opt::Operator{<:Number, <:ID{CompositeIndex}}) -> SVector

Get the whole rcoordinate of an operator.

expand!(operators::Operators, term::Term, bond::Bond, hilbert::Hilbert; half::Bool=false) -> Operators
expand!(operators::Operators, term::Term, bonds, hilbert::Hilbert; half::Bool=false) -> Operators

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

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(iid::SimpleIID, internal::SimpleInternal) -> IIDSpace
expand(iids::NTuple{N, SimpleIID}, internals::NTuple{N, SimpleInternal}) where N -> IIDSpace

Get the space expanded by a set of "labeled" iids.

expand(term::Term, bond::Bond, hilbert::Hilbert; half::Bool=false) -> Operators
expand(term::Term, bonds, hilbert::Hilbert; half::Bool=false) -> Operators

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

expand(::Val{termkind}, coupling::Coupling, bond::Bond, hilbert::Hilbert) where termkind

Expand a coupling with the given bond and Hilbert space of a certain kind of term.

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

Get the id of a term.

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

Get the kind of a term.

permute(index₁::CompositeIndex, index₂::CompositeIndex) -> Tuple{Vararg{Operator}}

Get the permutation of two composite indexes.

permute(index₁::Index, index₂::Index) -> Tuple{Vararg{Operator}}

Get the permutation of two indexes.

reset!(table::Table, operatorunits::AbstractVector{<:OperatorUnit}) -> Table

Reset a table by a new set of operatorunits.

reset!(table::Table, hilbert::Hilbert) -> Table

Reset a table by a Hilbert space.

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

Update the values of the boundary twisted phase.

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

Update the value of a term by its modulate function.