Degrees of freedom

const ˢᵗ = ⁿᵈ = ʳᵈ = ᵗʰ = Ordinal(1)

Constant ordinals.

AbstractIndex <: OperatorUnit

Abstract type of the index of degrees of freedom.

AllEqual{Fields} <: Function

All-equal constraint for the direct product of homogenous simple internal indexes that for every specified field the values of the internal indexes should be all equal.

AllEqual(fields::Tuple{Vararg{Symbol}})
AllEqual(fields::Symbol...)

Construct an all-equal constraint.

(constraint::AllEqual{fields})(index::InternalIndexProd{NTuple{N, I}}) where {fields, N, I<:SimpleInternalIndex} -> Bool

Judge whether the direct product of a set of homogenous simple internal indexes is subject to an all-equal constraint.

AllEqual(::Type{I}) where {I<:SimpleInternalIndex}

Construct an all-equal constraint based on the type of a simple internal 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 matrix coupling, i.e., a matrix acting on a separated internal space.

CompositeIndex{I<:Index} <: AbstractIndex

Abstract type of a composite index.

CompositeInternal{T<:Tuple{Vararg{SimpleInternal}}, I<:InternalIndex} <: Internal{I}

Abstract type of the composition (i.e., direct sum or direct product) of several simple internal spaces.

ConstrainedInternal{P<:InternalProd, C<:InternalPattern}

Constrained internal space.

ConstrainedInternal(internal::SimpleInternal, pattern::InternalPattern)
ConstrainedInternal(internal::InternalProd, pattern::InternalPattern)

Construct a constrained internal space.

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

Coordinated index, i.e., index with coordinates in the unitcell.

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

Construct a coordinated index.

Coupling{V, P<:Pattern} <: OperatorPack{V, P}

Coupling among internal degrees of freedom at different or same lattice points.

Coupling(value, pattern::Pattern)
Coupling(pattern::Pattern)

Construct a coupling.

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, Ordinal}, Colon}, ::Type{I}, fields::Union{NTuple{N}, Colon}...) where {N, I<:SimpleInternalIndex}
Coupling(value, sites::Union{NTuple{N, Ordinal}, Colon}, ::Type{I}, fields::Union{NTuple{N}, Colon}...) where {N, I<:SimpleInternalIndex}
Coupling{N}(sites::Union{NTuple{N, Ordinal}, Colon}, ::Type{I}, fields::Union{NTuple{N}, Colon}...) where {N, I<:SimpleInternalIndex}
Coupling{N}(value, sites::Union{NTuple{N, Ordinal}, Colon}, ::Type{I}, fields::Union{NTuple{N}, Colon}...) where {N, I<:SimpleInternalIndex}

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

Coupling(f::Union{Function, Type{<:Function}}, sites::Union{NTuple{N, Ordinal}, Colon}, fields::Union{NTuple{N}, Colon}...) where N
Coupling(value::Number, f::Union{Function, Type{<:Function}}, sites::Union{NTuple{N, Ordinal}, Colon}, fields::Union{NTuple{N}, Colon}...) where N
Coupling{N}(f::Union{Function, Type{<:Function}}, sites::Union{NTuple{N, Ordinal}, Colon}, fields::Union{NTuple{N}, Colon}...) where N
Coupling{N}(value::Number, f::Union{Function, Type{<:Function}}, sites::Union{NTuple{N, Ordinal}, Colon}, fields::Union{NTuple{N}, Colon}...) where N

Construct a Coupling by a function that can construct an Index with the input sites and the fields of a kind of simple internal index.

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

Hilbert space at a lattice.

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

Construct a Hilbert space with all same internal spaces.

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

Construct a Hilbert space with the given internal spaces.

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

Construct a Hilbert space the same way as an OrderedDict.

Index(site::Union{Int, Ordinal, Colon}, internal::SimpleInternalIndex)

Index of a degree of freedom, which consist of the spatial part (i.e., the site index) and the internal part (i.e., the internal index).

Internal{I<:InternalIndex} <: VectorSpace{I}

