Gnu Code¶

A gnu code encodes a logical qubit in parity-separated, binomially weighted Dicke states whose excitation weights are spaced by gap g across m=gnu symmetric physical qubits.

Version: v2 · 2026-10-03 · History
Domain-specific #: 13281
Domain group: Natural Sciences
Origin domain: Physics
Subdomain: Quantum Error Correction → Physics
Aliases: Gnu Quantum Code, G N U Code

Core Idea¶

A gnu code is one construction within permutation-invariant (PI) quantum codes. It encodes a logical qubit in symmetric states of \(m\) physical qubits. A normalized Dicke state \(|D_w^m\rangle\) is the equal superposition of all \(m\)-qubit basis strings with exactly \(w\) excitations; swapping qubit labels leaves it unchanged. Ouyang's code chooses a ladder of Dicke weights \(0,g,2g,\ldots,ng\) and weights the terms by square roots of binomial coefficients. The logical zero contains even ladder indices, and logical one the odd indices. With positive integers \(g,n\), length \(m\geq gn\), and \(u=m/(gn)\geq1\), Ouyang names this the \((g,n,u)\) or gnu code.^[1]

Permutation invariance belongs to the broader PI-code family. What is gnu-specific is the g-spaced binomial Dicke ladder and its parity split. Symmetry removes dependence on which physical qubit label is affected in a permutation-related error, but it does not alone guarantee correction of every error. Ouyang proves exact correction of one arbitrary qubit error for \((3,3,1)\), whereas \((2,4,9/8)\) is an approximate, small-noise spontaneous-decay construction with a nonzero worst-case error bound. These are distinct channel claims, not a blanket promise.^[1]

The frozen seed adds deletion correction and a generic collective-spin implementation. The 2021 deletion paper concerns a shifted gnu extension with a nonzero Dicke-weight offset and its own decoding results. The original paper discusses spin-half particles and Heisenberg ferromagnets as motivation, but does not by itself establish an atomic-ensemble deployment. Those claims are kept separate.^[1]^[2]

Structural Signature¶

Sig role-phrases:

Symmetric physical carriers: \(m\) qubits support permutation-invariant codewords. If swapping labels changed the codeword, it would not be this PI construction.
Dicke excitation ladder: only weights \(g\ell\) for \(0\leq\ell\leq n\) enter; arbitrary symmetric weight choices would define another code.
Binomial amplitudes and parity: coefficients proportional to \(\sqrt{\binom n\ell}\) and even/odd ladder indices define the two logical basis states.
Gap \(g\) and occupancy \(n\): spacing and number of terms set the combinatorial structure used in error analysis.
Scale \(u\) and length: \(u=m/(gn)\geq1\) fixes physical qubit count, which must accommodate the largest occupied weight \(gn\).
Specified error model: exact correction is demonstrated for defined sparse arbitrary errors, while the spontaneous-decay result gives approximate correction under bounded damping probability; neither follows from symmetry alone.^[1]

Condensed: PI Dicke states + g-spaced binomial weight ladder + parity-separated logical codewords + channel-specific recovery conditions.

What It Is Not¶

Not every PI quantum code. Other symmetric codes can use different supports or amplitudes; the gnu name marks this particular construction.^[1]
Not a classical binary code of bit strings. Its logical states are coherent quantum superpositions; their amplitudes and phase relationships matter.
Not automatically deletion-proof. A later article studies shifted gnu codes and explains deletion recovery under specified conditions.^[2]
Not one universal distance or correction count independent of \(g,n,u\). Capability must be tied to the original theorem and error channel.
Not a demonstrated generic atomic-ensemble device. The original paper's Heisenberg ferromagnet ground-space argument is theoretical motivation, not evidence for the seed's proposed implementation.

Scope of Application¶

In Ouyang's original paper, the \((3,3,1)\) code has \(m=9\) qubits. Its even-index logical state combines Dicke weights 0 and 6; the odd-index state combines weights 3 and 9, with stated binomial amplitudes. The paper identifies it with Ruskai's nine-qubit PI code and states it corrects one arbitrary qubit error. A \((5,5,1)\) 25-qubit extension is given for two arbitrary errors. These are concrete parameter/capability pairs, not an extrapolation from only the family name.^[1]

The paper's different \((2,4,9/8)\) construction also uses nine qubits, since \(2\cdot4\cdot9/8=9\). It has weights 0, 2, 4, 6 and 8; even ladder indices produce 0, 4 and 8, while odd indices produce 2 and 6. Ouyang presents it for approximate correction of one spontaneous-decay error under the small-damping conditions of Theorem 16, which gives a nonzero worst-case error bound that tends to zero as damping probability \(\gamma\) tends to zero. This nonunitary noise model needs different tools from the exact arbitrary-sparse-error result.^[1]

