Degrees of freedom

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

Constant ordinals.

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} <: OperatorIndex

Abstract type of a composite index.

(index::CompositeIndex)(quantumnumber::Abelian) -> Abelian

Get the resulting Abelian quantum number after a CompositeIndex acts upon an initial Abelian quantum number.

CompositeInternal{T<:OneAtLeast{SimpleInternal}, I<:OneOrMore{InternalIndex}} <: Internal{I}

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

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

Construct a Coupling with the input sites and the fields of a kind of 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 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::OneAtLeast{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::InternalIndex)

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

(index::Index)(quantumnumber::Abelian) -> Abelian

Get the resulting Abelian quantum number after an Index acts upon an initial Abelian quantum number.

Index(index::OperatorIndex)

Get the Index part of an OperatorIndex.

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

Internal space at a single point.

InternalIndex <: OperatorIndex

Internal index of an internal degree of freedom.

InternalIndex(index::OperatorIndex)

Get the InternalIndex part of an OperatorIndex.

InternalProd{T<:OneAtLeast{SimpleInternal}, I<:OneAtLeast{InternalIndex}} <: CompositeInternal{T, I}

Direct product of several single internal spaces.

InternalSum{T<:OneAtLeast{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<:InternalIndex}
MatrixCoupling(sites::Union{NTuple{2, Ordinal}, Colon}, ::Type{I}, contents::Component...) where {I<:InternalIndex}

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

Rules for measuring an operator index so that different operator indexes can be compared.

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

OperatorIndexToTuple{Fields} <: Metric

A rule that converts an operator index 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 OperatorIndex, 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 OperatorIndex, and its return value will become the corresponding element in the converted tuple.

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

Convert an index to a tuple.

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

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

Ordinal

Ordinal of an Int.

Pattern(indexes::OneAtLeast{Index}, constraint::Function, representation::String=string(constraint))
Pattern{P}(indexes::OneAtLeast{Index}, constraints::NTuple{N, Function}, representations::NTuple{N, String}=map(string, constraints))  where {P, N}

Construct a coupling pattern with 1) only one constraint function, and 2) several constraint functions.

Pattern{I, P, N, C<:OneAtLeast{Function}} <: QuantumOperator

Coupling pattern.

Pattern(indexes::OneAtLeast{Index})
Pattern(index::Index, indexes::Index...)

Construct a coupling pattern subject to the "diagonal" constraint for a homogeneous set of indexes.

SimpleInternal{I<:InternalIndex} <: Internal{I}

Simple internal space at a single point.

Table(indexes::AbstractVector{<:OperatorIndex}, by::Metric=OperatorIndexToTuple(eltype(indexes)))

Convert a set of operator units to the corresponding table of operator index 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 indexes. 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}

Table of operator index v.s. sequence pairs.

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

Get the index-sequence table of a Hilbert space.

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}

Function for the amplitude of a term.

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

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.

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

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(index::InternalIndex, internal::CompositeInternal) -> Union{Nothing, SimpleInternal, CompositeInternal}
filter(::Type{I}, internal::CompositeInternal) where {I<:InternalIndex} -> Union{Nothing, SimpleInternal, CompositeInternal}

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

filter(index::InternalIndex, internal::SimpleInternal) -> Union{Nothing, typeof(internal)}
filter(::Type{I}, internal::SimpleInternal) where {I<:InternalIndex} -> Union{Nothing, typeof(internal)}

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

filter(index::InternalIndex, ::Type{CI}) where {CI<:CompositeInternal}
filter(::Type{I}, ::Type{CI}) where {I<:InternalIndex, CI<:CompositeInternal}

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

filter(index::InternalIndex, ::Type{SI}) where {SI<:SimpleInternal}
filter(::Type{I}, ::Type{SI}) where {I<:InternalIndex, SI<:SimpleInternal}

Filter the type of a simple internal space with respect to the input internal index or the type of an 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(pattern::Pattern, slice)

Get the indexes specified by slice in a coupling pattern.

getindex(table::Table, index::OperatorIndex) -> Int

Inquiry the sequence of an operator index.

haskey(table::Table, index::OperatorIndex) -> Bool
haskey(table::Table, indexes::ID{OperatorIndex}) -> Tuple{Vararg{Bool}}

Judge whether a single operator index or a set of operator indexes 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(::OperatorIndexToTuple{Fields}) where Fields -> Fields
keys(::Type{<:OperatorIndexToTuple{Fields}}) where Fields -> Fields

Get the values of the type parameter Fields.