Internal space at a single point.

InternalIndex <: AbstractIndex

Internal index of the internal degrees of freedom.

InternalIndexProd{T<:Tuple{Vararg{SimpleInternalIndex}}} <: InternalIndex

Direct product of several simple internal indexes.

InternalIndexProd(contents::SimpleInternalIndex...)

Construct the direct product of several simple internal indexes.

InternalPattern(index::InternalIndexProd, constraint::Function, representation::String=string(constraint))
InternalPattern{P}(index::InternalIndexProd, constraints::NTuple{N, Function}, representations::NTuple{N, String}=map(string, constraints))  where {P, N}

Construct an internal pattern for the direct product of a set of simple internal indexes with 1) only one constraint function, and 2) several constraint functions.

InternalPattern{I, P, N, C<:NTuple{N, Function}} <: QuantumOperator

Internal pattern for the direct product of a set of simple internal indexes with extra constraints.

InternalPattern(index::SimpleInternalIndex)
InternalPattern(index::InternalIndexProd{<:Tuple{Vararg{I}}}) where {I<:SimpleInternalIndex}

Construct an internal pattern whose constraint is an AllEqual function for the direct product of a homogeneous set of simple internal indexes.

InternalProd{T<:Tuple{Vararg{SimpleInternal}}, I<:InternalIndex} <: CompositeInternal{T, I}

Direct product of several single internal spaces.

InternalSum{T<:Tuple{Vararg{SimpleInternal}}, I<:InternalIndex} <: CompositeInternal{T, I}

Direct sum of several single internal spaces.

MatrixCoupling{I}(sites::Union{NTuple{2, Ordinal}, NTuple{2, Colon}}, contents::Tuple{Vararg{Component}}) where {I<:SimpleInternalIndex}
MatrixCoupling(sites::Union{NTuple{2, Ordinal}, Colon}, ::Type{I}, contents::Component...) where {I<:SimpleInternalIndex}

Matrix coupling, i.e., a set of couplings whose coefficients are specified by matrices acting on separated internal spaces.

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

Product of matrix couplings together with an overall coefficient.

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

Sum of the products of matrix couplings.

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 into a tuple based on the specified type parameter Fields.

Here, Fields must be a tuple of Union{Symbol, Function}, which determines the elements of the converted tuple on an element-by-element basis.

For the ith element of Fields:

1. If it is a Symbol, it represents the name of a single index of an OperatorUnit, and its value will become the corresponding element in the converted tuple.
2. If it is a Function, it should be a trait function of an OperatorUnit, and its return value will become the corresponding element in the converted tuple.

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

Ordinal

Ordinal of an Int.

Pattern{C<:InternalPattern, S<:Tuple{Vararg{Union{Ordinal, Colon}}}} <: QuantumOperator

Coupling pattern.

Pattern(indexes::Index...)
Pattern(indexes::Tuple{Vararg{Index}})

Construct a coupling pattern from a set of indexes.

SimpleInternal{I<:SimpleInternalIndex} <: Internal{I}

Simple internal space at a single point.

SimpleInternalIndex <: InternalIndex

Simple internal index, i.e., a complete set of indexes to denote an internal degree of freedom.

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(hilbert::Hilbert, by::Metric=OperatorUnitToTuple(typeof(hilbert))) -> Table

Get the index-sequence table of a Hilbert space.

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

The table of operator unit v.s. sequence pairs.

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

Term of a quantum lattice system.

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

Construct a term.

TermAmplitude{F} <: TermFunction{F}

The function for the amplitude of a term.

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

The function for the coupling of a term.

TermFunction{F} <: Function

Abstract type for concrete term functions.

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

Construct a coupling pattern according to the pattern of the input indexes and an optional constraint.

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

Product between MatrixCouplings and MatrixCouplingProds.

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

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 for a MatrixCoupling/MatrixCouplingProd/MatrixCouplingSum.

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

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

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

Get the adjoint of a coordinated index.

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

Get the adjoint of an index.

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

