Fock package

ANNIHILATION

Indicate that the nambu index is ANNIHILATION.

CREATION

Indicate that the nambu index is CREATION.

MAJORANA

Indicate that the nambu index is MAJORANA.

bdefaultlatex

The default LaTeX format for a bosonic oid.

fdefaultlatex

The default LaTeX format for a fermionic oid.

AbstractFockOperator{V<:Number, I<:ID{OID{<:FIndex}}} <: Operator{V, I}

Abstract type for all Fock operators.

BOperator{V<:Number, I<:ID{OID{<:FIndex{:b}}}} <: AbstractFockOperator{V, I}

Bosonic Fock operator.

Coulomb(id::Symbol, value::Any, bondkind::Int=1;
    couplings::Union{Function, Coupling, Couplings, Nothing}=nothing,
    amplitude::Union{Function, Nothing}=nothing,
    modulate::Union{Function, Bool}=false
    )

Coulomb term.

Type alias for Term{:Coulomb, 4, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

FCID{A<:Tuple, N<:Tuple} <: SimpleID

The id of the atoms and nambus part of a Fock coupling.

FID <: IID

The Fock id.

FID{ST}(; orbital::Int=1, spin::Int=1, nambu::Int=ANNIHILATION) where ST

Create a Fock id.

FIndex{ST, S} <: Index{PID{S}, FID{ST}}

The Fock index.

FIndex(pid::PID, fid::FID) -> FIndex

Construct a Fock index by a pid and an fid.

FOperator{V<:Number, I<:ID{OID{<:FIndex{:f}}}} <: AbstractFockOperator{V, I}

Fermionic Fock operator.

Fock{ST} <: Internal{FID{ST}}

The Fock interanl degrees of freedom.

Fock{ST}(; atom::Int=1, norbital::Int=1, nspin::Int=2, nnambu::Int=2) where ST

Construct a Fock degrees of freedom.

FockCoupling{V, A<:Tuple, N<:Tuple, O<:Subscripts, S<:Subscripts, I<:Tuple{FCID, SubID, SubID}} <: Coupling{V, I}

Fock coupling.

FockCoupling{N}(value::Number=1;
    atoms::Union{NTuple{N, Int}, Nothing}=nothing,
    nambus::Union{NTuple{N, Int}, Nothing}=nothing,
    orbitals::Union{NTuple{N, Int}, Subscripts, Nothing}=nothing,
    spins::Union{NTuple{N, Int}, Subscripts, Nothing}=nothing
    ) where N

Hopping(id::Symbol, value::Any, bondkind::Int=1;
    couplings::Union{Function, Coupling, Couplings, Nothing}=nothing,
    amplitude::Union{Function, Nothing}=nothing,
    modulate::Union{Function, Bool}=false,
    )

Hopping term.

Type alias for Term{:Hopping, 2, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

Hubbard(id::Symbol, value::Any; amplitude::Union{Function, Nothing}=nothing, modulate::Union{Function, Bool}=false)

Hubbard term.

Type alias for Term{:Hubbard, 4, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

InterOrbitalInterSpin(id::Symbol, value::Any; amplitude::Union{Function, Nothing}=nothing, modulate::Union{Function, Bool}=false)

Interorbital-interspin term.

Type alias for Term{:InterOrbitalInterSpin, 4, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

InterOrbitalIntraSpin(id::Symbol, value::Any; amplitude::Union{Function, Nothing}=nothing, modulate::Union{Function, Bool}=false)

Interorbital-intraspin term.

Type alias for Term{:InterOrbitalIntraSpin, 4, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

Onsite(id::Symbol, value::Any;
    couplings::Union{Function, Coupling, Couplings, Nothing}=nothing,
    amplitude::Union{Function, Nothing}=nothing,
    modulate::Union{Function, Bool}=false,
    )

Onsite term.

Type alias for Term{:Onsite, 2, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

PairHopping(id::Symbol, value::Any; amplitude::Union{Function, Nothing}=nothing, modulate::Union{Function, Bool}=false)

Pair-hopping term.

Type alias for Term{:PairHopping, 4, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

Pairing(id::Symbol, value::Any, bondkind::Int=0;
    couplings::Union{Function, Coupling, Couplings, Nothing}=nothing,
    amplitude::Union{Function, Nothing}=nothing,
    modulate::Union{Function, Bool}=false,
    )

Pairing term.

Type alias for Term{:Pairing, 2, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

SpinFlip(id::Symbol, value::Any; amplitude::Union{Function, Nothing}=nothing, modulate::Union{Function, Bool}=false)

Spin-flip term.

Type alias for Term{:SpinFlip, 4, id, V, Int, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

fc"..." -> FockCoupling

Construct a FockCoupling from a literal string.

σʸ"sp" -> Couplings
σʸ"ob" -> Couplings
σʸ"sl" -> Couplings
σʸ"ph" -> Couplings

The Pauli matrix σʸ, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σˣ"sp" -> Couplings
σˣ"ob" -> Couplings
σˣ"sl" -> Couplings
σˣ"ph" -> Couplings

The Pauli matrix σˣ, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σᶻ"sp" -> Couplings
σᶻ"ob" -> Couplings
σᶻ"sl" -> Couplings
σᶻ"ph" -> Couplings

The Pauli matrix σᶻ, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σ⁰"sp" -> Couplings
σ⁰"ob" -> Couplings
σ⁰"sl" -> Couplings
σ⁰"ph" -> Couplings

The Pauli matrix σ⁰, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σ⁺"sp" -> Couplings
σ⁺"ob" -> Couplings
σ⁺"sl" -> Couplings
σ⁺"ph" -> Couplings

The Pauli matrix σ⁺, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σ⁻"sp" -> Couplings
σ⁻"ob" -> Couplings
σ⁻"sl" -> Couplings
σ⁻"ph" -> Couplings

The Pauli matrix σ⁻, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

*(f1::FOperator, f2::FOperator) -> Union{Nothing, FOperator}

Get the multiplication of two fermionic Fock operators.

*(fc₁::FockCoupling, fc₂::FockCoupling) -> FockCoupling

Get the multiplication between two Fock couplings.

angle(id::OID{<:FIndex}, vectors::AbstractVector{<:AbstractVector{Float}}, values::AbstractVector{Float}) -> Complex{Float}

Get the twist phase corresponding to a Fock oid.

repr(fc::FockCoupling) -> String

Get the repr representation of a Fock coupling.

show(io::IO, fc::FockCoupling)

Show a Fock coupling.

script(::Val{:site}, index::FIndex; kwargs...) -> Int
script(::Val{:orbital}, index::FIndex; kwargs...) -> Int
script(::Val{:spinint}, index::FIndex; kwargs...) -> Int
script(::Val{:spinsym}, index::FIndex; kwargs...) -> String
script(::Val{:nambu}, index::FIndex; kwargs...) -> String

Get the required script of a Fock index.

isnormalordered(opt::AbstractFockOperator) -> Bool

Judge whether a Fock operator is normal ordered.

nambufockindextotuple

Indicate that the choosed fields are (:scope, :nambu, :site, :orbital, :spin) when converting a Fock index to tuple.

statistics(opt::BOperator) -> Symbol
statistics(::Type{<:BOperator}) -> Symbol

Get the statistics of BOperator.

statistics(opt::FOperator) -> Symbol
statistics(::Type{<:FOperator}) -> Symbol

Get the statistics of FOperator.

usualfockindextotuple

Indicate that the choosed fields are (:scope, :site, :orbital, :spin) when converting a Fock index to tuple.

σʸ(mode::String) -> Couplings

The Pauli matrix σʸ, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σˣ(mode::String) -> Couplings

The Pauli matrix σˣ, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σᶻ(mode::String) -> Couplings

The Pauli matrix σᶻ, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σ⁰(mode::String) -> Couplings

The Pauli matrix σ⁰, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σ⁺(mode::String) -> Couplings

The Pauli matrix σ⁺, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

σ⁻(mode::String) -> Couplings

The Pauli matrix σ⁻, which can act on the space of spins("sp"), orbitals("ob"), sublattices("sl") or particle-holes("ph").

otype(T::Type{<:Term}, C::Type{<:Config{<:Fock{:f}}}, B::Type{<:AbstractBond})
otype(T::Type{<:Term}, C::Type{<:Config{<:Fock{:b}}}, B::Type{<:AbstractBond})

Get the operator type of a Fock term.

⊗(fc₁::FockCoupling, fc₂::FockCoupling) -> FockCoupling

Get the direct product between two Fock couplings.

⋅(fc₁::FockCoupling, fc₂::FockCoupling) -> FockCoupling

Get the dot product of two rank-2 Fock couplings.

A rank-2 FockCoupling can be considered as a matrix acting on the sublattice, orbital, spin and nambu spaces. Therefore, the dot product here is defined as the multiplication between such matrices.

expand(fc::FockCoupling, points::NTuple{R, Point}, focks::NTuple{R, Fock}, info::Val) where R -> Union{FCExpand, Tuple{}}

Expand a Fock coupling with the given set of points and Fock degrees of freedom.

permute(::Type{<:BOperator}, id₁::OID{<:FIndex{:b}}, id₂::OID{<:FIndex{:b}}) -> Tuple{Vararg{BOperator}}

Permute two bosonic oid and get the result.

permute(::Type{<:FOperator}, id₁::OID{<:FIndex{:f}}, id₂::OID{<:FIndex{:f}}) -> Tuple{Vararg{FOperator}}

Permute two fermionic oid and get the result.