# Protecting Quantum Information Encoded in Decoherence Free States Against Exchange Errors

## I Introduction

Preserving the coherence of quantum states and controlling their unitary evolution is one of the fundamental goals of Quantum Information Processing . When the system Hamiltonian is invariant under particle permutations, the exchange operator $`E_{ij}`$ interchanging particles $`i`$ and $`j`$ is a constant of the motion, and definite symmetry of a state will be conserved. Models of quantum computers based on identical bosons or fermions must of course respect this elementary requirement. It was pointed out in a recent paper  that active quantum error correcting codes (QECCs)  designed to correct independent single-qubit errors, will fail for identical particles in the presence of exchange errors. The reason is that exchange acts as a two-qubit error which has the same effect as a simultaneous bit flip on two different qubits. Of course, QECCs dealing explicitly with multiple-qubit errors are also available, so that exchange errors can readily be dealt with provided one accepts longer codewords than are needed to deal with single-qubit errors . For example, in Ref.  a nine-qubit code is presented which can correct all single-qubit errors and all Pauli exchange errors. This is to be compared with the five-qubit “perfect” code which protects (only) against all single-qubit errors . While the nine-qubit code is longer than the “perfect” code, it is shorter than a code required to protect against all two-qubit errors.

A different error model which has been considered by several authors is that in which qubits undergo collective, rather than independent errors . The underlying physics of this model has a rich history: it dates back at least to Dicke’s quantum optics work on superradiance of atoms coupled to a radiation field, where it arose in the consideration of systems confined to a region whose linear dimensions are small compared to the shortest wavelength of the field . The model was later treated extensively by Agarwal in the context of spontaneous emission . It was only recently realized, however, that in the collective decoherence model there exist large decoherence-free subspaces (DFSs), which are “quiet” Hilbert subspaces in which no environmentally-induced errors occur at all . Such subspaces offer a passive protection against decoherence. Collective decoherence is an assumption about the manner in which the environment couples to the system: instead of independent errors, as assumed in the active QECC approach, one assumes that errors are strongly correlated, in the sense that all qubits can be permuted without affecting the coupling between system and bath. This is clearly a very strong assumption, and it may not hold exactly in a realistic system-bath coupling scenario. To deal with this limitation, we have shown recently how DFSs can be stabilized in the presence of errors that perturb the exact permutation symmetry, by concatenating DFSs with QECCs . Concatenation is a general technique that is useful for achieving fault tolerant quantum computation , and trades stability of quantum information for the price of longer codewords. It is our purpose here to analyze the effect of exchange errors on DFSs for collective decoherence. These errors are fundamentally different from those induced by the system-bath coupling, since they originate entirely from the internal system Hamiltonian. We will show that by use of the very same concatenation scheme as introduced in Ref.  (which was designed originally to deal with system-bath induced errors), a DFS can be stabilized in the presence of exchange errors as well.

The structure of the paper is as follows. We begin by briefly recalling the origin of the exchange interaction in Sec. II and present some Hamiltonians modelling this interaction. We then present, in Sec. III, a short review of the Hamiltonian theory of DFSs. Next we discuss in Sec. IV the simplest model, of constant exchange matrix elements, and show that DFSs are immune to exchange errors in this case. Our main result is then presented in Sec. V, when we analyze the effect of exchange errors in the case of arbitrary exchange matrix elements. We show that a DFS is invariant under such errors, and conclude that concatenation with a QECC can generally stabilize DFSs against exchange.

## II Modelling Exchange in Qubit Arrays

The exchange interaction arises by virtue of permutation symmetry between identical particles, in addition to some interaction potential. Exchange is caused by the system Hamiltonian, and is unrelated to the coupling to an external environment. Exchange thus induces an extraneous unitary evolution on the system, but does not lead to decoherence. To model exchange it is sufficient to consider a Hamiltonian of the form

$$H_{\mathrm{ex}}=\frac{1}{2}\underset{ij}{\overset{K}{}}J_{ij}E_{ij},$$
(1)   
where the sum is over all qubit pairs, $`J_{ij}`$ are appropriate matrix elements, and

$$E_{ij}|ϵ_1,\mathrm{},ϵ_i,\mathrm{},ϵ_j,\mathrm{},ϵ_K=|ϵ_1,\mathrm{},ϵ_j,\mathrm{},ϵ_i,\mathrm{},ϵ_K.$$
(2)   
$`E_{ij}`$ thus written is a general exchange operator operating on qubits $`i`$ and $`j`$ of a $`K`$-qubit state.

