Built-in models

GetNeQNDiag(no :: Int64) :: QNDiag

Return the QNDiag of the number of electrons, implemented as

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

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

Return the QNDiag of the number 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\ \mathrm{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 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])

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 along the $y$-axis.

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

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

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.

GetC2Terms(nm :: Int64, nf :: Int64, mat_gen :: Vector{<:AbstractMatrix{<:Number}}[, mat_tr :: Vector{<:AbstractMatrix{<: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})}{\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})}{\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 unity.
• mat_tr :: Vector{Matrix{Number}}) is a list of trace matrices that will be normalised automatically and substracted. Facultative.

SphereObs

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

\[ \Phi(\Omega)=∑_{lm}\Phi_{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)↦\Phi_{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, get_comp :: Function) :: SphereObs

initialises the observable from $2s$, $2l_{\max}$ and a list of $\Phi_{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) :: SphereObs

Takes the Laplacian of an observable

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

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.

GetElectronObs(nm :: Int64, nf :: Int64, f :: Int64) :: 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.

GetDensityObs(nm :: Int64, nf :: Int64[, mat :: Matrix{<:Number}]) :: 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.

GetPairingObs(nm :: Int64, nf :: Int64, mat :: Matrix{<:Number}) :: 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'}$.

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.

+(obs1 :: AngModes, obs2 :: AngModes) :: AngModes
-(obs1 :: AngModes, obs2 :: 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}\]

*(obs1 :: AngModes, obs2 :: 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}\]

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.

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.