Built-in models

GetNeQNDiag(no :: Int64[, modul :: Int64 = 1]) :: QNDiag

Return the QNDiag of the number of electrons, implemented as

QNDiag("Ne", fill(1, no), modul)

If modul = 2, parity is returned.

GetLz2QNDiag(nm :: Int64, nf :: Int64) :: QNDiag

Return the QNDiag of twice the angular momentum $2L_z$, implemented as

QNDiag("Lz", collect(0 : nm * nf - 1) .÷ nf .* 2 .- (nm - 1))

GetFlavQNDiag(nm :: Int64, nf :: Int64, qf :: Dict{Int64, Int64}[, id :: Int64 = 1, modul :: Int64 = 1]) :: QNDiag 
GetFlavQNDiag(nm :: Int64, nf :: Int64, qf :: Vector{Int64}[, id :: Int64 = 1, modul :: Int64 = 1]) :: QNDiag

Return the QNDiag of linear combination of number of electrons in each flavour,

\[ Q = ∑_{f}q_fn_f\]

the factor $q_f$ can either be given by a length-$N_f$ vector or a dictionary containing non-zero terms. E.g., for $Q=n_{f=1}-n_{f=3}$ in a 4-flavour system, qf = [1, 0, -1, 0] or qf = Dict(1 => 1, 3 => -3). id is an index to be put in the name to distinguish. For qf given as vector, the function is implemented as

QNDiag("Sz$id", qf[collect(0 : nm * nf - 1) .% nf .+ 1], modul)

GetZnfChargeQNDiag(nm :: Int64, nf :: Int64) :: QNDiag

Return the QNDiag of a $ℤ_{N_f}$-charge,

\[ Q = ∑_{f=0}^{N_f-1}fn_f\mod N_f\]

implemented as

QNDiag("Q_Z$nf", collect(0 : nm * nf - 1) .% nf, nf)

GetPinOrbQNDiag(no :: Int64, pin_o :: Vector{Int64}[, id :: Int64 = 1]) :: QNDiag

Return the QNDiag of the number of electrons in the subset of sites pin_o, implemented as

QNDiag("Npin$i", [ o in pin_o ? 1 : 0 for o = 1 : no])

This QNDiag is useful in pinning defects, where certain subset of sites need to be set empty or filled. To empty the sites, set this QNDiag to 0 ; to fill the sites, set this QNDiag to length(pin_o). id is an index to be put in the name to distinguish.

GetParityQNOffd(nm :: Int64, nf :: Int64[, permf, fac])

Return the particle-hole transformation

\[ 𝒫: c^†_{mf}↦α_fc_{mπ_f}\]

Arguments

• nm :: Int64 and nf :: Int64 are the number of orbitals and the flavours.
• permf :: Dict{Int64, Int64}, permf :: Vector{Vector{Int64}} or Vector{Int64} gives the flavour permutation $π_f$. It is either a vector of the cycles, a vector of the target flavours, or a dictionary of the changed elements. E.g., a permutation $1↦4,2↦5,3↦3,4↦1,5↦6,6↦2$ can be expressed as [4,5,3,1,6,2], [[1,4],[2,5,6]] or Dict(1=>4,2=>5,4=>1,5=>6,6=>2). Facultative, identity by default.
• fac :: Dict{Int64, <: Number} or Vector{<: Number} gives the factor $α_f$. It is either a vector of all vectors, or a dictionary of all non-unity elements. Facultative, all unity by default.

GetFlavPermQNOffd(nm :: Int64, nf :: Int64, permf[, fac][, cyc :: Int64])

Return the flavour permutaiton transformation

\[ 𝒵: c^†_{mf}↦α_fc^†_{mπ_f}\]

Arguments