Typical examples of Hamiltonian leading to exchange are : (i) the Heisenberg interaction between spins

$$H_{\mathrm{Heis}}=\frac{1}{2}\underset{ij}{}J_{ij}^\mathrm{H}𝐒_i𝐒_j$$
(3)   
where $`𝐒_i=(\sigma _i^x,\sigma _i^y,\sigma _i^z)`$ is the Pauli matrix vector of spin $`i`$; (ii) the Coulomb interaction

$$H_{\mathrm{Coul}}=\frac{1}{2}\underset{ij}{}\underset{\sigma ,\sigma ^{}}{}J_{ij}^\mathrm{C}a_{i\sigma }^{}a_{i\sigma ^{}}a_{j\sigma ^{}}^{}a_{j\sigma }$$
(4)   
where $`a_{i\sigma }^{}`$ ($`a_{i\sigma }`$) is the creation (annihilation) operator of an electron of spin $`\sigma `$ in Wannier orbital $`i`$. $`J_{ij}`$ is the exchange matrix element and is given for electrons by

$$J_{ij}^\mathrm{C}=e^2𝑑𝐫𝑑𝐫^{}\frac{w^{}(𝐫𝐑_i)w(𝐫^{}𝐑_i)w^{}(𝐫^{}𝐑_j)w(𝐫𝐑_j)}{|𝐫𝐫^{}|},$$
(5)   
where $`𝐑_i`$ is a lattice vector and $`w`$ is a Wannier function . This is a rather generic form for the exchange matrix element; in other cases $`w`$ would be replaced by the appropriate wave function and the Coulomb interaction $`e^2/|𝐫𝐫^{}|`$ by the appropriate potential. The important point to notice is that the exchange integral depends on the overlap between the wave functions at locations $`i`$ and $`j`$. Thus exchange effects generally decay rapidly as the distance $`|𝐑_i𝐑_j|`$ increases. An important simplification is possible when interactions beyond nearest neighbors can be neglected (i.e., $`J_{ij}=0`$ if $`i`$ and $`j`$ are not nearest neighbors) in which case the approximation $`J_{ij}J`$ is often made.

In the Coulomb case the interpretation of $`a_{i\sigma }^{}a_{i\sigma ^{}}a_{j\sigma ^{}}^{}a_{j\sigma }`$ as an exchange operator is quite clear: spin $`\sigma `$ is destroyed at orbital $`j`$ and is created at orbital $`i`$, while spin $`\sigma ^{}`$ is destroyed at orbital $`i`$ and is created at orbital $`j`$. The net effect is that spins $`\sigma `$ and $`\sigma ^{}`$ are swapped between the electrons in orbitals $`i`$ and $`j`$. In the Heisenberg case one can verify that the operator $`𝐒_i𝐒_j`$ also implements an exchange. Let $`I`$ denote the identity operator, $`X_i`$ the Pauli matrix $`\sigma _i^x`$ operating on qubit $`i`$, etc. A qubit state is written as usual as a superposition over $`\sigma _z`$ eigenstates $`|0`$ and $`|1`$. Then, defining

$$E_{ij}\frac{1}{2}\left(I+𝐒_i𝐒_j\right)=\frac{1}{2}\left(I+X_iX_j+Y_iY_j+Z_iZ_j\right),$$
(6)   
it is easily checked that Eq. (2) is satisfied .

## III Review of Decoherence Free Subspaces

We briefly recall the Hamiltonian theory of DFSs . Given is a system-bath interaction Hamiltonian

$$H_{\mathrm{SB}}=\underset{\lambda }{}F_\lambda B_\lambda ,$$
(7)   
where $`F_\lambda `$ and $`B_\lambda `$ are, respectively, the system and bath operators. The decoherence free states are those, and only those states $`\{|\psi \}`$ which are simultaneous degenerate eigenvectors of all system operators appearing in $`H_{\mathrm{SB}}`$:

$$F_\lambda |\psi =c_\lambda |\psi .$$
(8)   
The eigenvalues $`\{c_\lambda \}`$ do not depend on $`|\psi `$. The subspace spanned by these states is a DFS, meaning that under $`H_{\mathrm{SB}}`$ the evolution in this subspace is unitary, and there is no decoherence. This results in a passive protection against errors, to be contrasted with the active QECC approach. Of particular interest is the case where the $`\{F_\lambda \}`$ are collective operators, such as the total spin operators

