Quantum Systems

const DMˣ = SparseMatrixCSC([0 0 0; 0 0 1; 0 -1 0])
const DMʸ = SparseMatrixCSC([0 0 -1; 0 0 0; 1 0 0])
const DMᶻ = SparseMatrixCSC([0 1 0; -1 0 0; 0 0 0])

DM coupling matrices DMˣ, DMʸ and DMᶻ.

FockTerm

Type alias for Union{Onsite, Hopping, Pairing, Hubbard, InterOrbitalInterSpin, InterOrbitalIntraSpin, SpinFlip, PairHopping, Coulomb}.

const Isingˣ = SparseMatrixCSC([1 0 0; 0 0 0; 0 0 0])
const Isingʸ = SparseMatrixCSC([0 0 0; 0 1 0; 0 0 0])
const Isingᶻ = SparseMatrixCSC([0 0 0; 0 0 0; 0 0 1])

Ising coupling matrices Isingˣ, Isingʸ and Isingᶻ.

const Lˣ = SparseMatrixCSC([0 0 0; 0 0 1im; 0 -1im 0])
const Lʸ = SparseMatrixCSC([0 0 -1im; 0 0 0; 1im 0 0])
const Lᶻ = SparseMatrixCSC([0 1im 0; -1im 0 0; 0 0 0])

Three-dimensional rotation generators Lˣ, Lʸ and Lᶻ.

PhononTerm

Type alias for Union{Kinetic, Hooke, Elastic}.

annihilation

Indicate that the nambu index is annihilation.

*(f₁::Operator{<:Number, <:OneAtLeast{FockIndex{:f}}}, f₂::Operator{<:Number, <:OneAtLeast{FockIndex{:f}}}) -> Operator
*(f₁::Operator{<:Number, <:OneAtLeast{Index{<:FockIndex{:f}, Int}}}, f₂::Operator{<:Number, <:OneAtLeast{Index{<:FockIndex{:f}, Int}}}) -> Operator
*(f₁::Operator{<:Number, <:OneAtLeast{CompositeIndex{<:Index{<:FockIndex{:f}, Int}}}}, f₂::Operator{<:Number, <:OneAtLeast{CompositeIndex{<:Index{<:FockIndex{:f}, Int}}}}) -> Operator

Get the multiplication of two fermionic Fock operators.

creation

Indicate that the nambu index is creation.

latexofbosons

Default LaTeX format of a bosonic index.

latexoffermions

Default LaTeX format of a fermionic index.

latexofparticles

Default LaTeX format of a wildcard Fock index.

latexofphonons

Default LaTeX format of a phonon index.

latexofspins

Default LaTeX format of a spin index.

const Γˣ = SparseMatrixCSC([0 0 0; 0 0 1; 0 1 0])
const Γʸ = SparseMatrixCSC([0 0 1; 0 0 0; 1 0 0])
const Γᶻ = SparseMatrixCSC([0 1 0; 1 0 0; 0 0 0])

Γ coupling matrices Γˣ, Γʸ and Γᶻ.

const Γ′ˣ = SparseMatrixCSC([0 1 1; 1 0 0; 1 0 0])
const Γ′ʸ = SparseMatrixCSC([0 1 0; 1 0 1; 0 1 0])
const Γ′ᶻ = SparseMatrixCSC([0 0 1; 0 0 1; 1 1 0])

Γ′ coupling matrices Γ′ˣ, Γ′ʸ and Γ′ᶻ.

const σ⁰ = SparseMatrixCSC([1 0; 0 1])
const σˣ = SparseMatrixCSC([0 1; 1 0])
const σʸ = SparseMatrixCSC([0 -1im; 1im 0])
const σᶻ = SparseMatrixCSC([1 0; 0 -1])
const σ⁺ = SparseMatrixCSC([0 1; 0 0])
const σ⁻ = SparseMatrixCSC([0 0; 1 0])
const σ¹¹ = SparseMatrixCSC([1 0; 0 0])
const σ¹² = SparseMatrixCSC([0 1; 0 0])
const σ²¹ = SparseMatrixCSC([0 0; 1 0])
const σ²² = SparseMatrixCSC([0 0; 0 1])

Pauli matrices σ⁰, σˣ, σʸ, σᶻ, σ⁺, σ⁻, σ¹¹, σ¹², σ²¹ and σ²².

MatrixCoupling{F}(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}, nambu::AbstractMatrix) where {F<:FockIndex}

Construct a matrix coupling for Fock systems.