match(index::InternalIndex, internal::SimpleInternal) -> Bool
match(::Type{I}, internal::SimpleInternal) where {I<:InternalIndex} -> Bool
match(index::InternalIndex, ::Type{SI}) where {SI<:SimpleInternal} -> Bool
match(::Type{I}, ::Type{SI}) where {I<:InternalIndex, SI<:SimpleInternal} -> Bool

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

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

match(pattern::Pattern, indexes::OneAtLeast{InternalIndex}) -> Bool

Judge whether a set of internal indexes satisfies a coupling pattern.

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 index vs. sequence tables.

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

Get the value type of a term.

valtype(terms::Tuple{Term, Vararg{Term}})
valtype(::Type{<:T}) where {T<:Tuple{Term, Vararg{Term}}}

Get the common value type of a set of terms.

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

Get the valtype of applying an OperatorIndexToTuple 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::Pattern) -> String

Convert a coupling pattern to the latex format.

rank(internal::CompositeInternal) -> Int
rank(::Type{<:CompositeInternal{T}}) where {T<:OneAtLeast{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(pattern::Pattern, i::Integer) -> Int
rank(::Type{P}, i::Integer) where {P<:Pattern} -> Int

Get the ith rank of the coupling pattern where the ith constraint can apply.

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

Get the total rank of the coupling pattern.

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

Get the rank of a term.

⊕(internal::SimpleInternal, internals::SimpleInternal...) -> InternalSum
⊕(internal::SimpleInternal, internals::InternalSum) -> InternalSum
⊕(internals::InternalSum, internal::SimpleInternal) -> InternalSum
⊕(internals₁::InternalSum, internals₂::InternalSum) -> InternalSum

Direct sum between simple internal spaces and composite internal spaces.

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

Get the combination of two coupling patterns.

⊗(internal::SimpleInternal, internals::SimpleInternal...) -> InternalProd
⊗(internal::SimpleInternal, internals::InternalProd) -> InternalProd
⊗(internals::InternalProd, internal::SimpleInternal) -> InternalProd
⊗(internals₁::InternalProd, internals₂::InternalProd) -> InternalProd

Direct product between simple internal spaces and composite internal spaces.

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

diagonalfields(::Type{I}) where {I<:InternalIndex} -> Tuple{Vararg{Symbol}}

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

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

Get the type of the Index part of an OperatorIndex.

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

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

internalindextype(index::OperatorIndex)
internalindextype(::Type{I}) where {I<:OperatorIndex}

Get the type of the InternalIndex part of an OperatorIndex.

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

Determine whether an index denotes a definite degree of freedom.

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

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

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

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

isdefinite(indexes::OneAtLeast{InternalIndex}) -> Bool
isdefinite(::Type{T}) where {T<:OneAtLeast{InternalIndex}} -> Bool

Judge whether all of a set of internal indexes denote definite internal degrees of freedom.

isdiagonal(indexes::OneAtLeast{InternalIndex}, ::Val{fields}) where fields -> Bool

Judge whether a set of homogenous internal indexes is subject to the "diagonal" constraint.

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

Get the partition of the coupling pattern.

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(sites::OneAtLeast{Colon}, ::Val, bondlength::Integer) -> OneAtLeast{Ordinal}

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

patternrule(indexes::OneAtLeast{InternalIndex}, ::Val{Name}) where Name -> OneAtLeast{InternalIndex}

Define the default rule for the internal index in a coupling pattern.

plain

Plain boundary condition without any twist.

showablefields(index::InternalIndex) -> Tuple{Vararg{Symbol}}
showablefields(::Type{I}) where {I<:InternalIndex} -> Tuple{Vararg{Symbol}}

Get the showable fields of an internal index or a type of internal index.

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(index::InternalIndex) -> Symbol

Get the statistics of an internal index.

statistics(internal::SimpleInternal) -> Symbol
statistics(::Type{<:SimpleInternal{I}}) where {I<:InternalIndex} -> Symbol

Get the statistics of a simple internal space.

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

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.

nneighbor(term::Term) -> Int
nneighbor(terms::Tuple{Term, Vararg{Term}}) -> Int

Get the

1. order of neighbor in a single term;
2. highest order of neighbors in a set of terms.

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

Get the whole rcoordinate of an operator.

dimension(internal::Internal) -> Int

Get the dimension of an internal space at a single point.

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, indexes::AbstractVector{<:OperatorIndex}) -> Table

Reset a table by a new set of indexes.

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

Reset a table by a Hilbert space.

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

Get the shape of a simple internal space when a labeled internal index is considered.

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

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.