$$S_\alpha =\underset{i=1}{\overset{K}{}}\sigma _i^\alpha \alpha =x,y,z.$$
(9)   
These operators satisfy $`su(2)`$ commutation relations, just like the local $`\sigma _i^\alpha `$ Pauli operators:

$$[S_\alpha ,S_\beta ]=2i\epsilon _{\alpha \beta \gamma }S_\gamma .$$
(10)   
This situation, referred to above as collective decoherence, arises when the bath couples in a permutation-invariant fashion to all qubits. In this paper we shall confine our attention to collective decoherence, and shall employ the term DFS exclusively in this context . With a system-bath interaction of the form $`H_{\mathrm{SB}}=_\alpha S_\alpha B_\alpha `$ (as, e.g., in the Lamb-Dicke limit of the spin-boson model), a combinatorial calculation shows (see appendix) that the number of encoded qubits is $`\mathrm{log}_2K!/\left[(K/2+1)!(K/2)!\right]\stackrel{K\mathrm{}}{}K\frac{3}{2}\mathrm{log}_2K`$. The resulting decoherence free code thus asymptotically approaches unit efficiency (number of encoded qubits per physical qubits), and is therefore of significant interest. In the collective decoherence case, since the $`S_\alpha `$ are the generators of the semisimple Lie algebra $`su(2)`$, the DFS condition Eq. (8) is satisfied with $`c_\alpha =0`$ . This means that the decoherence free states $`\{|j\}`$ are $`su(2)`$ singlets: they are states of zero total spin, and belong to the one-dimensional irreducible representation of $`su(2)`$. For example, for $`K=2`$ qubits undergoing collective decoherence, there is just one decoherence free state: $`(|01|10)/\sqrt{2}`$, i.e., the familiar singlet state of two spin 1/2 particles. For as few as $`K=4`$ there are already two singlet states, spanning a full encoded decoherence free qubit .

## IV Decoherence Free States and Exchange with Constant Matrix Elements

A simple situation arises when we can assume that $`J_{ij}J/K`$ for all $`i,j`$, i.e., without the restriction to nearest neighbor interactions. This long-range Ising model is thermodynamically equivalent to the mean-field theory of metallic ferromagnets, and there exist some examples of metals (e.g., HoRh<sub>4</sub>B<sub>4</sub>) that are well described by it . At present the relevance of such materials to quantum computer architectures is not clear. We also stress that in the vast majority of physical examples exchange correlations decay exponentially fast with the distance between particles. The case of arbitrary exchange matrix elements is dealt with in the next section. We consider the long-range model here mainly for its simplicity and for the remarkable result that DFSs are completely immune to exchange errors in this case.

We have for $`𝐒=(S_x,S_y,S_z)`$

$$S^2=𝐒𝐒=3KI+2\underset{ij}{}X_iX_j+Y_iY_j+Z_iZ_j,$$
(11)   
so that the exchange Hamiltonian can be rewritten as

$`H_{\mathrm{ex}}`$ $`=`$ $`{\displaystyle \frac{J}{4K}}{\displaystyle \underset{ij}{\overset{K}{}}}\left(I+X_iX_j+Y_iY_j+Z_iZ_j\right)`$ (12)   
$`=`$ $`{\displaystyle \frac{J}{8K}}\left[\left(K^24K\right)I+S^2\right].`$ (13)   
Whereas the DFS condition guarantees that no decoherence is caused by the coupling to the bath, uncontrolled unitary evolution due to the system Hamiltonian may still pose a significant problem. This is exactly the case in the presence of exchange errors, as described above. However, using Eq. (13) and recalling that the DFS states have zero total spin, we see that in the collective decoherence case the DFS is in fact automatically protected against exchange errors:

$$H_{\mathrm{ex}}|\psi =\left[\nu I+\frac{J}{8K}S^2\right]|\psi =\nu |\psi ,$$
(14)   
where $`|\psi `$ is a DFS state and $`\nu (J/K)(K^24K)/8`$. Since the constant $`\nu `$ does not depend on $`\psi `$, this implies that under the unitary evolution generated by $`H_{\mathrm{ex}}`$, a DFS state accumulates an overall, global phase $`e^{i\nu t}`$. This phase is not measurable and does not affect the decoherence time. Thus in the $`J_{ij}J`$ model a DFS does not undergo exchange errors, and the smallest DFS ($`K=4`$ physical qubits) already suffices to encode a full logical qubit.

## V Decoherence Free States and Arbitrary Exchange Matrix Elements