MatrixCoupling{P}(sites::Union{NTuple{2, Ordinal}, Colon}, matrix::AbstractMatrix; rows::Union{AbstractVector, Nothing}=nothing, cols::Union{AbstractVector, Nothing}=nothing) where {P<:PhononIndex{:u}}

Construct a set of Couplings corresponding to the dynamical matrix of phonons.

MatrixCoupling{S}(sites::Union{NTuple{2, Ordinal}, Colon}, matrix::AbstractMatrix; rows::AbstractVector=SVector('x', 'y', 'z'), cols::AbstractVector=SVector('x', 'y', 'z')) where {S<:SpinIndex}

Construct a matrix coupling for spin systems.

Coulomb(id::Symbol, value, bondkind, coupling=Coupling(𝕕⁺(:, :, :), 𝕕(:, :, :))^2; ishermitian::Bool=true, amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Coulomb term.

Type alias for Term{:Coulomb, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

DM(
    id::Symbol,
    value,
    bondkind,
    vectors::Pair{<:AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}}, <:Union{Char, AbstractVector{<:Number}}}...;
    unit::Symbol=:degree,
    amplitude::Union{Function, Nothing}=nothing,
    ismodulatable::Bool=true
)

DM term. Since DM term is antisymmetric on every bond, only the positive direction of a bond is needed. The negative direction of a bond can be handled automatically by this function.

Here, vectors specify the unit DM vector on every bond in the form [bond₁, bond₂, ...]=>v, where bondᵢ can be

1. a Number specifying the azimuth angle of a bond in the 2-dimensional case, or
2. a Tuple{Number, Number} specifying the polar and azimuth angle pairs of a bond in the 3-dimensional case, or
3. an AbstractVector{<:Number} specifying the direction of a bond;

and v can be

1. a Char of 'x', 'y' or 'z', indicating the unit DM vector on the set of bonds is along the x, y or z direction, or
2. an AbstractVector{<:Number}, specifying the direction of the DM vector on the set of bonds.

