Degrees of freedom
QuantumLattices.DegreesOfFreedom.AbstractCompositeIndex
— TypeAbstractCompositeIndex{I<:Index} <: OperatorUnit
The abstract type of a composite index.
QuantumLattices.DegreesOfFreedom.Boundary
— TypeBoundary{Names}(values::AbstractVector{<:Number}, vectors::AbstractVector{<:AbstractVector{<:Number}}) where Names
Boundary twist of operators.
QuantumLattices.DegreesOfFreedom.Boundary
— Method(bound::Boundary)(operator::Operator; origin::Union{AbstractVector, Nothing}=nothing) -> Operator
Get the boundary twisted operator.
QuantumLattices.DegreesOfFreedom.Component
— TypeComponent{T₁, T₂} <: VectorSpace{Tuple{T₁, T₁, T₂}}
A component of a MatrixCoupling
, i.e., a matrix acting on a separated internal space.
QuantumLattices.DegreesOfFreedom.CompositeIID
— TypeCompositeIID{T<:Tuple{Vararg{SimpleIID}}} <: IID
The composition of several single internal ids.
QuantumLattices.DegreesOfFreedom.CompositeIID
— MethodCompositeIID(contents::SimpleIID...)
Construct a composite iid from a set of simple iids.
QuantumLattices.DegreesOfFreedom.CompositeIndex
— TypeCompositeIndex{I<:Index, V<:SVector} <: AbstractCompositeIndex{I}
Composite index of a quantum operator.
QuantumLattices.DegreesOfFreedom.CompositeIndex
— MethodCompositeIndex(index::Index, rcoordinate, icoordinate)
CompositeIndex(index::Index; rcoordinate, icoordinate)
Construct an operator id.
QuantumLattices.DegreesOfFreedom.CompositeInternal
— TypeCompositeInternal{K, T<:Tuple{Vararg{SimpleInternal}}} <: Internal{IID}
The composition of several single internal spaces.
QuantumLattices.DegreesOfFreedom.CompositeInternal
— MethodCompositeInternal{K}(contents::SimpleInternal...) where K
Construct a composite internal space from a set of simple internal spaces.
QuantumLattices.DegreesOfFreedom.Constraint
— TypeConstraint{RS, N, C<:NTuple{N, Function}}
The constraint of the indexes of internal degrees of freedom in a coupling.
QuantumLattices.DegreesOfFreedom.Constraint
— MethodConstraint(indexes::Index...)
Constraint(indexes::NTuple{N, Index}) where N
Construct a constraint based on the pattern of the input indexes.
QuantumLattices.DegreesOfFreedom.Constraint
— MethodConstraint{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.
QuantumLattices.DegreesOfFreedom.Coupling
— TypeCoupling{V, I<:ID{Index}, C<:Constraint} <: OperatorPack{V, Tuple{I, C}}
The coupling intra/inter internal degrees of freedom at different lattice points.
QuantumLattices.DegreesOfFreedom.Coupling
— MethodCoupling(indexes::Index...)
Coupling(value, indexes::Index...)
Coupling(value, indexes::Tuple{Vararg{Index}})
Construct a Coupling
with the input indexes
as the pattern.
QuantumLattices.DegreesOfFreedom.Coupling
— MethodCoupling(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.
QuantumLattices.DegreesOfFreedom.Diagonal
— TypeDiagonal{Fields} <: Function
Construct a pattern for a set of homogenous Index
es that all the specified fields of their contained iids should be diagonal, respectively.
QuantumLattices.DegreesOfFreedom.Hilbert
— TypeHilbert{I<:Internal} <: CompositeDict{Int, I}
Hilbert space at a lattice.
QuantumLattices.DegreesOfFreedom.Hilbert
— MethodHilbert(internal::Internal, num::Int)
Construct a Hilbert space with all internal spaces the same.
QuantumLattices.DegreesOfFreedom.Hilbert
— MethodHilbert(internals::Internal...)
Hilbert(internals::Tuple{Vararg{Internal}})
Hilbert(internals::AbstractVector{<:Internal})
Construct a Hilbert space with the given internals.
QuantumLattices.DegreesOfFreedom.Hilbert
— MethodHilbert(ps::Pair...)
Hilbert(kv)
Construct a Hilbert space the same way as a Dict.
QuantumLattices.DegreesOfFreedom.IID
— TypeIID <: OperatorUnit
The id of an internal degree of freedom.
QuantumLattices.DegreesOfFreedom.IIDSpace
— TypeIIDSpace{I<:IID, V<:Internal} <: VectorSpace{IID}
The space expanded by a "labeled" iid.
QuantumLattices.DegreesOfFreedom.Index
— TypeIndex{S<:Union{Int, Colon}, I<:SimpleIID} <: OperatorUnit
The index of a degree of freedom, which consist of the spatial part and the internal part.
QuantumLattices.DegreesOfFreedom.Internal
— TypeInternal{I<:IID} <: VectorSpace{I}
The whole internal degrees of freedom at a single point.
QuantumLattices.DegreesOfFreedom.MatrixCoupling
— TypeMatrixCoupling{I<:SimpleIID, C<:Tuple{Vararg{Component}}} <: VectorSpace{Coupling}
A set of Coupling
s whose coefficients are specified by matrices acting on separated internal spaces.
QuantumLattices.DegreesOfFreedom.MatrixCouplingProd
— TypeMatrixCouplingProd{V<:Number, C<:Tuple{Vararg{MatrixCoupling}}} <: VectorSpace{Coupling}
The product of a set of Coupling
s whose coefficients are specified by matrices.
QuantumLattices.DegreesOfFreedom.MatrixCouplingSum
— TypeMatrixCouplingSum{C<:MatrixCouplingProd, N} <: VectorSpace{Coupling}
The sum of a set of Coupling
s whose coefficients are specified by matrices.
QuantumLattices.DegreesOfFreedom.Metric
— TypeMetric <: 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.
QuantumLattices.DegreesOfFreedom.OperatorUnitToTuple
— TypeOperatorUnitToTuple{Fields} <: Metric
A rule that converts an operator unit to a tuple by iterating over a set of selected fields in a specific order.
QuantumLattices.DegreesOfFreedom.OperatorUnitToTuple
— Method(operatorunittotuple::OperatorUnitToTuple)(index::Index) -> Tuple
Convert an index to a tuple.
QuantumLattices.DegreesOfFreedom.OperatorUnitToTuple
— MethodOperatorUnitToTuple(::Type{I}) where {I<:Index}
Construct the metric rule from the information of the Index
type.
QuantumLattices.DegreesOfFreedom.Pattern
— TypePattern <: Function
Construct a pattern for a set of Index
es.
QuantumLattices.DegreesOfFreedom.SimpleIID
— TypeSimpleIID <: IID
The id of a simple internal degree of freedom.
QuantumLattices.DegreesOfFreedom.SimpleInternal
— TypeSimpleInternal{I<:SimpleIID} <: Internal{I}
The simple internal degrees of freedom at a single point.
QuantumLattices.DegreesOfFreedom.Table
— TypeTable(hilbert::Hilbert, by::Metric=OperatorUnitToTuple(typeof(hilbert))) -> Table
Get the index-sequence table of a Hilbert space.
QuantumLattices.DegreesOfFreedom.Table
— TypeTable(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.
QuantumLattices.DegreesOfFreedom.Table
— TypeTable{I, B<:Metric} <: CompositeDict{I, Int}
The table of operator unit vs. sequence pairs.
QuantumLattices.DegreesOfFreedom.Term
— TypeTerm{K, I, V, B, C<:TermCoupling, A<:TermAmplitude, M<:TermModulate}
A term of a quantum lattice system.
QuantumLattices.DegreesOfFreedom.Term
— MethodTerm{K}(id::Symbol, value, bondkind, coupling, ishermitian::Bool; amplitude::Union{Function, Nothing}=nothing, modulate::Union{Function, Bool}=true) where K
Construct a term.
QuantumLattices.DegreesOfFreedom.TermAmplitude
— TypeTermAmplitude(amplitude::Union{Function, Nothing}=nothing)
The function for the amplitude of a term.
QuantumLattices.DegreesOfFreedom.TermCoupling
— TypeTermCoupling{E<:Coupling, C} <: TermFunction
The function for the coupling of a term.
QuantumLattices.DegreesOfFreedom.TermFunction
— TypeTermFunction <: Function
Abstract type for concrete term functions.
QuantumLattices.DegreesOfFreedom.TermModulate
— TypeTermModulate(id::Symbol, modulate::Function)
TermModulate(id::Symbol, modulate::Bool)
The function for the modulation of a term.
QuantumLattices.DegreesOfFreedom.@indexes
— Macro@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.
Base.:*
— Method*(cp₁::Coupling, cp₂::Coupling) -> Coupling
Get the multiplication between two coupling.
Base.:*
— Method*(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 MatrixCoupling
s and MatrixCouplingProd
s.
Base.:*
— Method*(constraint₁::Constraint, constraint₂::Constraint) -> Constraint
Get the combination of two sets of constraints.
Base.:+
— Method+(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 MatrixCoupling
s and MatrixCouplingProd
s.
Base.:/
— Method/(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.
Base.:^
— Method^(mc::Union{MatrixCoupling, MatrixCouplingProd, MatrixCouplingSum}, n::Int) -> Union{MatrixCoupling, MatrixCouplingProd, MatrixCouplingSum}
Get the nth power of a MatrixCoupling
/MatrixCouplingProd
/MatrixCouplingSum
.
Base.adjoint
— Methodadjoint(index::CompositeIndex) -> typeof(index)
Get the adjoint of an operator id.
Base.adjoint
— Methodadjoint(index::Index) -> typeof(index)
Get the adjoint of an index.
Base.filter
— Methodfilter(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
.
Base.filter
— Methodfilter(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
.
Base.filter
— Methodfilter(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
.
Base.filter
— Methodfilter(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
.
Base.getindex
— Methodgetindex(table::Table, operatorunit::OperatorUnit) -> Int
Inquiry the sequence of an operator unit.
Base.haskey
— Methodhaskey(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.
Base.keys
— Methodkeys(bound::Boundary) -> Tuple{Vararg{Symbol}}
keys(::Type{<:Boundary{Names}}) where Names -> Names
Get the names of the boundary parameters.
Base.keys
— Methodkeys(::OperatorUnitToTuple{Fields}) where Fields -> Fields
keys(::Type{<:OperatorUnitToTuple{Fields}}) where Fields -> Fields
Get the names of the selected fields.
Base.match
— Methodmatch(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.
Base.match
— Methodmatch(constraint::Constraint, indexes::Tuple{Vararg{Index}}) -> Bool
Judge whether a composite iid fulfills a constraint.
Base.merge!
— Methodmerge!(bound::Boundary, another::Boundary) -> typeof(bound)
Merge the values and vectors of the twisted boundary condition from another one.
Base.one
— Methodone(term::Term) -> Term
Get a unit term.
Base.replace
— Methodreplace(bound::Boundary; values=bound.values, vectors=bound.vectors) -> Boundary
Replace the values or vectors of a twisted boundary condition and get the new one.
The plain boundary condition keeps plain even when replaced with new values or new vectors.
Base.replace
— Methodreplace(term::Term; kwargs...) -> Term
Replace some attributes of a term with key word arguments.
Base.repr
— Methodrepr(term::Term, bond::Bond, hilbert::Hilbert) -> String
Get the repr representation of a term on a bond with a given Hilbert space.
Base.union
— Methodunion(tables::Table...) -> Table
Unite several operator unit vs. sequence tables.
Base.valtype
— Methodvaltype(term::Term)
valtype(::Type{<:Term)
Get the value type of a term.
Base.valtype
— Methodvaltype(::Type{<:OperatorUnitToTuple}, ::Type{<:Index})
Get the valtype of applying an OperatorUnitToTuple
rule to an Index
.
Base.zero
— Methodzero(term::Term) -> Term
Get a zero term.
LaTeXStrings.latexstring
— Methodlatexstring(coupling::Coupling) -> String
Convert a Coupling
to the latex format.
LinearAlgebra.rank
— Methodrank(ciid::CompositeIID) -> Int
rank(::Type{<:CompositeIID{T}}) where {T<:Tuple{Vararg{SimpleIID}}} -> Int
Get the number of simple iids in a composite iid.
LinearAlgebra.rank
— Methodrank(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.
LinearAlgebra.rank
— Methodrank(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.
LinearAlgebra.rank
— Methodrank(constraint::Constraint) -> Int
rank(::Type{<:Constraint{RS}}) where RS -> Int
Get the rank of the coupling indexes that a constraint can apply.
LinearAlgebra.rank
— Methodrank(term::Term) -> Int
rank(::Type{<:Term) -> Int
Get the rank of a term.
QuantumLattices.:⊕
— Method⊕(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.
QuantumLattices.:⊗
— Method⊗(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.
QuantumLattices.:⊗
— Method⊗(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.
QuantumLattices.DegreesOfFreedom.iidtype
— Methodiidtype(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.
QuantumLattices.DegreesOfFreedom.iidtype
— Methodiidtype(index::Index)
iidtype(::Type{I}) where {I<:Index}
Get the type of the internal part of an index.
QuantumLattices.DegreesOfFreedom.indextype
— Methodindextype(::AbstractCompositeIndex)
indextype(::Type{<:AbstractCompositeIndex})
Get the index type of a composite index.
QuantumLattices.DegreesOfFreedom.indextype
— Methodindextype(I::Type{<:SimpleInternal}, P::Type{<:Point}, ::Val)
Get the compatible composite index type based on the information of its internal part.
QuantumLattices.DegreesOfFreedom.ismodulatable
— Methodismodulatable(term::Term) -> Bool
ismodulatable(::Type{<:Term}) -> Bool
Judge whether a term could be modulated by its modulate function.
QuantumLattices.DegreesOfFreedom.plain
— Functionplain
Plain boundary condition without any twist.
QuantumLattices.DegreesOfFreedom.sitestructure
— Methodsitestructure(::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.
QuantumLattices.DegreesOfFreedom.statistics
— Methodstatistics(index::Index) -> Symbol
statistics(::Type{<:Index{I}}) where {I<:SimpleIID} -> Symbol
Get the statistics of an index.
QuantumLattices.DegreesOfFreedom.statistics
— Methodstatistics(index::AbstractCompositeIndex) -> Symbol
statistics(::Type{<:AbstractCompositeIndex{I}}) where {I<:Index} -> Symbol
Get the statistics of a composite operator id.
QuantumLattices.DegreesOfFreedom.statistics
— Methodstatistics(i::SimpleInternal) -> Symbol
statistics(::Type{<:SimpleInternal{I}}) where {I<:SimpleIID} -> Symbol
Get the statistics of a simple internal space.
QuantumLattices.QuantumOperators.optype
— Methodoptype(::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.
QuantumLattices.QuantumOperators.script
— Methodscript(::Val{:integercoordinate}, index::CompositeIndex; vectors, kwargs...)
Get the integral script of the icoordinate of an composite index.
QuantumLattices.QuantumOperators.script
— Methodscript(::Val{:rcoordinate}, index::CompositeIndex; kwargs...) -> String
script(::Val{:icoordinate}, index::CompositeIndex; kwargs...) -> String
Get the rcoordinate/icoordinate
script of a composite index.
QuantumLattices.QuantumOperators.script
— Methodscript(::Val{:site}, index::Index; kwargs...) -> String
script(attr::Val, index::Index; kwargs...) -> String
Get the required script of a spin index.
QuantumLattices.QuantumOperators.script
— Methodscript(::Val{attr}, index::CompositeIndex; kwargs...) where attr
Get the attr
script of an index, which is contained in its index.
QuantumLattices.Spatials.icoordinate
— Methodicoordinate(opt::Operator{<:Number, <:ID{CompositeIndex}}) -> SVector
Get the whole icoordinate of an operator.
QuantumLattices.Spatials.rcoordinate
— Methodrcoordinate(opt::Operator{<:Number, <:ID{CompositeIndex}}) -> SVector
Get the whole rcoordinate of an operator.
QuantumLattices.expand!
— Methodexpand!(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 operatorsfalse
: "Hermitian whole" of the generated operators
QuantumLattices.expand
— Methodexpand(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.
QuantumLattices.expand
— Methodexpand(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.
QuantumLattices.expand
— Methodexpand(::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.
QuantumLattices.id
— Methodid(term::Term) -> Symbol
id(::Type{<:Term) -> Symbol
Get the id of a term.
QuantumLattices.kind
— Methodkind(term::Term) -> Symbol
kind(::Type{<:Term) -> Symbol
Get the kind of a term.
QuantumLattices.permute
— Methodpermute(index₁::CompositeIndex, index₂::CompositeIndex) -> Tuple{Vararg{Operator}}
Get the permutation of two composite indexes.
QuantumLattices.permute
— Methodpermute(index₁::Index, index₂::Index) -> Tuple{Vararg{Operator}}
Get the permutation of two indexes.
QuantumLattices.reset!
— Methodreset!(table::Table, operatorunits::AbstractVector{<:OperatorUnit}) -> Table
Reset a table by a new set of operatorunits.
QuantumLattices.reset!
— Methodreset!(table::Table, hilbert::Hilbert) -> Table
Reset a table by a Hilbert space.
QuantumLattices.update!
— Methodupdate!(bound::Boundary; parameters...) -> Boundary
Update the values of the boundary twisted phase.
QuantumLattices.update!
— Methodupdate!(term::Term, args...; kwargs...) -> Term
Update the value of a term by its modulate
function.