The later deletion-channel paper states that PI codes of distance \(t+1\) can correct \(t\) deletions, and examines shifted gnu codes with Dicke weights \(g\ell+\Delta\). It gives a 15-qubit shifted example correcting two deletions. Because the offset and recovery construction differ, this source cannot be folded into a claim that the unshifted nine-qubit examples automatically possess all deletion properties.^[2]

Clarity¶

The letters are parameters, not an animal metaphor: \(g\) is the gap between occupied excitation weights, \(n\) controls the binomial ladder, and \(u\) scales length \(m=gnu\). These roles are visible in the original formula. For \((3,3,1)\), the ladder 0,3,6,9 fits in nine qubits. For \((2,4,9/8)\), the maximum weight 8 fits in nine qubits, leaving one extra carrier relative to \(gn=8\).^[1]

An error-correction claim needs three pieces: the codewords, the error set, and a recovery proof or criterion. Permutation invariance alone gives label symmetry. It does not answer whether an arbitrary Pauli error, spontaneous decay, erasure or deletion can be corrected for a selected \(g,n,u\).

Manages Complexity¶

PI structure collapses many qubit-label permutations into a Dicke-weight description. Instead of tracking all \(2^m\) computational basis strings individually, the construction organizes codeword support by the \(n+1\) occupied symmetric weights and their binomial amplitudes. This makes combinatorial error analysis possible and can align with symmetric physical models such as the Heisenberg-ferromagnet motivation in Ouyang's introduction.^[1]

The simplification has a cost: symmetry does not remove the need for channel-specific recovery or physical preparation. The original paper uses different arguments for arbitrary sparse errors and spontaneous decay. The later deletion article develops encoding and decoding for shifted variants. A short codeword formula should not be treated as a complete laboratory architecture.^[1]^[2]

Abstract Reasoning¶

For each weight \(g\ell\), the Dicke state is unchanged by permutations. A binomially weighted sum of such states remains symmetric. Splitting the ladder by even versus odd \(\ell\) yields two orthogonal logical basis states because they occupy disjoint excitation weights. The gap controls how local errors mix nearby weights, and the number of terms supplies combinatorial cancellations in the recovery conditions. These statements explain why the construction is plausible; actual correction counts still come from Ouyang's specified theorems, not visual spacing alone.^[1]

Increasing parameters can improve provable capability but length grows. The paper's nine-qubit \((3,3,1)\) one-arbitrary-error example and 25-qubit \((5,5,1)\) two-error example make the cost visible. The error class also matters: the nine-qubit spontaneous-decay example uses different \(g,n,u\) and a different theorem despite having the same total length.^[1]

Knowledge Transfer¶

The gnu construction transfers as a mathematical family across parameter choices and noise analyses when the same g-spaced binomial/parity codewords are retained. It does not mean every PI code is gnu. Nor does the later shifted version have identical identity: adding \(\Delta\) changes the occupied Dicke weights and is named and analyzed separately in the deletion paper.^[2]

The generic skeleton of encoding logical information redundantly to recover from a specified error set belongs to the live Error-Correcting Code genus. Its physical carriers, Dicke basis and exact parameter inequalities are domain-specific. A narrower Quantum Error-Correcting Code intermediate has not been independently admitted, so no such intermediate edge is invented; that absence does not undo the broader live parent.

Examples¶

Nine-qubit arbitrary-error construction¶

Ouyang's \((3,3,1)\) code uses nine symmetric qubits and occupied weights 0, 3, 6 and 9. The logical zero combines the even-index weights 0 and 6, and logical one the odd-index weights 3 and 9, with the original paper's square-root binomial coefficients. Ouyang identifies it as Ruskai's nine-qubit PI code and states one arbitrary qubit error is correctable. That claim is for the stated parameter regime and one-error model.^[1]

Mapped back: nine qubits are the symmetric carriers; the four occupied Dicke states form the g-spaced ladder; parity and binomial amplitudes define logical zero/one; \(g=n=3\); \(u=1\) gives \(m=9\); the cited correction target is one arbitrary qubit error.

Nine-qubit spontaneous-decay construction¶

The \((2,4,9/8)\) code is also length nine but uses five ladder weights 0 through 8 by twos. The even-index weights 0,4,8 encode logical zero; odd-index 2,6 encode logical one, again with binomial amplitudes. The source presents this as approximate spontaneous-decay protection under \(g=t+1\), \(n>3t\), \(u\geq1+t/(gn)\) for \(t=1\) and the small-\(\gamma\) assumptions of Theorem 16. Its error bound is not zero at fixed nonzero damping. The unlike error mechanism is crucial; equal length does not imply equal guarantees.^[1]

Mapped back: nine PI carriers support weights \(0,2,4,6,8\); the ladder is separated by \(g=2\); binomial parity separates the logical states; \(n=4\); \(u=9/8\) gives \(m=9\); the specified channel is one spontaneous-decay error with approximate small-noise recovery, not exact arbitrary-error correction.