Type alias for Term{:DM, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

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

Generic elastic energy of phonons.

Type alias for Term{:Elastic, id, V, B, C<:TermCoupling, A<:TermAmplitude}

Fock{T} <: SimpleInternal{FockIndex{T, Int, Rational{Int}}}

Fock space of Fock generators at a single point.

FockIndex{T, O<:Union{Int, Symbol, Colon}, S<:Union{Rational{Int}, Symbol, Colon}} <: InternalIndex

Fock index, i.e., the internal index to specify the generators of a Fock space.

FockIndex(orbital::Union{Int, Symbol, Colon}, spin::Union{Rational{Int}, Int, Symbol, Colon}, nambu::Int)
FockIndex{T}(orbital::Union{Int, Symbol, Colon}, spin::Union{Rational{Int}, Int, Symbol, Colon}, nambu::Int) where T
FockIndex{T, O, S}(orbital::Union{Int, Symbol, Colon}, spin::Union{Rational{Int}, Symbol, Colon}, nambu::Int) where {T, O, S}

Construct a Fock index.

Heisenberg(id::Symbol, value, bondkind; form::Symbol=Symbol("+-z"), amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Heisenberg term.

Type alias for Term{:Heisenberg, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

Hooke(id::Symbol, value, bondkind; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Potential energy of phonons by the Hooke's law.

Type alias for Term{:Hooke, id, V, B, C<:TermCoupling, A<:TermAmplitude}

Hopping(id::Symbol, value, bondkind, coupling=Coupling(𝕕⁺(:, :, :), 𝕕(:, :, :)); amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Hopping term.

Type alias for Term{:Hopping, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

Hubbard(id::Symbol, value; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Hubbard term.

Type alias for Term{:Hubbard, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

InterOrbitalInterSpin(id::Symbol, value; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Interorbital-interspin term.

Type alias for Term{:InterOrbitalInterSpin, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

InterOrbitalIntraSpin(id::Symbol, value; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Interorbital-intraspin term.

Type alias for Term{:InterOrbitalIntraSpin, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

Ising(id::Symbol, value, bondkind, direction::Char; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Ising term.

Type alias for Term{:Ising, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

Kinetic(id::Symbol, value; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Kinetic energy of phonons.

Type alias for Term{:Kinetic, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

Kitaev(
    id::Symbol, value, bondkind;
    x::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    y::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    z::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    unit::Symbol=:degree,
    amplitude::Union{Function, Nothing}=nothing,
    ismodulatable::Bool=true
)

Kitaev term. Since Kitaev term is symmetric on every bond, only one direction of a bond is needed. The inverse direction of a bond can be handled automatically by this function.

Here, x, y and z assign the x-bonds, y-bonds, and z-bonds, respectively, with each kind of bond can be

1. a Number specifying the azimuth angle of a bond in the 2-dimensional case, or
2. a Tuple{Number, Number} specifying the polar and azimuth angle pairs of a bond in the 3-dimensional case, or
3. an AbstractVector{<:Number} specifying the direction of a bond.

Type alias for Term{:Kitaev, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

Onsite(id::Symbol, value, coupling=Coupling(𝕕⁺(:, :, :), 𝕕(:, :, :)); ishermitian::Bool=true, amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Onsite term.

Type alias for Term{:Onsite, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

PairHopping(id::Symbol, value; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Pair-hopping term.

Type alias for Term{:PairHopping, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

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

Pairing term.

Type alias for Term{:Pairing, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

Phonon{K} <: SimpleInternal{PhononIndex{K, Char}}

Phonon space of lattice vibration generators at a single point.

Phonon(ndirection::Integer)
Phonon{K}(ndirection::Integer) where K

Construct a phonon space.

PhononIndex{K, D<:Union{Char, Symbol, Colon}} <: InternalIndex

Phonon index, i.e., the internal index to specify the generators of the vibration of a lattice point.

PhononIndex{K}(direction::Union{Char, Symbol, Colon}) where K
PhononIndex{K, D}(direction::Union{Char, Symbol, Colon}) where {K, D}

Construct a phonon index.

SingleIonAnisotropy(id::Symbol, value, direction::Char; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)
SingleIonAnisotropy(id::Symbol, value, matrix::AbstractMatrix{<:Number}; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Single ion anisotropy term.

Type alias for Term{:SingleIonAnisotropy, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

Spin{S} <: SimpleInternal{SpinIndex{S, Char}}

Spin space of spin generators at a single point.

SpinFlip(id::Symbol, value; amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true)

Spin-flip term.

Type alias for Term{:SpinFlip, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

SpinIndex{S, T<:Union{Char, Symbol, Colon}} <: InternalIndex

Spin index, i.e., the internal index to specify the generators of a spin space.

SpinIndex(tag::Union{Char, Symbol, Colon})
SpinIndex{S}(tag::Union{Char, Symbol, Colon}) where S
SpinIndex{S, T}(tag::Union{Char, Symbol, Colon}) where {S, T}

Construct a spin index.

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

Generic spin term.

Type alias for Term{:SpinTerm, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

Zeeman(
    id::Symbol, value, direction::Char, g::Number=1;
    amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true
)
Zeeman(
    id::Symbol, value, direction::Union{AbstractVector{<:Number}, Tuple{Number, Number}}, g::Union{Number, AbstractMatrix{<:Number}}=1;
    unit::Symbol=:degree, amplitude::Union{Function, Nothing}=nothing, ismodulatable::Bool=true
)

Zeeman term.

Type alias for Term{:Zeeman, id, V, Int, C<:TermCoupling, A<:TermAmplitude}.

Γ(
    id::Symbol, value, bondkind;
    x::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    y::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    z::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    unit::Symbol=:degree,
    amplitude::Union{Function, Nothing}=nothing,
    ismodulatable::Bool=true
)

Γ Term. Since Γ term is symmetric on every bond, only one direction of a bond is needed. The inverse direction of a bond can be handled automatically by this function.

Here, x, y and z assign the x-bonds, y-bonds, and z-bonds, respectively, with each kind of bond can be

1. a Number specifying the azimuth angle of a bond in the 2-dimensional case, or
2. a Tuple{Number, Number} specifying the polar and azimuth angle pairs of a bond in the 3-dimensional case, or
3. an AbstractVector{<:Number} specifying the direction of a bond.

Type alias for Term{:Γ, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

Γ′(
    id::Symbol, value, bondkind;
    x::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    y::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    z::AbstractVector{<:Union{Number, Tuple{Number, Number}, AbstractVector{<:Number}}},
    unit::Symbol=:degree,
    amplitude::Union{Function, Nothing}=nothing,
    ismodulatable::Bool=true
)

Γ′ Term. Since Γ′ term is symmetric on every bond, only one direction of a bond is needed. The inverse direction of a bond can be handled automatically by this function.

Here, x, y and z assign the x-bonds, y-bonds, and z-bonds, respectively, with each bond can be

1. a Number specifying the azimuth angle of a bond in the 2-dimensional case, or
2. a Tuple{Number, Number} specifying the polar and azimuth angle pairs of a bond in the 3-dimensional case, or
3. an AbstractVector{<:Number} specifying the direction of a bond.

Type alias for Term{:Γ′, id, V, B, C<:TermCoupling, A<:TermAmplitude}.

𝕊(tag) -> SpinIndex
𝕊(site, tag) -> Index{<:SpinIndex}
𝕊(site, tag, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:SpinIndex}}

𝕊{S}(tag) where S -> SpinIndex{S}
𝕊{S}(site, tag) where S -> Index{<:SpinIndex{S}}
𝕊{S}(site, tag, rcoordinate, icoordinate) where S -> CoordinatedIndex{<:Index{<:SpinIndex{S}}}

Convenient construction of SpinIndex, Index{<:SpinIndex}, CoordinatedIndex{<:Index{<:SpinIndex}}.

angle(id::CoordinatedIndex{<:Index{<:FockIndex}}, vectors::AbstractVector{<:AbstractVector{<:Number}}, values::AbstractVector{<:Number}) -> Complex{<:Number}

Get the twist phase.

matrix(index::Union{SpinIndex{S, Char}, Index{SpinIndex{S, Char}}, CompositeIndex{<:Index{SpinIndex{S, Char}}}}, dtype::Type{<:Number}=ComplexF64) where S -> Matrix{dtype}

Get the matrix representation of an index acting on the local spin space.

script(index::FockIndex, ::Val{:orbital}; kwargs...) -> String
script(index::FockIndex, ::Val{:spin}; kwargs...) -> String
script(index::FockIndex, ::Val{:spinsym}; kwargs...) -> String
script(index::FockIndex, ::Val{:nambu}; kwargs...) -> String

Get the requested script of a Fock index.

script(index::PhononIndex, ::Val{:direction}; kwargs...) -> String

Get the requested script of a phonon index.

script(index::SpinIndex, ::Val{:tag}; kwargs...) -> String

Get the requested script of a spin index.

isannihilation(index::FockIndex) -> Bool
isannihilation(index::Index) -> Bool
isannihilation(index::CompositeIndex) -> Bool

Judge whether the nambu index is annihilation.

iscreation(index::FockIndex) -> Bool
iscreation(index::Index) -> Bool
iscreation(index::CompositeIndex) -> Bool

Judge whether the nambu index is creation.

isnormalordered(opt::Operator{<:Number, <:ZeroAtLeast{Union{CompositeIndex{<:Index{<:FockIndex}}, Index{<:FockIndex}, FockIndex}}}) -> Bool

Judge whether an operator is normal ordered.

totalspin(::SpinIndex) -> Rational{Int}/Int/Colon
totalspin(::Type{<:SpinIndex}) -> Rational{Int}/Int/Colon/Float64

totalspin(::Index{<:SpinIndex}) -> Rational{Int}/Int/Colon
totalspin(::Type{<:Index{<:SpinIndex}}) -> Rational{Int}/Int/Colon/Float64

totalspin(::CompositeIndex{<:Index{<:SpinIndex}}) -> Rational{Int}/Int/Colon
totalspin(::Type{<:CompositeIndex{<:Index{<:SpinIndex}}}) -> Rational{Int}/Int/Colon/Float64

Get the total spin.

totalspin(::Spin) -> Rational{Int}/Int/Colon
totalspin(::Type{<:Spin}) -> Rational{Int}/Int/Colon

Get the total spin.

𝕊ᵀ𝕊(sites::Union{NTuple{2, Ordinal}, Colon}, matrix::AbstractMatrix; rows::AbstractVector=SVector('x', 'y', 'z'), cols::AbstractVector=SVector('x', 'y', 'z')) -> MatrixCoupling

Construct a matrix coupling for spin system.

𝕒(orbital, spin) -> FockIndex{:b}
𝕒(site, orbital, spin) -> Index{<:FockIndex{:b}}
𝕒(site, orbital, spin, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:FockIndex{:b}}}

Convenient construction of FockIndex{:b}, Index{<:FockIndex{:b}}, CoordinatedIndex{<:Index{<:FockIndex{:b}}} with the nambu attribute being annihilation.

𝕒⁺(orbital, spin) -> FockIndex{:b}
𝕒⁺(site, orbital, spin) -> Index{<:FockIndex{:b}}
𝕒⁺(site, orbital, spin, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:FockIndex{:b}}}

Convenient construction of FockIndex{:b}, Index{<:FockIndex{:b}}, CoordinatedIndex{<:Index{<:FockIndex{:b}}} with the nambu attribute being creation.

𝕔(orbital, spin) -> FockIndex{:f}
𝕔(site, orbital, spin) -> Index{<:FockIndex{:f}}
𝕔(site, orbital, spin, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:FockIndex{:f}}}

Convenient construction of FockIndex{:f}, Index{<:FockIndex{:f}}, CoordinatedIndex{<:Index{<:FockIndex{f}}} with the nambu attribute being annihilation.

𝕔⁺(orbital, spin) -> FockIndex{:f}
𝕔⁺(site, orbital, spin) -> Index{<:FockIndex{:f}}
𝕔⁺(site, orbital, spin, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:FockIndex{:f}}}

Convenient construction of FockIndex{:f}, Index{<:FockIndex{:f}}, CoordinatedIndex{<:Index{<:FockIndex{f}}} with the nambu attribute being creation.

𝕔⁺𝕔(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕔⁺𝕔⁺(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕔𝕔(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕔𝕔⁺(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling

𝕒⁺𝕒(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕒⁺𝕒⁺(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕒𝕒(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕒𝕒⁺(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling

𝕕⁺𝕕(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕕⁺𝕕⁺(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕕𝕕(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling
𝕕𝕕⁺(sites::Union{NTuple{2, Ordinal}, Colon}, orbital::Union{AbstractMatrix, Colon}, spin::Union{AbstractMatrix, Colon}) -> MatrixCoupling

Construct a matrix coupling for Fock systems.

𝕕(orbital, spin) -> FockIndex{:}
𝕕(site, orbital, spin) -> Index{<:FockIndex{:}}
𝕕(site, orbital, spin, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:FockIndex{:}}}

Convenient construction of FockIndex{:}, Index{<:FockIndex{:}}, CoordinatedIndex{<:Index{<:FockIndex{:}}} with the nambu attribute being annihilation.

𝕕⁺(orbital, spin) -> FockIndex{:}
𝕕⁺(site, orbital, spin) -> Index{<:FockIndex{:}}
𝕕⁺(site, orbital, spin, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:FockIndex{:}}}

Convenient construction of FockIndex{:}, Index{<:FockIndex{:}}, CoordinatedIndex{<:Index{<:FockIndex{:}}} with the nambu attribute being creation.

𝕡(direction) -> PhononIndex{:p}
𝕡(site, direction) -> Index{<:PhononIndex{:p}}
𝕡(site, direction, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:PhononIndex{:p}}}

Convenient construction of SpinIndex{:p}, Index{<:SpinIndex{:p}}, CoordinatedIndex{<:Index{<:SpinIndex{:p}}}.

𝕦(direction) -> PhononIndex{:u}
𝕦(site, direction) -> Index{<:PhononIndex{:u}}
𝕦(site, direction, rcoordinate, icoordinate) -> CoordinatedIndex{<:Index{<:PhononIndex{:u}}}

Convenient construction of SpinIndex{:u}, Index{<:SpinIndex{:u}}, CoordinatedIndex{<:Index{<:SpinIndex{:u}}}.

𝕦ᵀ𝕦(sites::Union{NTuple{2, Ordinal}, Colon}, matrix::AbstractMatrix; rows::Union{AbstractVector, Nothing}=nothing, cols::Union{AbstractVector, Nothing}=nothing) -> MatrixCoupling

Construct a set of Couplings corresponding to the dynamical matrix of phonons.

expand(pnc::Coupling{<:Number, <:Pattern{<:NTuple{2, Index{<:PhononIndex{:u}}}}}, ::Val{:Hooke}, bond::Bond, hilbert::Hilbert) -> VectorSpace

Expand the default phonon potential coupling on a given bond.

kind(index::PhononIndex) -> Symbol
kind(::Type{<:PhononIndex{K}}) where K -> Symbol

kind(index::Index{<:PhononIndex}) -> Symbol
kind(::Type{<:Index{<:PhononIndex{K}}}) where K -> Symbol

kind(index::CoordinatedIndex{<:Index{<:PhononIndex}}) -> Symbol
kind(::Type{<:CoordinatedIndex{<:Index{<:PhononIndex{K}}}}) where K -> Symbol

Get the kind of a phonon index.

kind(pn::Phonon)
kind(::Type{<:Phonon{K}}) where K

Get the kind of a phonon space.

permute(id₁::FockIndex, id₂::FockIndex) -> ZeroAtLeast{Operator}

Permute two Fock indexes and get the result.

permute(id₁::PhononIndex, id₂::PhononIndex) -> ZeroAtLeast{Operator}

Permute two phonon indexes and get the result.

permute(id₁::SpinIndex, id₂::SpinIndex) -> ZeroAtLeast{Operator}

Permute two spin indexes and get the result.