We now analyze the effect of arbitrary exchange errors on DFS states for collective decoherence. We show that by concatenation with QECCs, DFSs can be stabilized against these errors.

### A Decoherence Free Subspaces are Invariant Under Exchange

The exchange operator commutes with the total spin operators. To see this, use the definitions of these operators in Eqs. (2) and (9), and let $`S_\alpha ^{ij}\left(_{ki,j}^K\sigma _k^\alpha \right)`$. Since they act on different qubits, $`S_\alpha ^{ij}`$ clearly commutes with $`E_{ij}`$. Now, using $`\sigma ^\alpha \sigma ^\beta =\delta _{\alpha \beta }I+i\epsilon _{\alpha \beta \gamma }\sigma ^\gamma `$:

$`S_\alpha E_{ij}`$ $`=`$ $`\left[S_\alpha \left(\sigma _i^\alpha +\sigma _j^\alpha \right)\right]E_{ij}+\left(\sigma _i^\alpha +\sigma _j^\alpha \right)E_{ij}`$ (15)   
$`=`$ $`\left({\displaystyle \underset{ki,j}{\overset{K}{}}}\sigma _k^\alpha \right)E_{ij}+{\displaystyle \frac{1}{2}}\left(\sigma _i^\alpha +\sigma _j^\alpha \right)\left(I+{\displaystyle \underset{\beta =x,y,z}{}}\sigma _i^\beta \sigma _j^\beta \right)`$ (16)   
$`=`$ $`S_\alpha ^{ij}E_{ij}+\sigma _i^\alpha +\sigma _j^\alpha +{\displaystyle \frac{i}{2}}{\displaystyle \underset{\beta ,\gamma }{}}\epsilon _{\alpha \beta \gamma }\left(\sigma _i^\beta \sigma _j^\gamma +\sigma _i^\gamma \sigma _j^\beta \right).`$ (17)   
The last term in this expression vanishes since $`\epsilon _{\alpha \beta \gamma }=\epsilon _{\alpha \gamma \beta }`$ and we are summing over all $`\beta ,\gamma `$ values. Thus

$$S_\alpha E_{ij}=S_\alpha ^{ij}E_{ij}+\sigma _i^\alpha +\sigma _j^\alpha =E_{ij}S_\alpha .$$
(18)   
Now let $`|\psi `$ be a decoherence free state (which it is for collective decoherence iff $`S_\alpha |\psi =0`$ ). Since $`S_\alpha \left(E_{ij}|\psi \right)=E_{ij}S_\alpha |\psi =0`$, it follows that $`E_{ij}|\psi `$ also is decoherence free. We have thus proved:

Theorem I. Let $`\stackrel{~}{}`$ be a decoherence free subspace against collective decoherence errors, and $`E_{ij}`$ an exchange operation on qubits $`i`$ and $`j`$. Then $`E_{ij}\stackrel{~}{}=\stackrel{~}{}`$.

The significance of this result is that exchange errors act as errors on the encoded DFS qubits, i.e., they keep decoherence free states inside the DFS. The exact way in which these errors are manifested is a difficult problem. Exchange operations are transpositions in the language of the permutation group $`S_K`$, and are known to generate this group . For a given number $`K`$ of physical qubits the action of the exchange operators will realize a $`2^K`$-dimensional reducible representation of $`S_K`$. The DFS for collective decoherence on these $`K`$ qubits is the set of one-dimensional irreducible subspaces in the irreducible representations (irreps) of $`S_K`$, which appear with multiplicity $`\frac{K!}{(K/2+1)!(K/2)!}`$ (see appendix). For $`K=4`$ the DFS is 2-dimensional (=multiplicity of the 1D irreps), encoding one qubit. Therefore in this case exchange errors will act as the usual Pauli errors on a single (encoded-) qubit. Correction of exchange errors for $`K=4`$ can then be done entirely within the DFS by using a quantum error correcting code for single-qubit errors. This observation naturally leads one to consider concatenating the DFS codewords with such a code, as done in the concatenated code of Ref. . That paper showed that the concatenated DFS-QECC code can in fact deal with the more general case of both errors inside the DFS (as is our case here), and errors that take states outside of the DFS. We investigate the correction of exchange errors in detail for the $`K=4`$ case in the next subsection. For $`K>4`$ qubits, the dimension of the DFS is greater than 2 (e.g., for $`K=6`$ it is 5), and the action of exchange errors will correspondingly be represented by higher dimensional irreps of $`S_K`$. To correct such unitary errors it will be necessary to resort to codes for “qu$`k`$its” ($`k>2`$), such as stabilizer codes for higher-dimensional sytems , or polynomial codes . We defer the discussion of this case to a future publication  and focus here on the $`K=4`$ case.