Shifted-gnu deletion boundary¶

Ouyang's later deletion paper introduces a nonzero shift \(\Delta\) in the Dicke weights and gives a 15-qubit shifted code correcting two deletions. This is a related variant and negative identity check, not a third unshifted-gnu example.^[2]

Structural Tensions¶

Correctability versus physical length. Enlarging gap and occupancy can meet stronger error-correction conditions: Ouyang's one-arbitrary-error code uses nine qubits, while its stated two-error extension uses 25. More carriers increase overhead and preparation/recovery burden; minimizing length may leave an error set uncorrected. Diagnostic: what target error weight is necessary, and what \(m=gnu\) and channel-specific proof follow from that choice?^[1]

Permutation symmetry simplifies the codeword description, but it does not itself prove recovery for every channel. This is a theorem-scope boundary, not an opposing design pressure: specify the noise operators and consult the corresponding recovery result before claiming a capability.^[1]^[2]

Structural–Framed Character¶

Gnu code is strongly formal/structural within quantum information: its codewords, symmetry and correction conditions are mathematical statements, not assessments of whether a device is desirable. Evaluative weight enters when comparing protection against qubit overhead and implementation feasibility. Human practice chooses a noise model and parameter set; laboratory or institutional convention does not make an unproved channel correctable. The name arises from Ouyang's \(g,n,u\) construction, and its vocabulary travels literally among quantum-code papers only when the Dicke ladder/parity specification remains. Importing the “gnu” label to any PI code would conflate family with member; recognizing a new implementation would require identifying actual carriers and recovery operations, not just pointing to symmetry. Its character: a precise parameterized quantum-code construction with theorem-bounded error claims and contingent physical realization.

Structural Core vs. Domain Accent¶

The skeletal relation is redundant encoding of a logical state so specified errors can be distinguished and reversed. That much is carried by the live Error-Correcting Code parent. The gnu mechanism is narrower: symmetric \(m\)-qubit Dicke states at weights \(g\ell\), square-root binomial amplitudes, even/odd logical parity and channel-specific inequalities. Without those, the named construction disappears even if a code remains. It fails the prime bar because these Hilbert-space and excitation-number commitments do not recur literally in all error correction or across unrelated domains. Quantum State, Quantum Circuit and Quantum Operation are live neighbors but not strict gnu parents; only a narrower quantum-code intermediate remains a future question.

This entry is a kind of Error-Correcting Code.

The live Error-Correcting Code is the strict genus because this quantum construction encodes logical states with redundancy and specified error recovery. Its Dicke ladder and parity split are the child differentia; classical codes and other quantum codes lack them. A more specific Quantum Error-Correcting Code intermediate remains a future question, not an asserted node. Shifted gnu codes are later relatives, and this edge imports no blanket classical distance or channel guarantee.^[1]

Relationships to Other Abstractions¶

Current abstraction Gnu Code Domain-specific

Parents (1) — more general patterns this builds on

Gnu Code is a kind of Error-Correcting Code Domain-specific

A gnu code is an error-correcting code with a specific symmetric Dicke-state ladder and parity split.

Hierarchy path (1) — routes to 1 parentless root

Gnu Code → Error-Correcting Code → Encoding And Decoding → Transformation → Function (Mapping)

Neighborhood in Abstraction Space¶

Gnu Code sits in a sparse region of the domain-specific corpus (68^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Quantum States & Information Measures (25 abstractions)

Nearest neighbors

Steane Code — 0.85
Quantum Walk — 0.84
Even code — 0.84
Hamming Scheme — 0.84
Clifford gate — 0.83

Computed from structural-signature embeddings · 2026-10-08

Not to Be Confused With¶

Any permutation-invariant code: symmetry alone does not supply the g-spaced binomial ladder. Shifted gnu code: adds offset \(\Delta\) and has later deletion-channel results. Dicke state: one symmetric fixed-excitation basis state, not the full logical code. A hardware collective-spin device: the original's spin-half and Heisenberg motivation is not an implementation report. Generic deletion correction: channel and recovery conditions must be separately proved.^[1]^[2]

References¶

[1] Yingkai Ouyang, Permutation-invariant quantum codes, Physical Review A 90 (2014), original full text; Introduction equations (1)–(5), sparse-error and spontaneous-decay analyses. registry ↩a ↩b ↩c ↩d ↩e ↩f ↩g ↩h ↩i ↩j ↩k ↩l ↩m ↩n ↩o ↩p ↩q ↩r

[2] Yingkai Ouyang, Permutation-invariant quantum coding for quantum deletion channels, 2021 original full text, §II-C shifted gnu codes and deletion example. registry ↩a ↩b ↩c ↩d ↩e ↩f ↩g ↩h