Jack Tool-Kit

GetJackRoots(nm :: Int64, ne :: Int64, k :: Int64, r :: Int64, lz2 :: Int64 = 0 ; fermion :: Bool = true) :: Vector{Vector{Int64}}

enumerates the $(k,r)$-admissible roots with nm orbitals $N_m$, ne particles $N_e$ and total $2L^z$ lz2, i.e., the occupation vectors obeying the clustering condition

\[ n_j+n_{j+1}+⋯+n_{j+r-1}≤k\]

together with $n_j≤1$ for fermions and $n_j≤k$ for bosons. Each root generates one Jack state. Returns the occupation vectors nocc[m], m = 1 : nm in decreasing lexicographic order.

GetSqueezedParts(part_rt :: Vector{Int64} ; fermion :: Bool = true) :: Vector{Vector{Int64}}

returns the partitions squeezed from the root part_rt, i.e., dominated by it, $∑_{i≤t}μ_i≤∑_{i≤t}λ_i$ for every t, in decreasing lexicographic order — a refinement of the dominance order, so that part_rt comes first and every partition follows those that dominate it. For fermions the partitions are strictly decreasing, obtained from the bosonic ones through the dominance-preserving bijection $μ↦μ+δ$, $δ=(N_e-1,…,1,0)$.

GetJackCoefficients(part_rt :: Vector{Int64}, k :: Int64, r :: Int64 ; fermion :: Bool = true) :: Tuple{Vector{Vector{Int64}}, Vector{Float64}}

returns the expansion of the $(k,r)$ model state — Laughlin $(1,q)$, Moore-Read $(2,2q)$, Read-Rezayi $(k,r)$ — with root partition part_rt in the monomials (bosons) or the Slater determinants (fermions) of the squeezed partitions.

For bosons the state is the Jack polynomial at $α=-(k+1)/(r-1)$, $J^α_λ=∑_{μ≤λ}c_{λμ}m_μ$ with $c_{λλ}=1$, whose coefficients follow from the recursion of the Laplace–Beltrami operator

\[ c_{λμ}=\frac{1}{E_λ-E_μ}∑_{ν}(ν_i-ν_j)c_{λν},\qquad E_μ=∑_i\left[\frac{α}{2}μ_i(μ_i-1)-(i-1)μ_i\right]\]

$ν$ running over the partitions obtained by un-squeezing a pair of $μ$, $(μ_i,μ_j)↦(μ_i+s,μ_j-s)$ with $i<j$ and $s≥1$, reordered decreasingly. For $r=1$, $α=∞$ and the Jack degenerates to the single monomial $m_λ$.

For fermions the state is not the Jack of the fermionic partition, but the bosonic Jack of the $(k,r-k)$ root $λ-δ$ times the Vandermonde determinant $Δ=∏_{i<j}(z_i-z_j)$,

\[ Ψ^{(k,r)}_λ=Δ(z)\,J^{α}_{λ-δ}(z),\qquad δ=(N_e-1,…,1,0),\qquad α=-\frac{k+1}{r-k-1}\]

which is the construction that gives the model states as the zero modes of the clustering Hamiltonians. The product is taken monomial by monomial into the Slater determinants $\mathrm{sl}_ν=\det z_i^{ν_j}$,

\[ Δ\,m_μ=\frac{1}{|\mathrm{Aut}\,μ|}∑_{w∈S_{N_e}}\mathrm{sgn}(w)\,\det z_i^{μ_j+w_j}\]

summing over the assignments of the $N_e$ distinct staircase powers $w_j∈\{0,…,N_e-1\}$ to the parts of $μ$, dropping those that give two equal powers $μ_j+w_j$ and keeping one assignment per block of equal parts, which cancels $1/|\mathrm{Aut}\,μ|$. N. b., this last step costs up to $N_e!$ per squeezed partition and is the bottleneck for large $N_e$.

Returns the squeezed partitions parts, with parts[1] == part_rt, and the coefficients coeff, with coeff[1] == 1.

GetJackState(bs :: Basis, nm :: Int64, ne :: Int64, k :: Int64, r :: Int64, root :: Vector{Int64}) :: Vector{Float64}
GetJackState(bs :: SBasis, nm :: Int64, ne :: Int64, k :: Int64, r :: Int64, root :: Vector{Int64}) :: Vector{Float64}

returns the normalised $(k,r)$ model state generated by the root configuration root — an occupation vector of length nm, e. g., an element of GetJackRoots — as a vector of length bs.dim, cf. GetJackCoefficients. The particles are fermions for a Basis and bosons for an SBasis. If bs carries QNOffds, the projection of the state onto the sector is returned.

GetJackStates(bs :: Basis, nm :: Int64, ne :: Int64, k :: Int64, r :: Int64, lz2 :: Int64 = 0) :: Matrix{Float64}
GetJackStates(bs :: SBasis, nm :: Int64, ne :: Int64, k :: Int64, r :: Int64, lz2 :: Int64 = 0) :: Matrix{Float64}

returns the normalised Jack states generated by all the $(k,r)$-admissible roots in the sector (ne, lz2), cf. GetJackRoots and GetJackState, as the columns of a bs.dim×nroot matrix. N. b., they are neither orthogonal nor eigenstates of the total angular momentum.

OrganizeJackStates(sts :: Matrix{T}, l2_mat :: OpMat{T}) :: Tuple{Vector{T}, Matrix{T}}

takes in the Jack states generated from GetJackStates, orthonomalizes them and diagonalize with respect to the total angular momentum specified by l2_mat, and returns the vector of total angular momentum and the eigen-states.

OrganizeJackStates(sts :: Matrix{T}, bs :: Basis, nm :: Int64) :: Tuple{Vector{T}, Matrix{T}}
OrganizeJackStates(sts :: Matrix{T}, bs :: SBasis, nm :: Int64) :: Tuple{Vector{T}, Matrix{T}}

takes in the Jack states generated from GetJackStates, orthonomalizes them and diagonalize with respect to the total angular momentum, and returns the vector of total angular momentum and the eigen-states. The total angular momentum is generated from the basis bs :: Basis or bs :: Basis and the number of orbitals nm.