### B Effect of Exchange Errors on the Four Qubit Decoherence Free Subspace

Suppose that the qubits undergo collective decoherence in clusters of four identical particles, but different clusters are independent (as they might, e.g., in a polymer with an AAAABBBBAAAA… type of order). Each cluster would then support a two-dimensional DFS, accommodating a single encoded DFS qubit. The $`K=4`$ physical qubits DFS states can then be written as 

$$|\stackrel{~}{0}=\frac{|a|b}{2},|\stackrel{~}{1}=\frac{2|c|a|b}{2\sqrt{3}},$$
(19)   
where

$$|a|0110+|1001,|b|1010+|0101,|c|0011+|1100.$$
(20)   
Note that the mutually orthogonal states $`|a`$, $`|b`$ and $`|c`$ are sums of complementary states. Moreover, the four qubits play a symmetrical role (i.e., $`0`$ and $`1`$ appear equally in all four positions in both $`|\stackrel{~}{0}`$ and $`|\stackrel{~}{1}`$). This dictates that exchange of qubits in symmetrical positions should have the same effect. In other words, we expect $`E_{12}`$ to be indistinguishable from $`E_{34}`$, and similarly for $`\{E_{13},E_{24}\}`$ and $`\{E_{23},E_{14}\}`$ (although for a linear geometry most physical exchange mechanisms will yield $`|J_{23}|>|J_{14}|`$). This expectation is born out; in the $`\{|\stackrel{~}{0},|\stackrel{~}{1}\}`$ basis we find, using straightforward algebra, that the six exchange operators can be written as

$`E_{12}`$ $`=`$ $`E_{34}=\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right)=\overline{Z}`$ (23)   
$`E_{13}`$ $`=`$ $`E_{24}=\stackrel{~}{R}\left(\pi /3\right)={\displaystyle \frac{\sqrt{3}}{2}}\overline{X}+{\displaystyle \frac{1}{2}}\overline{Z}`$ (24)   
$`E_{14}`$ $`=`$ $`E_{23}=\stackrel{~}{R}\left(\pi /3\right)={\displaystyle \frac{\sqrt{3}}{2}}\overline{X}+{\displaystyle \frac{1}{2}}\overline{Z},`$ (25)   
where $`\stackrel{~}{R}\left(\theta \right)=R\left(\theta \right)Z`$, and $`R\left(\theta \right)=\left(\begin{array}{cc}\mathrm{cos}\theta & \mathrm{sin}\theta \\ \mathrm{sin}\theta & \mathrm{cos}\theta \end{array}\right)`$. Thus $`\stackrel{~}{R}\left(\theta \right)`$ is a reflection about the $`x`$-axis followed by a counter-clockwise rotation in the $`x,y`$ plane. In writing these expressions, the matrices operate on column vectors such that $`|\stackrel{~}{0}=\left(\genfrac{}{}{0pt}{}{1}{0}\right)`$ and $`|\stackrel{~}{1}=\left(\genfrac{}{}{0pt}{}{0}{1}\right),`$ and $`\overline{X},\overline{Z}`$ are the encoded Pauli matrices, i.e., the Pauli matrices acting on the DFS states (and not on the physical qubits). Thus, exchange errors act as encoded Pauli errors on the DFS states.

Using this observation, it is possible to protect DFS states against such errors by concatenation with a QECC designed to correct single qubit errors. The critical point is that this QECC will now correct single encoded qubit errors. This requires an additional encoding layer to be constructed. In particular, suppose we add such an encoding layer by using DFS qubits to build codewords of the five-qubit “perfect” QECC . These codewords have the form $`|\stackrel{~}{ϵ}_1|\stackrel{~}{ϵ}_2|\stackrel{~}{ϵ}_3|\stackrel{~}{ϵ}_4|\stackrel{~}{ϵ}_5`$, where $`ϵ=0,1`$, and $`j`$ in $`\stackrel{~}{ϵ}_j`$ is now a cluster index. Since the five-qubit QECC can correct any single qubit error, in particular it can correct the specific errors of Eq. (25) which the encoded DFS qubits would undergo under an exchange interaction on the physical qubits in a given cluster. However, the error detection and correction procedure must be carried out sufficiently fast so that exchange errors affecting multiple blocks at a time do not occur, or else concatenation with a code that can deal with $`t>1`$ independent errors is needed. The typical time scale for exchange errors to occur is $`1/2|J_{ij}|`$, where $`J_{ij}`$ is the relevant exchange matrix element.

