GitHub

Jack Tool Kit

JackToolkit is a module that generates Jack states — fractional quantum Hall wave-functions such as Laughlin, Moore-Read, Read-Rezayi, and their quasi-hole states with zero energy under the parent Hamiltonian.

To use the module, include also at the start of your Julia script

using FuzzifiED.JackToolkit

The core function that generates the Jack states is GetJackStates. The quantum Hall states are specified by a pair of integers $(k,r)$ corresponding to an admissibility condition. We list several common instances below.

StateStatistics$(k,r)$$\nu$Root
Laughlin $1/2$boson$(1,2)$$1/2$$101010\cdots$
Laughlin $1/3$fermion$(1,3)$$1/3$$100100\cdots$
Laughlin $1/4$boson$(1,4)$$1/4$$10001000\cdots$
Bosonic Pfaffianboson$(2,2)$$1$$202020\cdots$
Fermionic Pfaffianfermion$(2,4)$$1/2$$11001100\cdots$
Gaffnianboson$(2,3)$$2/3$$200200\cdots$
Haffnianboson$(2,4)$$1/2$$20002000\cdots$
$ℤ_3$ Read–Rezayiboson$(3,2)$$3/2$$303030\cdots$
$ℤ_4$ Read–Rezayiboson$(4,2)$$2$$404040\cdots$

Formalism

The wave function of quantum Hall states (and their quasi-hole states) in the first quantized form are usually related to the eigenstates $\Phi(z_1,\dots,z_{N_e})$ of the Laplace-Beltrami operator.

\[ D=\frac{\alpha}{2}\sum_i z_i^2\partial_i^2+\sum_{i\ne j}\frac{z_i^2}{z_i-z_j}\partial_i\]

For simplicity we first consider bosonic states ; for fermions an additional factor should be included : $\Psi=\Phi\Delta$, $\Delta=\prod_{i<j}(z_i-z_j)$. The value of $\alpha$ is usually a rational number

\[ \alpha = -\frac{k+1}{r-1}\]

where different $(k,r)$ specifies different quantum Hall states. On a sphere the co-ordinate $z=v/u$.

Its solutions — known as the Jack polynomials — can be written as linear combinaison of the monomial symmetric polynomials.

\[ J^{(\alpha)}_\lambda(z)=\sum_{\mu\leq\lambda}c_{\lambda\mu}m_\mu(z).\]

Here $\mu$ and $\lambda$ are partition numbers which specifies the power of each monomial in descending order. The monomial that it gives

\[m_\mu(z)=\sum_{\tilde{\mu}\in\mathscr{S}(\mu)}z_1^{\tilde{\mu}_1}z_2^{\tilde{\mu}_2}\cdots z_{N_e}^{\tilde{\mu}_{N_e}}\]

where $\tilde{\mu}$ go through the re-arrangements of $\mu$. E. g. $m_{(4,1,1)}=z_1^4z_2z_3+z_2^4z_1z_3+z_3^4z_1z_2$. The partition number has a one-to-one correspondence with the occupation numbers of each orbital and thus a "configuration" up to a normalization factor.

The monomial $\lambda$ with the maximal partition number in lexicographic order in the linear combination is called the root, and the Jack polynomial $J^{(\alpha)}_\lambda$ is said to be generated by the root $\lambda$. The root must satisfy a $(k,r)$-admissible condition

\[ n_m+n_{m+1}+⋯+n_{m+r-1}≤k\]

in the representation of occupation number, i. e., in a window of $r$ consecutive orbitals, there are maximally $k$ particles.

The other partitions $\mu$ in the Jack polynomial is obtained by squeezing the root. At each step of the squeezing, we pick two elements $(\mu_i,\mu_j)$ in $\mu$ where $i<j$ and change them to $(\mu_i,\mu_j)\mapsto (\mu_i+s,\mu_j-s)$.

The coefficients of each monomial is obtained recursively

\[ c_{\lambda\mu}=\frac{1}{\epsilon_\lambda-\epsilon_\mu}\sum_\nu(\nu_i-\nu_j)c_{\lambda\nu}, \qquad\epsilon_\mu=\sum_i\left[\tfrac{\alpha}{2}\mu_i(\mu_i-1)-(i-1)\mu_i\right] ,\]

where $\nu$ runs over the de-squeezings of $\mu$ : for every ordered pair of $i<j$, we go through $\nu=(\dots,\mu_i+s,\dots,\mu_j-s,\dots)$ re-sorted decreasingly (the omitted elements of $\nu$ are the same as $\mu$), and we keep only $\nu<\lambda$. Note that the de-squeezed partitions does not have to be in decreasing lexicographic order, and different re-arrangements should all be considered if applicable.

Example : $1/2$ Laughlin state

To demonstrate how the Jack state is obtained through squeezing the root, we go through an example of $1/2$ Laughlin state with $N_m=5$ and $N_e=3$, for which $\alpha=-2$. The root is $\lambda=(4,2,0)$ (equivalent to occupation number $10101$). All the allowed $\mu$ are

