Permutation-Invariant GNU Codes

• Permutation-invariant GNU codes are a family of quantum codes using Dicke state superpositions within the symmetric subspace, defined by gap (g), occupancy (n), and scaling (u) parameters.
• They separate logical states by fixed excitation gaps, enabling exact correction of sparse Pauli errors and approximate correction of amplitude damping errors.
• These codes exploit combinatorial binomial structures and inherent symmetry to support deletion correction, magic state distillation, and extend into broader permutation-invariant frameworks.

Permutation-invariant GNU codes are a three-parameter family of quantum codes embedded in the symmetric subspace of multiple qubits and expressed as structured superpositions of Dicke states. They were introduced explicitly under the name “gnu code” in Ouyang’s “Permutation-invariant quantum codes,” with parameters $g$ (gap), $n$ (occupancy), and $u$ (scaling factor), and block length $m=gnu$ (Ouyang, 2013). Their defining feature is simultaneous exploitation of permutation symmetry, combinatorial Dicke-state structure, and spacing in excitation number. In the original formulation, this supports two distinct correction regimes: exact correction of arbitrary weight-$t$ errors for one parameter choice, and approximate correction of $t$ spontaneous-decay or amplitude-damping errors for another (Ouyang, 2013).

1. Physical and algebraic setting

Permutation-invariant quantum codes are code subspaces contained in the symmetric subspace of $m$ qubits, equivalently the subspace fixed by all qubit permutations. In Ouyang’s construction this setting is not merely aesthetic: for the spin-$\tfrac12$ ferromagnetic Heisenberg Hamiltonian

$$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$

with positive exchange constants $J_e$, every permutation-invariant state is a ground state. Consequently, any permutation-invariant code automatically lies in the ground space of any connected Heisenberg ferromagnet without external magnetic field (Ouyang, 2013).

The natural basis of the symmetric subspace is the Dicke basis. For qubits, the Dicke state $n$0 is the normalized symmetric superposition of all computational basis states of Hamming weight $n$1. GNU codes are built directly from these states, so error-correction questions reduce to identities involving binomial coefficients and low-degree polynomials rather than generic tensor-product operator algebra (Ouyang, 2013).

The original paper also stresses two structural points that distinguish GNU codes from more standard families. First, these codes are generally non-stabilizer: the expectation is that permutation-invariant codes correcting a non-trivial number of errors are not quantum stabilizer codes (Ouyang, 2013). Second, they are not constant-excitation codes. Each logical basis state is instead supported on several Dicke weights separated by a fixed gap $n$2 (Ouyang, 2013). A recurring misconception is that “GNU” was attached later; the 2013 paper itself introduces both the $n$3-PI terminology and the shorthand “gnu code” (Ouyang, 2013).

2. Code construction and parameterization

For positive integers $n$4 with $n$5, Ouyang defines a one-qubit permutation-invariant code with logical basis

$n$6

where $n$7 is the gap, $n$8 the occupancy, $n$9 the scaling factor, and the block length is exactly

$u$0

(Ouyang, 2013).

This parameterization is operational. The logical zero occupies Dicke weights $u$1, while the logical one occupies $u$2, up to $u$3 (Ouyang, 2013). The gap $u$4 controls how far low-weight errors must move excitation number in order to mix the two logical ladders; the occupancy $u$5 controls how many Dicke levels participate and therefore how much combinatorial cancellation can be enforced; the scaling $u$6 stretches the block without changing the basic ladder structure (Ouyang, 2013).

The shortest exact $u$7-error-correcting GNU family arises from

$u$8

so that

$u$9

(Ouyang, 2013). Ouyang identifies this family as completely symmetrized Bacon–Shor codes. In particular, the $m=gnu$0-PI code is Ruskai’s 9-qubit permutation-invariant code, equivalently the completely symmetrized Shor code (Ouyang, 2013). For $m=gnu$1, the $m=gnu$2-PI code has length $m=gnu$3 and logical support on Dicke weights $m=gnu$4 and $m=gnu$5, respectively (Ouyang, 2013).

3. Exact correction of sparse and Pauli-type errors

The exact GNU theorem concerns $m=gnu$6-sparse channels, meaning channels whose Kraus operators are linear combinations of Pauli operators of weight at most $m=gnu$7. Ouyang proves that if

$m=gnu$8

then the worst-case error is exactly zero with respect to the resulting gnu code (Ouyang, 2013). In the minimal case $m=gnu$9, the block length is $t$0 (Ouyang, 2013).

The mechanism has two parts. First, because the occupied Dicke weights for $t$1 and $t$2 differ by multiples of $t$3, and because $t$4, no operator of weight at most $t$5 can bridge the logical ladders. This forces cross terms

$t$6

to vanish for $t$7-sparse Kraus operators $t$8 (Ouyang, 2013). Second, the diagonal expectations agree because the difference reduces to an alternating binomial sum annihilated by