Filter the composite internal space and select those that match the input simple internal index or the type of a simple internal index.

filter(ii::SimpleInternalIndex, i::SimpleInternal) -> Union{Nothing, typeof(internal)}
filter(::Type{I}, i::SimpleInternal) where {I<:SimpleInternalIndex} -> Union{Nothing, typeof(internal)}

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

filter(ii::SimpleInternalIndex, ::Type{CI}) where {CI<:CompositeInternal}
filter(::Type{I}, ::Type{CI}) where {I<:SimpleInternalIndex, CI<:CompositeInternal}

Filter the type of a composite internal space and select those that match the input simple internal index or the type of a simple internal index.

filter(ii::SimpleInternalIndex, ::Type{SI}) where {SI<:SimpleInternal}
filter(::Type{I}, ::Type{SI}) where {I<:SimpleInternalIndex, SI<:SimpleInternal}

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

findall(select::Function, hilbert::Hilbert, table::Table) -> Vector{Int}

Find all the sequences of indexes contained in a Hilbert space according to a table and a select function.

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 values of the type parameter Fields.

match(pattern::InternalPattern, index::InternalIndexProd) -> Bool

Judge whether the direct product of a set of simple internal indexes satisfies an internal pattern.

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

Judge whether a simple internal space or the type of a simple internal space matches a simple internal index or the type of a simple internal index.

Here, "match" means that the eltype of the simple internal space is consistent with the type of the simple internal index, which usually means that they share the same type name.

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, value) -> Term

Replace the value of a term.

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

Get the string 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.

latexstring(pattern::InternalPattern) -> String

Convert an internal pattern to the latex format.

latexstring(pattern::Pattern) -> String

Convert a coupling pattern to the latex format.

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

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

rank(coupling::Coupling) -> Int
rank(::Type{M}) where {M<:Coupling} -> Int

Get the rank of a coupling.

rank(cii::InternalIndexProd) -> Int
rank(::Type{<:InternalIndexProd{T}}) where {T<:Tuple{Vararg{SimpleInternalIndex}}} -> Int

Get the number of simple internal indexes in a direct product.

rank(pattern::InternalPattern, i::Integer) -> Int
rank(::Type{P}, i::Integer) where {P<:InternalPattern} -> Int

Get the rank of the direct product of the simple internal indexes that the ith constraint in an internal pattern can apply.

rank(pattern::InternalPattern) -> Int
rank(::Type{P}) where {P<:InternalPattern} -> Int

Get the rank of the direct product of the simple internal indexes that an internal pattern can apply.

rank(pattern::Pattern) -> Int
rank(::Type{<:Pattern{<:InternalPattern, S}}) where {S<:Tuple{Vararg{Union{Ordinal, Colon}}}} -> Int

Get the rank of a coupling pattern.

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

Get the rank of a term.

⊕(is::SimpleInternal...) -> InternalSum
⊕(i::SimpleInternal, ci::InternalSum) -> InternalSum
⊕(ci::InternalSum, i::SimpleInternal) -> InternalSum
⊕(ci₁::InternalSum, ci₂::InternalSum) -> InternalSum

Direct sum between simple internal spaces and composite internal spaces.

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

Get the multiplication between two coupling.

⊗(pattern₁::InternalPattern, pattern₂::InternalPattern) -> InternalPattern

Get the combination of two internal patterns.

⊗(pattern₁::Pattern, pattern₂::Pattern) -> Pattern

Get the combination of two coupling patterns.

⊗(iis::SimpleInternalIndex...) -> InternalIndexProd
⊗(ii::SimpleInternalIndex, cii::InternalIndexProd) -> InternalIndexProd
⊗(cii::InternalIndexProd, ii::SimpleInternalIndex) -> InternalIndexProd
⊗(cii₁::InternalIndexProd, cii₂::InternalIndexProd) -> InternalIndexProd

Direct product between internal indexes.

⊗(is::SimpleInternal...) -> InternalProd
⊗(i::SimpleInternal, ci::InternalProd) -> InternalProd
⊗(ci::InternalProd, i::SimpleInternal) -> InternalProd
⊗(ci₁::InternalProd, ci₂::InternalProd) -> InternalProd