\[ (4,2,0),\quad(4,1,1),\quad (3,3,0),\quad (3,2,1),\quad (2,2,2)\]

Their respective $\epsilon$ values are $-16,-15,-15,-12,-12$. We start with $c_{(4,2,0)}=1$. After the first squeezing, for $(4,1,1)$,

\[ c_{(4,1,1)}=\frac{1}{(-16)-(-15)}\left[(2-0)c_{(4,\underline{2},\underline{0})}\right]=-2\]

The only eligible de-squeezing is $(4,2,0)$. The factor $(2-0)$ comes from the two squeezed elements, which are underlined. Similarly

\[ \begin{aligned} c_{(3,3,0)}&=\frac{1}{(-16)-(-15)}\left[(4-2)c_{(\underline{4},\underline{2},0)}\right]=-2\\ c_{(3,2,1)}&=\frac{1}{(-16)-(-12)}\left[(4-0)c_{(\underline{4},2,\underline{0})}+(4-1)c_{(\underline{4},\underline{1},1)}+(3-0)c_{(3,\underline{3},\underline{1})}\right]=2\\ c_{(2,2,2)}&=\frac{1}{(-16)-(-12)}\left[(4-0)c_{(\underline{4},2,\underline{0})}+(3-1)c_{(\underline{3},2,\underline{1})}+(4-0)c_{(\underline{4},\underline{0},2)}+(3-1)c_{(\underline{3},\underline{1},2)}+(4-0)c_{(2,\underline{4},\underline{0})}+(3-1)c_{(2,\underline{3},\underline{1})}\right]=-6 \end{aligned}\]

We thus obtain the $\nu=1/2$ Laughlin state

\[J^{-2}_{(4,2,0)}=m_{(4,2,0)}-2m_{(4,1,1)}-2m_{(3,3,0)}+2m_{(3,2,1)}-6m_{(2,2,2)}=\prod_{i<j}(z_i-z_j)^2.\]

Interface

FuzzifiED.JackToolkit.GetJackRoots — Function
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 occ[m], m = 1 : nm in decreasing lexicographic order.

source
FuzzifiED.JackToolkit.OccToPart — Function
OccToPart(occ :: Vector{Int64}) :: Vector{Int64}
PartToOcc(part :: Vector{Int64}, nm :: Int64) :: Vector{Int64}

These two functions converts between the two representations of a configuration :

  1. The occupation number of each orbital

\[ \{n_m\}=\{n_{m=-s},n_{m=-s+1},⋯,n_{m=s}\}\]

  1. The partition, i. e. the $L^z$ quantum number of each particles in descending order

\[ μ=\{m_1,m_2,⋯,\}\]

in practice, the partition is stores as $m+s$.

source
FuzzifiED.JackToolkit.GetSqueezedParts — Function
GetSqueezedParts(part_rt :: Vector{Int64} ; fermion :: Bool = true) :: Vector{Vector{Int64}}

returns the partitions squeezed from the root part_rt in decreasing lexicographic order.

source
FuzzifiED.JackToolkit.GetJackCoefficients — Function
GetJackCoefficients(part_rt :: Vector{Int64}, k :: Int64, r :: Int64 ; fermion :: Bool = true) :: Tuple{Vector{Vector{Int64}}, Vector{Float64}}

calculates the expansion of the state with root partition part_rt in the monomials (bosons) or the Slater determinants (fermions) of the squeezed partitions. Returns the squeezed partitions parts and their respective weight. The first entry is the root itself whose weight is $1$.

source
FuzzifiED.JackToolkit.GetJackState — Function
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 normalized state generated by a $(k,r)$-admissible root configuration.

Input

  • bs :: Basis and bs :: SBasis is the basis in the type of Basis for fermions and SBasis for bosons.
  • nm :: Int64 and ne :: Int64 specifies the number of orbitals and the number of particles.
  • k :: Int64 and r :: Int64 specifies the admissibility condition.
  • root :: Vector{Int64} is a vector of occupation numbers of length nm

Output

  • st :: Vector{Float64} is the normalized state in the basis bs given by a vector of length bs.dim.
source
FuzzifiED.JackToolkit.GetJackStates — Function
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. N. b., they are neither orthogonal nor eigenstates of the total angular momentum.

Input

  • bs :: Basis and bs :: SBasis is the basis in the type of Basis for fermions and SBasis for bosons.
  • nm :: Int64 and ne :: Int64 specifies the number of orbitals and the number of particles.
  • k :: Int64 and r :: Int64 specifies the admissibility condition.
  • lz2 :: Int64 specifies twice the angular momentum in $z$-direction $2L^z$.

Output

  • st :: Matrix{Float64} is the normalized states in the basis bs given by a $\text{dim}×N_{\text{root}}$ matrix where each column specifies a state.
source
FuzzifiED.JackToolkit.OrganizeJackStates — Function
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.

source
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.

source

Reference