$t$9

together with the fact that the relevant Dicke-state expectation values become polynomials of degree $t$0 in $t$1 (Ouyang, 2013). In effect, the gap enforces orthogonality, while the binomial amplitudes enforce diagonal equality.

Later work made this exact-error-correction picture more general. “A family of permutationally invariant quantum codes” derives necessary and sufficient Knill–Laflamme conditions for PI codes correcting $t$2 Pauli errors, extending the previously known $t$3 Pollatsek–Ruskai conditions to arbitrary $t$4 (Aydin et al., 2023). That paper also constructs a broader PI family $t$5 and proves that, for odd $t$6,

$t$7

coincides exactly with Ouyang’s GNU code with parameters $t$8 (Aydin et al., 2023). In the same work, the shortest explicit $t$9-Pauli-error-correcting code in the new family has length

$m$0

which is shorter than the classical GNU benchmark $m$1 for the corresponding explicit PI construction (Aydin et al., 2023).

4. Approximate amplitude damping, spontaneous decay, and deletions

The original GNU paper distinguishes sharply between exact correction of $m$2-sparse errors and approximate correction of $m$3 spontaneous decays. For the amplitude-damping channel

$m$4

the GNU choice is

$m$5

with advertised minimal length

$m$6

(Ouyang, 2013). The resulting code is a $m$7-AD code in the sense that the uncorrectable error scales as $m$8 for small $m$9 (Ouyang, 2013).

The underlying idea is again gap protection, but now for a non-Pauli, non-unitary channel. Amplitude damping lowers excitation number, and at most $\tfrac12$0 decays change the weight by at most $\tfrac12$1, which is too small to mix GNU ladders separated by $\tfrac12$2 (Ouyang, 2013). Exact Knill–Laflamme conditions fail in this setting, so Ouyang develops an approximate criterion using deviation matrices $\tfrac12$3, a total deviation parameter $\tfrac12$4, and a lower bound involving $\tfrac12$5 and $\tfrac12$6 (Ouyang, 2013). This extends both exact Knill–Laflamme and the approximate criterion of Leung–Nielsen–Chuang–Yamamoto (Ouyang, 2013).

A later deletion-oriented development shows that permutation invariance also trivializes location uncertainty for lost particles. “Permutation-invariant quantum coding for quantum deletion channels” states that any permutation-invariant quantum code of distance $\tfrac12$7 can correct $\tfrac12$8 quantum deletions in both qubit and qudit settings, because deletion of $\tfrac12$9 unknown particles is equivalent to erasure of a fixed $$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$0 particles on the symmetric subspace (Ouyang, 2021). That paper studies shifted gnu codes with block length

$$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$1

where Dicke weights $$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$2 are shifted to $$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$3, and gives an $$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$4 encoding algorithm and an $$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$5 decoding algorithm for a special shifted family satisfying

$$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$6

(Ouyang, 2021).

Setting	GNU-type parameter choice	Stated guarantee
Arbitrary $$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$7-sparse / weight-$$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$8 errors	$$H=-2\sum_{e=\{i,j\}}J_e\,\mathbf S_i\cdot \mathbf S_j = -\sum_e J_e\left(\pi_e-\frac12\mathbb 1\right),$$9	Exact correction; worst-case error $J_e$0 (Ouyang, 2013)
$J_e$1 spontaneous decays / amplitude damping	$J_e$2	Approximate $J_e$3-AD correction with error $J_e$4 (Ouyang, 2013)
$J_e$5 deletions on PI codes	Distance $J_e$6	Any PI code corrects $J_e$7 deletions; shifted gnu decoding given explicitly (Ouyang, 2021)

The 2026 general PI QEC theory reinforces this division of labor. For arbitrary correctable errors on arbitrary PI codes it proposes efficient algorithms using total angular momentum measurements, quantum Schur transforms or logical state teleportations, and geometric phase gates; for erasure and deletion errors on certain PI codes it gives a simpler algorithm, and the $J_e$8-shifted gnu family is a central example (Ouyang et al., 14 Feb 2026).

5. Extensions, comparisons, and the broader PI landscape

Subsequent work places GNU codes inside a larger family of PI constructions rather than displacing them. The 2023 family $J_e$9 uses both “low-weight” Dicke sectors $n$00 and reflected sectors $n$01, introduces a length-adjustment parameter $n$02, and a sign parameter $n$03, and contains the odd-occupancy $n$04 GNU subclass exactly (Aydin et al., 2023). This broader family corrects Pauli, deletion, and amplitude-damping errors in different regimes and yields shorter explicit block lengths in several cases (Aydin et al., 2023).