• nm :: Int64 and nf :: Int64 are the number of orbitals and the flavours.
• permf :: Dict{Int64, Int64}, permf :: Vector{Vector{Int64}} or Vector{Int64} gives the flavour permutation $π_f$. It is either a vector of the cycles, a vector of the target flavours, or a dictionary of the changed elements. E.g., a permutation $1↦4,2↦5,3↦3,4↦1,5↦6,6↦2$ can be expressed as [4,5,3,1,6,2], [[1,4],[2,5,6]] or Dict(1=>4,2=>5,4=>1,5=>6,6=>2). Facultative, identity by default.
• fac :: Dict{Int64, <: Number} or Vector{<: Number} gives the factor $α_f$. It is either a vector of all vectors, or a dictionary of all non-unity elements. Facultative, all unity by default.
• cyc :: Int64 is the period of the permutation.

GetRotyQNOffd(nm :: Int64, nf :: Int64)

Return the $π$-rotation with respect to the $y$-axis.

\[ ℛ_y: c^†_{mf}↦(-)^{m+s}c^†_{-mf}\]

GetIntMatrix(nm :: Int64, ps_pot :: Vector{<:Number}) :: Array{ComplexF64, 3}

Gives the interaction matrix $U_{m_1,m_2,m_3,m_4}$ from the pseudopotentials.

Argument

• nm :: Int64 is the number of orbitals.
• ps_pot :: Vector{<:Number} is the vector of non-zero pseudopotentials.

Output

• A nm×nm×nm array giving the interaction matrix $U_{m_1,m_2,m_3,-m_1-m_2-m_3}$.

GetDenIntTerms(nm :: Int64, nf :: Int64[, ps_pot :: Vector{<:Number}][, mat_a :: Matrix{<:Number}[, mat_b :: Matrix{<:Number}]][ ; m_kept :: Vector{Int64}]) :: Terms

Return the normal-ordered density-density term in the Hamiltonian

\[∑_{\{m_i,f_i\}}U_{m_1m_2m_3m_4}M^A_{f_1f_4}M^B_{f_2f_3}c^{†}_{m_1f_1}c^{†}_{m_2f_2}c_{m_3f_3}c_{m_4f_4}.\]

Arguments