This 20-qubit concatenated DFS-QECC code is precisely the one discussed in Ref. , where it was shown that it offers protection against general collective decoherence symmetry breaking perturbations. Our present result shows that this concatenated code is stable against exchange errors as well.

We note that it is certainly possible to find a shorter QECC than the five-qubit one to protect against the restricted set of errors in Eq. (25). However, such a code would not offer the full protection against general errors that is offered by concatenation with the perfect five-qubit code, and thus would not be as useful.

## VI Summary and Conclusions

To conclude, in this paper we considered the effect of unitary exchange errors between identical qubits on the protection of quantum information by decoherence free subspaces (DFSs) defined for a qubit array. We showed that in the important case of ideal collective decoherence (qubits are coupled symmetrically to the bath), for which a perfectly stable DFS is obtained, DFSs are additionally invariant to exchange errors. Thus such errors generate rotations inside the DFS, but do not take decoherence free states outside of the DFS. Consequently it is possible to use, without any modification, the concatenated DFS-QECC scheme of Ref.  in order to protect DFSs against exchange errors, while at the same time relaxing the constraint of ideal collective decoherence, and allowing for symmetry breaking perturbations. This is useful for quantum memory applications. Since exchange interactions preserve a DFS, an interesting further question is whether they can be used constructively in order to perform controlled logic operations inside a DFS. We have found the answer to be positive, and that it is actually possible to perform universal computation in a fault tolerant manner inside a DFS for collective decoherence using only two-body exchange interactions .

Acknowledgments.— This material is based upon work supported by the U.S. Army Research Office under contract/grant number DAAG55-98-1-0371, and in part by NSF CHE-9616615.

## Dimension of Decoherence Free Subspaces for Collective Decoherence

In view of the fact that the total spin operators $`S_\alpha `$ satisfy spin-1/2 commutation relations, it follows from the addition of angular momentum that the operators $`S^2`$ and $`S_z`$ have simultaneous eigenstates given by

$$S^2|S,m=S(S+1)|S,m,S_z|S,m=m|S,m,$$
(26)   
where $`m=S,S+1,\mathrm{},S`$ and $`S=0,1,\mathrm{},K/2`$ (for $`K`$ even), $`S=1/2,3/2,\mathrm{},K/2`$ (for $`K`$ odd). The $`|S,m`$ states are known as Dicke states . The degeneracy of a state with given $`S`$ is

$$\frac{K!(2S+1)}{(K/2+S+1)!(K/2S)!},$$
(27)   
which for $`S=0`$, i.e., the singlet states, coincides with the dimension of the DFS for $`K`$ qubits undergoing collective decoherence cited in the text.

It is interesting to derive this formula from combinatorial arguments relating to the permutation group of $`K`$ objects, which we will do for $`S=0`$. The result follows straightforwardly from the Young diagram technique. As is well known (see, e.g., ), the singlet states of $`su(2)`$ belong to the rectangular Young tableaux of $`K/2`$ columns and $`2`$ rows. The multiplicity $`\lambda `$ of such states is the number of “standard tableaux” (tableaux containing an arrangement of numbers which increase from left to right in a row and from top to bottom in a column), which is also the dimension of the irreducible representation of the permutation group corresponding to the Young diagram $`\eta _{K/2,2}`$ (an empty tableau) of $`K/2`$ columns and $`2`$ rows. This number is found using the “hook recipe” , where one writes the “hook length” $`g_i`$ (the sum of the number of positions to the right of box $`i`$, plus the number of positions below it, plus one) of each box $`i`$ in the Young diagram:

$$\lambda (\eta )=\frac{K!}{_{i=1}^Kg_i}.$$
(28)   
E.g., for $`\eta _{c,2}`$ the hook lengths are:

| $`c+1`$ | $`c`$ | $`c1`$ | $`\mathrm{}`$ | $`3`$ | $`2`$ |
| --- | --- | --- | --- | --- | --- |
| $`c`$ | $`c1`$ | $`c2`$ | $`\mathrm{}`$ | $`2`$ | $`1`$ |

(29)   
and one finds, with $`c=K/2`$:

$$\lambda (\eta _{K/2,2})=\frac{K!}{(K/2+1)!(K/2)!},$$
(30)   
which is indeed the $`S=0`$ case of the general degeneracy formula, Eq. (27).