Direct product between simple internal spaces and composite internal spaces.

allequalfields(::Type{I}) where {I<:SimpleInternalIndex} -> Tuple{Vararg{Symbol}}

Get the field names that can be subject to all-equal constraint based on the type of a simple internal index.

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

Get the index type of a composite index.

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

Get the type of the internal part of an index.

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

Get the compatible type of the coordinated index based on the type of an internal space and the type of a point.

indextype(I::Type{<:SimpleInternal})

Get the compatible type of the index based on the type of an internal space.

isdefinite(index::Index) -> Bool
isdefinite(::Type{<:Index{I}}) where {I<:SimpleInternalIndex} -> Bool

Determine whether an index denotes a definite degree of freedom.

isdefinite(ii::InternalIndex) -> Bool
isdefinite(::Type{<:InternalIndex}) -> Bool

Judge whether an internal index denotes a definite internal degree of freedom.

isdefinite(indexes::Tuple{Vararg{Index}}) -> Bool
isdefinite(::Type{T}) where {T<:Tuple{Vararg{Index}}} -> Bool

Determine whether a tuple of indexes denotes a definite degree of freedom.

partition(pattern::InternalPattern) -> Tuple{Vararg{Int}}
partition(::Type{<:InternalPattern{I, P} where I}) where P -> P

Get the partition of the direct product of a set of simple internal indexes on which the extra constraints operate independently.

patternrule(value, ::Val{Name}, args...; kwargs...) where Name

By overriding this function, a named rule for the value of some attributes in a pattern can be defined so that the value can be transformed into the desired one.

In most cases, such overridden functions define the default rules for the attributes in a pattern when they take on the default value :.

patternrule(value, ::Val, args...; kwargs...)-> typeof(value)

Default pattern rule unless otherwise specified.

patternrule(index::InternalIndexProd{T}, ::Val{Name}) where {N, T<:NTuple{N, SimpleInternalIndex}, Name} -> InternalIndexProd

Define the default rule for the internal index in an internal pattern.

patternrule(sites::NTuple{N, Colon}, ::Val, bondlength::Integer) where N -> NTuple{N, Ordinal}

Define the default rule for the sites of a set of indexes in a coupling pattern.

plain

Plain boundary condition without any twist.

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

Get the statistics of a composite index.

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

Get the statistics of an index.

statistics(ii::SimpleInternalIndex) -> Symbol

Get the statistics of a simple internal index.

statistics(i::SimpleInternal) -> Symbol
statistics(::Type{<:SimpleInternal{I}}) where {I<:SimpleInternalIndex} -> 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(index::CoordinatedIndex, ::Val{:integercoordinate}; vectors, kwargs...)

Get the integer coordinate script of a coordinated index.

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

Get the rcoordinate/icoordinate script of a coordinated index.

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

Get the required script of an index.

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

Get the attr script of a composite index.

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

Get the whole icoordinate of an operator.

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

Get the whole rcoordinate of an operator.

shape(internal::SimpleInternal, index::SimpleInternalIndex) -> OrdinalRange{Int, Int}

The shape of a simple internal space when a labeled simple internal index are considered.

A constrained internal space need this function to generate all the internal indexes that match the internal pattern, which gets a default implementation, i.e.,

shape(internal::SimpleInternal, index::SimpleInternalIndex) = shape(internal)

It can be overloaded to restrict the shape of a simple internal space based on the input simple internal index to significantly improve efficiency, but this is not necessary.

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(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(coupling::Coupling, ::Val{Rule}, bond::Bond, hilbert::Hilbert) where Rule

Expand a coupling with the given bond and Hilbert space under a given named pattern rule.

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₁::CoordinatedIndex, index₂::CoordinatedIndex) -> Tuple{Vararg{Operator}}

Get the permutation of two coordinated 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 if it is ismodulatable.

value(term::Term) -> valtype(term)

Get the value of a term.