The qubit-versus-qudit PI landscape was sharpened in “Permutation-invariant codes: a numerical study and qudit constructions,” which derives qudit Knill–Laflamme conditions for deletion errors and numerically studies minimal block length as a function of distance (Bond et al., 11 Mar 2026). For qubit PI codes correcting up to $n$05 deletions, that work conjectures

$n$06

equivalently

$n$07

and reports numerical evidence that Pollatsek–Ruskai codes can saturate this bound (Bond et al., 11 Mar 2026). It also observes that, for qudit PI codes encoding one logical qudit, increasing the physical local dimension $n$08 monotonically decreases the needed block length and approaches the quantum Singleton bound $n$09 (Bond et al., 11 Mar 2026). This suggests that qudit generalizations of GNU-style ideas may be structurally advantageous even when canonical qubit GNU parameters remain the starting point.

A more sweeping generalization appears in “Quantum error correction beyond $n$10: spin, bosonic, and permutation-invariant codes from convex geometry,” which explicitly discusses Ouyang’s gnu family as a PI benchmark and embeds PI, bosonic constant-excitation, and generalized spin codes into a common discrete-simplex and $n$11 framework (Aydin et al., 24 Sep 2025). That work compares Ouyang’s shortest $n$12-error-correcting PI family of length $n$13 with shorter explicit PI families of length $n$14, and proves existence results with distance scaling

$n$15

for PI, spin, and Fock-state codes (Aydin et al., 24 Sep 2025). In this framework, GNU codes appear as a distinguished qubit subfamily rather than the full design space (Aydin et al., 24 Sep 2025).

At the shortest-distance end, “Minimal Permutation-Invariant Qudit Codes from Edge-Colorings of Complete Graphs” constructs, for every $n$16, a symmetric-sector code with parameters

$n$17

and proves that no such PI code of dimension $n$18 and distance at least $n$19 exists for $n$20, making four physical qudits necessary and sufficient (Kubischta et al., 21 May 2026). Although these are not GNU codes in the narrow $n$21 sense, they belong to the same occupation-number/Dicke-state tradition and illustrate how far PI code theory has moved toward exact extremal statements (Kubischta et al., 21 May 2026).

6. Representation theory, enumerators, and applications

Recent work has turned GNU-style symmetry from a code ansatz into a full analysis framework. “A theory of quantum error correction for permutation-invariant codes” develops a general representation-theoretic decoding theory for PI codes using measurements of total angular momentum, SYT- and Schur-Weyl-sector structure, modular Dicke-weight measurements, and geometric phase gates (Ouyang et al., 14 Feb 2026). In that theory, GNU codes are especially natural because their logical states are sparse, evenly gapped Dicke superpositions, and shifted gnu codes admit particularly simple deletion recovery via measurement of Dicke weight modulo $n$22 followed by a syndrome-dependent subspace map (Ouyang et al., 14 Feb 2026).

At the enumerator level, “Orthogonal Polynomials and the MacWilliams Transform for Permutation-Invariant Qudit Codes” derives an explicit intrinsic MacWilliams transform for PI qudit codes in $n$23 (Teixeira, 14 May 2026). The operator space decomposes multiplicity-free as

$n$24

and the corresponding MacWilliams matrix is identified with a finite Racah transform whose entries are given by a terminating hypergeometric series (Teixeira, 14 May 2026). For GNU codes, this does not give a new construction, but it supplies the symmetry-adapted harmonic-analysis machinery needed for intrinsic weight enumerators and linear-programming bounds in the symmetric sector (Teixeira, 14 May 2026).

Permutation-invariant gnu codes have also entered fault-tolerance-oriented applications. “Magic state distillation with permutation-invariant gnu codes and a two-qubit example” uses GNU codes as the central primitive of a nonstandard distillation protocol, with logical states

$n$25

defined by the GNU Dicke-superposition formula and projection onto the code subspace followed by decoding (Leitch et al., 4 Mar 2026). The paper reports a two-qubit GNU protocol with threshold $n$26 and distillation rate $n$27, and emphasizes that varying the input-state position on the Bloch sphere allows distillation of magic states with arbitrary magic, not only $n$28 and $n$29 (Leitch et al., 4 Mar 2026). Closely related PI families, though not standard GNU codes, have also been used for measurement-free code switching and transversal rational $n$30-rotations, showing that symmetric Dicke-state encodings support non-Clifford gate constructions beyond the original Ouyang noise models (Ouyang et al., 2024).

Permutation-invariant GNU codes therefore occupy a specific but still central place in the PI-code literature. They are the original $n$31-parameterized Dicke-superposition family, physically motivated by the Heisenberg ferromagnet, combinatorially structured by excitation gaps and alternating binomial amplitudes, exact for $n$32-sparse errors in one regime and approximate for amplitude damping in another, and sufficiently rigid to anchor later developments in deletion correction, PI decoding theory, intrinsic MacWilliams analysis, and small-block magic-state distillation (Ouyang, 2013).