• nm :: Int64 is the number of orbitals.
• nf :: Int64 is the number of flavours.
• ps_pot :: Vector{<:Number} is a list of numbers specifying the pseudopotentials for the interacting matrix $U_{m_1m_2m_3m_4}$. Facultative, [1.0] by default.
• mat_a :: Matrix{<:Number} is a nf×nf matrix specifying $M^A_{ff'}$. Facultative, $I_{N_f}$ by default.
• mat_b :: Matrix{<:Number} is a nf×nf matrix specifying $M^B_{ff'}$. Facultative, the Hermitian conjugate of mat_a by default.
• m_kept :: Vector{Int64} is a list of orbitals that range from 1 to nm. Facultative, if specified, only terms for which all $m_i$ are in the list are kept.

GetDenIntTerms(nm :: Int64, nf :: Int64, ps_pot :: Vector{<:Number}, mat_a :: Vector{<:AbstractMatrix{<:Number}}[, mat_b :: Vector{<:AbstractMatrix{<:Number}}][ ; m_kept :: Vector{Int64}]) :: Terms

Return the sum of a series of normal-ordered density-density term in the Hamiltonian

\[∑_{\{m_i,f_i,α\}}U_{m_1m_2m_3m_4}(M^A_{α})_{f_1f_4}(M^B_{α})_{f_2f_3}c^{†}_{m_1f_1}c^{†}_{m_2f_2}c_{m_3f_3}c_{m_4f_4}.\]

Arguments

• nm :: Int64 is the number of orbitals.
• nf :: Int64 is the number of flavours.
• ps_pot :: Vector{<:Number} is a list of numbers specifying the pseudopotentials for the interacting matrix $U_{m_1m_2m_3m_4}$. Facultative, [1.0] by default.
• mat_a :: Vector{<:AbstractMatrix{<:Number}} is a vector of nf×nf matrix specifying $(M^A_{α})_{ff'}$. Facultative, $I_{N_f}$ by default.
• mat_b :: Vector{<:AbstractMatrix{<:Number}} is a vector of nf×nf matrix specifying $(M^B_{α})_{ff'}$. Facultative, the Hermitian conjugate of mat_a by default.
• m_kept :: Vector{Int64} is a list of orbitals that range from 1 to nm. Facultative, if specified, only terms for which all $m_i$ are in the list are kept.

GetPairIntTerms(nm :: Int64, nf :: Int64, ps_pot :: Vector{<:Number}, mat_a :: Matrix{<:Number}[, mat_b :: Matrix{<:Number}][ ; m_kept :: Vector{Int64}]) :: Terms

Return the normal-ordered pair-pair interaction term in the Hamiltonian

\[∑_{\{m_i,f_i\}}U_{m_1m_2m_3m_4}M^A_{f_1f_2}M^B_{f_3f_4}c^{†}_{m_1f_1}c^{†}_{m_2f_2}c_{m_3f_3}c_{m_4f_4}.\]

Arguments

• nm :: Int64 is the number of orbitals.
• nf :: Int64 is the number of flavours.
• ps_pot :: Vector{<:Number} is a list of numbers specifying the pseudopotentials for the interacting matrix $U_{m_1m_2m_3m_4}$.
• mat_a :: Matrix{<:Number} is a nf×nf matrix specifying $M^A_{ff'}$. Facultative, $I_{N_f}$ by default.
• mat_b :: Matrix{<:Number} is a nf×nf matrix specifying $M^B_{ff'}$. Facultative, the Hermitian conjugate of mat_a by default.
• m_kept :: Vector{Int64} is a list of orbitals that range from 1 to nm. Facultative, if specified, only terms for which all $m_i$ are in the list are kept.

GetPolTerms(nm :: Int64, nf :: Int64[, mat :: Matrix{<:Number}][ ; fld_m :: Vector{<:Number}]) :: Terms

Return the polarisation term in the Hamiltonian

\[∑_{mff'}c^{†}_{mf}M_{ff'}c_{mf'}.\]

Arguments

• nm :: Int64 is the number of orbitals.
• nf :: Int64 is the number of flavours.
• mat :: Matrix{<:Number} is a nf×nf matrix specifying $M_{ff'}$. Facultative, $I_{N_f}$ by default.
• fld_m :: Vector{<:Number} gives an orbital dependent polarisation

\[∑_{mff'}h_mc^{†}_{mf}M_{ff'}c_{mf'}\]

Facultative.

GetL2Terms(nm :: Int64, nf :: Int64) :: Terms

Return the terms for the total angular momentum.

Arguments

• nm :: Int64 is the number of orbitals.
• nf :: Int64 is the number of flavours.

GetLpLzTerms(nm :: Int64, nf :: Int64) :: Tuple{Terms, Terms}

Return the a pair of terms containing $L^z$ and $L^+$

Arguments

• nm :: Int64 is the number of orbitals.
• nf :: Int64 is the number of flavours.

GetL2Terms(tms_lzlp :: Tuple{Terms, Terms}) :: Terms

Return the terms for the total angular momentum from a tuple of terms containing $L^z$ and $L^+$, implemented as

tms_lz, tms_lp = tms_lzlp 
return SimplifyTerms(tms_lz * tms_lz - tms_lz + tms_lp * tms_lp')

GetC2Terms(nm :: Int64, nf :: Int64, mat_gen :: Vector{Matrix{<:Number}}[, mat_tr :: Vector{Matrix{<:Number}}]) :: Terms

Return the terms for the quadratic Casimir of the flavour symmetry.

\[ C_2=∑_{imm'}\frac{(c^†_{mf_1}G_{i,f_1f_2}c_{mf_2})(c^†_{m'f_3}G^†_{i,f_3f_4}c_{m'f_4})}{2\operatorname{tr}G_i^†G_i}-∑_{imm'}\frac{(c^†_{mf_1}T_{i,f_1f_2}c_{mf_2})(c^†_{m'f_3}T^†_{i,f_3f_4}c_{m'f_4})}{2\operatorname{tr}T_i^†T_i}\]

where $G_i$ are the generator matrices, and $T_i$ are the trace matrices.

Arguments

• nm :: Int64 is the number of orbitals.
• nf :: Int64 is the number of flavours.
• mat_gen :: Vector{Matrix{Number}} is a list of the matrices that gives the generators. It will automatically be normalised such that its square traces to $1/2$.
• mat_tr :: Vector{Matrix{Number}} is a list of trace matrices that will be normalised automatically and substracted. Facultative.

GetC2Terms(nm :: Int64, nf :: Int64, group :: Symbol) :: Terms

Return the terms for the quadratic Casimir of the flavour symmetry for a built-in Lie-group

Arguments

• nm :: Int64 is the number of orbitals.
• nf :: Int64 is the number of flavours.
• group :: Symbol specifies the built-in Lie group.
  • :Sp gives the Casimir of $\mathrm{Sp}(N_f/2)$
  • :SU gives the Casimir of $\mathrm{SU}(N_f)$

\[\begin{aligned} C_{2,\mathrm{Sp}}&=-\frac{1}{4}(c^†_{m_1f_1}c_{m_1f_2})(c^†_{m_2f_3}c_{m_2f_4})Ω_{f_1f_3}Ω_{f_2f_4}+\frac{1}{4}(c^†_{m_1f_1}c_{m_1f_2})(c^†_{m_2f_2}c_{m_2f_1})\\ C_{2,\mathrm{SU}}&=\frac{1}{2}(c^†_{m_1f_1}c_{m_1f_2})(c^†_{m_2f_2}c_{m_2f_1})-\frac{1}{2N_f}(c^†_{m_1f_1}c_{m_1f_1})(c^†_{m_2f_2}c_{m_2f_2}) \end{aligned}\]

SphereObs

The mutable type SphereObs stores the information of a local observable (or local operator) $𝒪$ that can be decomposed into angular components.

\[ 𝒪(\Omega)=∑_{lm}𝒪_{lm}Y^{(s)}_{lm}\]

Fields

• s2 :: Int64 is twice the spin $2s$ of the observable.
• l2m :: Int64 is twice the maximal angular momentum $2l_{\max}$ of the components of the observable.
• get_comp :: Function is a function get_comp(l2 :: Int64, m2 :: Int64) :: Terms that sends the component specified by a tuple of integers $(2l,2m)$ where $|s|\leq l\leq l_{\max}, -l\leq m\leq l$ to a list of terms that specifies the expression of the component.
• stored_q :: Bool is a boolean that specifies whether or not each component of the observable is stored.
• comps :: Dict{Tuple{Int64, Int64}, Terms} stores each component of the observable in the format of a dictionary whose keys are the tuples of integers $(2l,2m)$ and values are the lists of terms that specifies the expression of the component.

SphereObs(s2 :: Int64, l2m :: Int64, get_comp :: Function) :: SphereObs

initialises the observable from $2s$, $2l_{\max}$ and the function $(l,m)↦𝒪_{lm}$.

Arguments

• s2 :: Int64 is twice the spin $2s$ of the observable.
• l2m :: Int64 is twice the maximal angular momentum $2l_{\max}$ of the components of the observable.
• get_comp :: Function is a function get_comp(l2 :: Int64, m2 :: Int64) :: Terms that sends the component specified by a tuple of integers $(2l,2m)$ where $|s|\leq s\leq l_{\max}, -l\leq m\leq l$ to a list of terms that specifies the expression of the component.

SphereObs(s2 :: Int64, l2m :: Int64, comps :: Dict{Tuple{Int64, Int64}, Terms}) :: SphereObs

initialises the observable from $2s$, $2l_{\max}$ and a list of $𝒪_{lm}$ specified by a dictionary.

Arguments

• s2 :: Int64 is twice the spin $2s$ of the observable.
• l2m :: Int64 is twice the maximal angular momentum $2l_{\max}$ of the components of the observable.
• comps :: Dict{Tuple{Int64, Int64}, Terms} stores each component of the observable in the format of a dictionary whose keys are the tuples of integers $(2l,2m)$ and values are the lists of terms that specifies the expression of the component.

StoreComps!(obs :: SphereObs)

calculates and stores each component of the observable obs and replace the function in obs by the list of calculated components.

StoreComps(obs :: SphereObs) :: SphereObs

calculates and stores each component of the observable obs and return a new observable with the list of calculated components.

*(fac :: Number, obs :: SphereObs) :: SphereObs
*(obs :: SphereObs, fac :: Number) :: SphereObs
/(obs :: SphereObs, fac :: Number) :: SphereObs
-(obs :: SphereObs) :: SphereObs

enables the multiplication of an observable with a number.

+(obs1 :: SphereObs, obs2 :: SphereObs) :: SphereObs
-(obs1 :: SphereObs, obs2 :: SphereObs) :: SphereObs

enables the addition of two observables.

adjoint(obs :: SphereObs) :: SphereObs

enables the Hermitian conjugate of a spherical observable.

\[\begin{aligned} 𝒪^†(Ω)&=∑_{lm}(𝒪_{lm})^†\bar{Y}^{(s)}_{lm}(Ω)=∑_{lm}(𝒪_{lm})^†(-1)^{s+m}Y^{(-s)}_{l,-m}(Ω)\\ (𝒪^†)_{lm}&=(-1)^{s-m}(𝒪_{l,-m})^† \end{aligned}\]

*(obs1 :: SphereObs, obs2 :: SphereObs) :: SphereObs

enables the multiplication of two observable by making use of the composition of two monopole harmonics into one.

Laplacian(obs :: SphereObs[ ; norm_r2 :: Float64]) :: SphereObs

Takes the Laplacian of an observable

\[ (∇^2𝒪)_{lm}=-l(l+1)𝒪_{lm}\]

Arguments

• norm_r2 :: Float64 is the radius squared $R^2$ used for normalisation. Facultative, ObsNormRadSq by default. If $R≠1$, an extra factor $1/R^2$ is included.

PadSphereObs(obs :: SphereObs, nol :: Int64)

adds nol empty orbitals to the left by shifting each orbital index, implemented as

SphereObs(obs.s2, obs.l2m, (l, m) -> PadTerms(obs.get_comp(l, m), nol))

FuzzifiED.ObsNormRadSq :: Float64

The default radius squared $R^2$ that is used to normalise the observables, 1 by default. In the convention of He2025, $R^2=N_m$.

GetComponent(obs :: SphereObs, l :: Number, m :: Number) :: Terms

returns an angular component $𝒪_{lm}$ of an observable in the format of a list of terms.

GetPointValue(obs :: SphereObs, θ :: Float64, ϕ :: Float64) :: Terms

evaluates an observable at one point $𝒪(θ,ϕ)$ in the format of a list of terms.

GetIntegral(obs :: SphereObs[ ; norm_r2 :: Float64]) :: Terms

returns the uniform spatial integral $∫\mathrm{d}^2𝐫\,𝒪(𝐫)$ in the format of a list of terms.

Arguments

• norm_r2 :: Float64 is the radius squared $R^2$ used for normalisation. Facultative, ObsNormRadSq by default. If $R≠1$, an extra factor $R^2$ is included.

FilterComponent(obs :: SphereObs, flt) :: AngModes

returns an observable object with certain modes filtered out.

Arguments

• obs :: SphereObs is the original observable
• flt is the filter function whose input is the pair $(l,m)$ and output is a logical that indicates whether this mode is chosen. E.g., if one wants to filter out the components with $L^z=0$, one should put (l, m) -> m == 0.

GetElectronObs(nm :: Int64, nf :: Int64, f :: Int64[ ; norm_r2 :: Float64]) :: SphereObs

returns the electron annihilation operator $ψ_f$.

Arguments

• nf :: Int64 is the number of flavours.
• nm :: Int64 is the number of orbitals.
• f :: Int64 is the index of the flavour to be taken.
• norm_r2 :: Float64 is the radius squared $R^2$ used for normalisation. Facultative, ObsNormRadSq by default. If $R≠1$, an extra factor $1/R$ is included.

GetDensityObs(nm :: Int64, nf :: Int64[, mat :: Matrix{<:Number}][ ; norm_r2 :: Float64]) :: SphereObs

returns the density operator $n=∑_{ff'}ψ^†_{f}M_{ff'}ψ_{f'}$

Arguments

• nf :: Int64 is the number of flavours.
• nm :: Int64 is the number of orbitals.
• mat :: Int64 is the matrix $M_{ff'}$. Facultative, identity matrix $\mathbb{I}$ by default.
• norm_r2 :: Float64 is the radius squared $R^2$ used for normalisation. Facultative, ObsNormRadSq by default. If $R≠1$, an extra factor $1/R^2$ is included.

GetPairingObs(nm :: Int64, nf :: Int64, mat :: Matrix{<:Number}[ ; norm_r2 :: Float64]) :: SphereObs

returns the pair operator $Δ=∑_{ff'}ψ_{f}M_{ff'}ψ_{f'}$.

Arguments

• nf :: Int64 is the number of flavours.
• nm :: Int64 is the number of orbitals.
• mat :: Int64 is the matrix $M_{ff'}$.
• norm_r2 :: Float64 is the radius squared $R^2$ used for normalisation. Facultative, ObsNormRadSq by default. If $R≠1$, an extra factor $1/R^2$ is included.

AngModes

The mutable type AngModes stores angular momentum components of an operator on the sphere $Φ_{lm}$ and superposes in the rule of Clebsch-Gordan coefficients. The usage is similar to the spherical observables, except that SphereObs superposes in the rule of spherical harmonics and has the notion of locality

Fields

• l2m :: Int64 is twice the maximal angular momentum $2l_{\max}$ of the components of the modes object.
• get_comp :: Function is a function get_comp(l2 :: Int64, m2 :: Int64) :: Terms that sends the component specified by a tuple of integers $(2l,2m)$ where $|s|\leq l\leq l_{\max}, -l\leq m\leq l$ to a list of terms that specifies the expression of the component.
• stored_q :: Bool is a boolean that specifies whether or not each component of the modes object is stored.
• comps :: Dict{Tuple{Int64, Int64}, Terms} stores each component of the modes object in the format of a dictionary whose keys are the tuples of integers $(2l,2m)$ and values are the lists of terms that specifies the expression of the component.

AngModes(l2m :: Int64, get_comp :: Function) :: AngModes

initialises the modes object from $2l_{\max}$ and the function $(l,m)↦\Phi_{lm}$

Arguments

• l2m :: Int64 is twice the maximal angular momentum $2l_{\max}$ of the components of the modes object.
• get_comp :: Function is a function get_comp(l2 :: Int64, m2 :: Int64) :: Terms that sends the component specified by a tuple of integers $(2l,2m)$ where $|s|\leq s\leq l_{\max}, -l\leq m\leq l$ to a list of terms that specifies the expression of the component.

AngModes(l2m :: Int64, get_comp :: Function) :: AngModes

initialises the modes object from $2l_{\max}$ and a list of $\Phi_{lm}$ specified by a dictionary.

Arguments

• l2m :: Int64 is twice the maximal angular momentum $2l_{\max}$ of the components of the modes object.
• comps :: Dict{Tuple{Int64, Int64}, Terms} stores each component of the modes object in the format of a dictionary whose keys are the tuples of integers $(2l,2m)$ and values are the lists of terms that specifies the expression of the component.

StoreComps!(amd :: AngModes)

calculates and stores each component of the modes object amd and replace the function in amd by the list of calculated components.

StoreComps(amd :: AngModes) :: AngModes

calculates and stores each component of the modes object amd and return a new modes object with the list of calculated components.

*(fac :: Number, amd :: AngModes) :: AngModes
*(amd :: AngModes, fac :: Number) :: AngModes
/(amd :: AngModes, fac :: Number) :: AngModes
-(amd :: AngModes) :: AngModes

enables the multiplication of a mode with a number.

+(amd1 :: AngModes, amd2 :: AngModes) :: AngModes
-(amd1 :: AngModes, amd2 :: AngModes) :: AngModes

enables the addition of two modes.

adjoint(amd :: AngModes) :: AngModes

enables the Hermitian conjugate of a spherical mode.

\[\begin{aligned} (Φ^†)_{lm}&=(-1)^{l+m}(Φ_{l,-m})^† \end{aligned}\]

*(amd1 :: AngModes, amd2 :: AngModes) :: AngModes

enables the multiplication of two modes in the rule of CG coefficients.

\[ Φ_{lm}=∑_{l_1l_2m_1m_2}δ_{m,m_1+m_2}⟨l_1m_1,l_2m_2|lm⟩Φ_{l_1m_1}Φ_{l_2m_2}\]

PadAngModes(amd :: AngModes, nol :: Int64)

adds nol empty orbitals to the left by shifting each orbital index, implemented as

AngModes(amd.l2m, (l, m) -> PadTerms(amd.get_comp(l, m), nol))

GetComponent(amd :: AngModes, l :: Number, m :: Number) :: Terms

returns an angular component $Φ_{lm}$ of a modes object in the format of a list of terms.

FilterL2(amd :: AngModes, l :: Number) :: AngModes

returns an angular modes object with modes of a certain total angular momentum filtered out.

FilterComponent(amd :: AngModes, flt) :: AngModes

returns an angular modes object with certain modes filtered out.

Arguments

• amd :: AngModes is the original angular modes
• flt is the filter function whose input is the pair $(l,m)$ and output is a logical that indicates whether this mode is chosen. E.g., if one wants to filter out the modes with angular momentum l0, one should put (l, m) -> l == l0.

ContractMod(amd1 :: AngModes, amd2 :: amd2, comps :: Dict) :: Terms
ContractMod(amd1 :: AngModes, amd2 :: AngModes, l0 :: Number) :: Terms

Return the contraction of two angular modes

\[ ∑_{l}U_l∑_{m=-l}^l(-1)^{l+m}Φ_{1,l}Φ_{2,l(-m)}\]

where the list of $U_l$ is given by a dictionary, or

\[ U_{l₀}∑_{m=-l₀}^{l₀}(-1)^{l₀+m}Φ_{1,l₀m}Φ_{2,l₀(-m)}.\]

GetElectronMod(nm :: Int64, nf :: Int64, f :: Int64) :: AngModes

returns the modes of electron annihilation operator $c_m$, with angular momentum $s=(N_m-1)/2$

Arguments

• nf :: Int64 is the number of flavours.
• nm :: Int64 is the number of orbitals.
• f :: Int64 is the index of the flavour to be taken.

GetPairingMod(nm :: Int64, nf :: Int64, mat :: Matrix{<:Number}) :: AngModes

returns the modes of two electrons superposed in the rule of CG coefficients.

\[ Δ_{lm}=∑_{m_1m_2}δ_{m,m_1+m_2}⟨sm_1,sm_2|lm⟩c_{a,m_1}M_{ab}c_{b,m_2}\]

Arguments

• nf :: Int64 is the number of flavours.
• nm :: Int64 is the number of orbitals.
• mat :: Int64 is the matrix $M_{ff'}$.

GetDensityMod(nm :: Int64, nf :: Int64, mat :: Matrix{<:Number}) :: AngModes

returns the modes of electron creation and annihilation superposed in the rule of CG coefficients.

\[ n_{lm}=∑_{m_1m_2}δ_{m,-m_1+m_2}(-1)^{s+m_1}⟨s(-m_1),sm_2|lm⟩c^†_{m_1}c_{m_2}\]

Arguments

• nf :: Int64 is the number of flavours.
• nm :: Int64 is the number of orbitals.
• mat :: Int64 is the matrix $M_{ff'}$. Facultative, identity matrix $\mathbb{I}$ by default.