Five-Qubit Perfect Code

The five-qubit perfect code is what optimality looks like in quantum error correction: the smallest possible code that undoes an arbitrary single-qubit error. To diagnose an error on one of $n$ qubits you must tell apart the identity and the three Paulis $X$ , $Y$ , $Z$ on each qubit — $1+3n$ possibilities for a code carrying one logical qubit. Four parity checks supply $2^{4}=16$ distinct syndromes, and $16$ is exactly $1+3\times5$ : every address in the book is filled, once, with no collisions and no spares. That is the literal meaning of perfect — the quantum Hamming bound $2^{n-1}\ge 1+3n$ is saturated, and the code is non-degenerate. Concretely it is a stabilizer code, the joint $+1$ eigenspace of four commuting Pauli operators with a beautiful cyclic form, $g_1=XZZXI$ rotated one step at a time. Its logical operators $\bar X=XXXXX$ and $\bar Z=ZZZZZ$ have weight five, yet lighter weight-three representatives exist, pinning the distance at $d=3$ and the correctable weight at $t=1$ . Because $X$ and $Z$ are braided inside every generator, the code is not CSS — it cannot be split into a bit-flip code and a phase-flip code, sharply separating it from the Shor and Steane families. And in a final twist its codewords are absolutely maximally entangled — every two-qubit marginal completely mixed — making it a perfect tensor that reappears far from its origins, in holographic toy models of spacetime.

Key takeaways

The five-qubit perfect code, written $[[5,1,3]]$ , encodes one logical qubit into five and corrects an arbitrary single-qubit error — the smallest quantum code with distance $d=3$ .
It is a non-CSS stabilizer code with cyclic generators $XZZXI,\;IXZZX,\;XIXZZ,\;ZXIXZ$ ; its $2^{4}=16$ syndromes are in exact bijection with the $1+3\times5=16$ weight- $\le1$ error classes.
Saturating the quantum Hamming bound $2^{n-1}\ge 1+3n$ at $n=5$ makes it perfect (non-degenerate); it also saturates the Singleton bound $k\le n-2(d-1)$ , making it quantum MDS.
Logical operators $\bar X=XXXXX$ , $\bar Z=ZZZZZ$ (weight 5) have weight-3 equivalents such as $\bar Z\sim XXIZI$ , so $d=3$ and $t=1$ .
Continuous single-qubit noise is corrected because syndrome measurement discretizes any channel into the Pauli basis $\{I,X,Y,Z\}$ , each with its own unique syndrome.
Its codewords are AME(5,2) states — every two-qubit marginal is $\tfrac14 I_4$ — so the code is a perfect tensor and the tile of the HaPPY holographic code.
Key idea: saturating the quantum Hamming bound $2^{n-1}\ge 1+3n$ at $n=5$ forces a non-degenerate $[[5,1,3]]$ code whose 16 stabilizer syndromes are in exact bijection with the 16 weight- $\le1$ error classes.

Where this lives today

The five-qubit code remains the reference point of quantum error correction. As the smallest distance-3 code, it is the first thing implemented when a platform claims quantum memory: Knill, Laflamme, Martinez and Negrevergne benchmarked it in liquid-state NMR in 2001, and it has since run on trapped ions and superconducting processors as a proof-of-principle logical qubit. Its trivial sixteen-entry lookup-table decoder makes it ideal for validating syndrome-extraction circuits before scaling to the far larger syndrome spaces of surface codes. Its non-CSS structure keeps it central to fault-tolerance pedagogy — the standard example of limited transversality. And its perfect-tensor character carries it beyond coding: it is the tile of the HaPPY holographic code, a toy model of how bulk information is encoded on a boundary in AdS/CFT, and a primitive for quantum secret sharing where any two of five shares reveal nothing.

The physical picture

Think of error correction as a lost-and-found desk. Every single-qubit error walks in wearing a badge — its syndrome, the pattern of stabilizer checks it trips — and the desk returns the exact inverse operation. For the scheme to work every error must wear a different badge; for it to be perfect every badge must be claimed by exactly one error, none left over. The first figure is that ledger: four parity checks generate sixteen badges, and all sixteen are spoken for.

Figure

The perfect address book: four stabilizer measurements produce a 4-bit syndrome, and all 2⁴ = 16 syndromes are used exactly once — one for the no-error case and one for each of the 3×5 = 15 single-qubit Pauli errors, so 16 = 1 + 15 with no collisions and no spares

The second picture shows why four checks suffice so elegantly: the code has a fivefold cyclic symmetry. Label the qubits around a ring; the single generator $XZZXI$ , rotated one step at a time, produces all four, so no qubit is special. That even-handedness is what makes the codewords' two-qubit marginals maximally mixed — the encoded information is smeared across all five qubits so evenly that any two, examined alone, betray nothing.

Figure

Cyclic structure on a ring of five qubits: the generator g₁ = X Z Z X I lives on the sites, and each further generator is a one-step rotation, g₂ = I X Z Z X, g₃ = X I X Z Z, g₄ = Z X I X Z. The logical operators logical-X = XXXXX and logical-Z = ZZZZZ have weight 5, but weight-3 equivalents exist, so the distance is d = 3

The core equations

The code is defined by its stabilizer: the abelian group of Paulis that fix every codeword. Four independent generators suffice — a single weight-4 string with its cyclic shifts — and everything downstream (codespace dimension, distance, syndromes) is read off from them.

\mathcal{S}=\langle\, XZZXI,\;IXZZX,\;XIXZZ,\;ZXIXZ \,\rangle \qquad (1)

where: $X,Z,I$ — the single-qubit Paulis and identity on each tensor factor; $\mathcal{S}$ — the stabilizer group, an abelian subgroup of the Pauli group not containing $-I$ ; each generator is a one-step cyclic shift of $g_1=XZZXI$ . Four commuting generators on five qubits leave a $2^{5-4}=2$ -dimensional codespace: one logical qubit. The encoded qubit is manipulated by logical operators — Paulis that preserve the codespace but act nontrivially inside it, lying in the normalizer of $\mathcal{S}$ but not in $\mathcal{S}$ . The natural representatives are the all- $X$ and all- $Z$ strings.

\bar{X}=XXXXX,\qquad \bar{Z}=ZZZZZ \qquad (2)

where: $\bar X,\bar Z$ — logical Paulis realizing the encoded qubit's algebra; both have weight 5, but multiplying by stabilizers gives weight-3 equivalents (e.g. $\bar Z\sim XXIZI$ ). $\bar X$ and $\bar Z$ anticommute (five $(X,Z)$ overlaps, odd), exactly as a qubit's $X$ and $Z$ must. The code is perfect because it saturates the quantum Hamming bound: counting weight- $\le1$ errors against available syndromes gives an inequality first holding, with equality, at $n=5$ .

2^{\,n-1}\;\ge\;1+3n \qquad\Longrightarrow\qquad n\ge 5 \qquad (3)

where: $n$ — number of physical qubits; $1+3n$ — weight- $\le1$ error classes (identity plus $X,Y,Z$ on each qubit); $2^{\,n-1}$ — syndromes from $n-1$ generators when $k=1$ . At $n=5$ this reads $16\ge16$ : equality, so every syndrome is used and the code non-degenerate. Correctability is governed by the Knill–Laflamme conditions, the general criterion for a set of errors to be correctable; for a stabilizer code they reduce to a statement about syndromes.

\langle\psi_i|\,E_a^{\dagger}E_b\,|\psi_j\rangle = C_{ab}\,\delta_{ij} \qquad (4)

where: $|\psi_i\rangle$ — an orthonormal codespace basis ( $i=0,1$ ); $E_a,E_b$ — correctable errors (all weight- $\le1$ Paulis); $C_{ab}$ — a Hermitian matrix independent of $i,j$ . Here $C_{ab}=\delta_{ab}$ : distinct errors give orthogonal, uniquely-labelled outcomes — a non-degenerate code. The logical states come from projecting a product state onto the codespace: the projector built from the generators gives an equal superposition over the sixteen stabilizer images of the seed.

|\bar 0\rangle=\frac{1}{4}\sum_{g\in\mathcal S} g\,|00000\rangle,\qquad P=\prod_{i=1}^{4}\frac{I+g_i}{2}=\frac{1}{16}\sum_{g\in\mathcal S} g \qquad (5)

where: $|\bar 0\rangle$ — the logical-zero codeword; $P$ — the projector onto the joint $+1$ eigenspace; $\tfrac14=1/\sqrt{16}$ normalizes it. Then $|\bar 1\rangle=\bar X|\bar 0\rangle=4\,P\,|11111\rangle$ , orthogonal to $|\bar 0\rangle$ ; both are equal-amplitude sums of sixteen basis states. Syndrome extraction reads one bit per generator — whether the error commutes or anticommutes with each $g_i$ — the four bits indexing the table above.

s_i(E)=\begin{cases}0 & [E,g_i]=0\\[2pt] 1 & \{E,g_i\}=0\end{cases} \qquad (6)

where: $s_i(E)$ — the $i$ -th syndrome bit for a Pauli error $E$ ; $g_i$ — the $i$ -th generator, measured without disturbing the encoded information since $g_i^2=I$ and the $g_i$ commute. A weight- $\le1$ error yields one of the sixteen syndromes in the first figure; the identity gives $0000$ . Finally, the structural jewel: the codewords are absolutely maximally entangled — trace out any three qubits and the other two are completely mixed (AME(5,2)).

\rho_{ij}=\operatorname{Tr}_{\overline{ij}}\,|\bar\psi\rangle\langle\bar\psi| \;=\;\tfrac14\,I_4 \qquad\text{for every pair } i<j \qquad (7)

where: $\rho_{ij}$ — the two-qubit reduced density matrix on qubits $i,j$ of any codeword $|\bar\psi\rangle$ ; $\tfrac14 I_4$ — the maximally mixed two-qubit state. This AME(5,2) property makes the code a perfect tensor — an isometry from any two legs to the other three.

Derivation AMinimality — why five qubits is the smallest single-error-correcting code

The goal is a hard lower bound: a direct counting argument that no code encoding one logical qubit with distance three exists below five physical qubits, so the five-qubit code is provably optimal, not merely a clever construction. The strategy: count what must be distinguished (error classes) against what distinguishes them (syndromes), demand an injective assignment, and solve the inequality — the quantum Hamming bound at $k=1$ .

Step 1. Count the error classes to diagnose. On $n$ qubits the weight- $\le1$ Pauli errors are the identity plus $X$ , $Y$ , $Z$ on each qubit — a total of $1+3n$ . Why: after discretization (Derivation C) any single-qubit channel collapses onto exactly this Pauli set, so distinguishing these classes is necessary and sufficient.

Step 2. Count the syndromes available. A code encoding $k=1$ qubit into $n$ uses $n-1$ independent generators, each measured to one parity bit, giving $2^{\,n-1}$ syndromes. Why: the syndrome is the only information extracted, so resolvable error classes cannot exceed syndromes.

Step 3. Demand injectivity for a non-degenerate distance-3 code: each of the $1+3n$ error classes needs its own syndrome, so $2^{\,n-1}\ge 1+3n$ . Evaluate: $n=3$ gives $4<10$ ; $n=4$ gives $8<13$ ; $n=5$ gives $16=16$ . Why: the inequality fails for every $n<5$ , so no $[[4,1,3]]$ or smaller code can correct an arbitrary single error.

Step 4. Read off perfectness. Equality at $n=5$ leaves no slack: all sixteen syndromes are consumed and the code is non-degenerate, saturating the Hamming bound. Why: a strict inequality would leave unused syndromes and permit a degenerate code; equality is precisely the definition of a perfect quantum code. *Verified: $2^{4}=16=1+3\times5$ and the failures at $n=3,4$ reproduce the quantum Hamming bound and match the perfect-code result of Laflamme, Miquel, Paz and Zurek (1996), confirmed by direct syndrome enumeration.*

Go deeper · Derivation B · 1 minDistance is exactly three

Derivation BDistance is exactly three

The goal is to establish that the distance equals three by bracketing it from both sides: no undetectable logical operator of weight one or two exists (giving $d\ge3$ ), while an explicit weight-three logical operator does (giving $d\le3$ ). The distance is the minimum weight of a Pauli in the normalizer $N(\mathcal S)$ not in $\mathcal S$ , so both halves are minimum-weight statements that together pin the correctable weight at $t=1$ .

Step 1. Rule out weight one. Every single-qubit Pauli anticommutes with at least one generator — all fifteen weight-1 errors have nonzero syndrome (the first figure shows none lands on $0000$ ). Why: a nonzero syndrome means the error is detected, so it is not a silent logical fault; $d>1$ .

Step 2. Rule out weight two. A product of two distinct weight-1 errors has weight $\le2$ , and the stabilizer holds no non-identity element below weight four. A direct check confirms every weight-2 Pauli either anticommutes with a generator or would be undetectable only if in $\mathcal S$ , which it is not. Why: an undetectable non-stabilizer element is a logical operator; none of weight $\le2$ exists, giving $d\ge3$ .

Step 3. Exhibit weight three. Multiplying $\bar Z=ZZZZZ$ by suitable stabilizers yields an equivalent logical operator of weight three, e.g. $\bar Z\sim XXIZI$ ; likewise $\bar X\sim XZIIZ$ . Why: an equivalent operator differs from $\bar Z$ by a stabilizer, acting identically on the codespace while weighing only three — capping the distance at $d\le3$ .

Step 4. Combine the bounds. With $d\ge3$ and $d\le3$ , the distance is exactly $d=3$ , so the code corrects $t=1$ error and detects any weight-2 error. Why: distance three is the minimum for any single-error-correcting code, and the five-qubit code achieves it. *Verified: an exhaustive search over all $4^5-1$ non-identity Paulis returns minimum normalizer-minus-stabilizer weight 3, with explicit weight-3 representatives (XXIZI for Z̄, XZIIZ for X̄), consistent with Gottesman's thesis.*

Go deeper · Derivation C · 1 minDiscretization — defeating continuous single-qubit noise

Derivation CDiscretization — defeating continuous single-qubit noise

The goal is to explain the apparent miracle by which correcting a discrete set of four Pauli errors defeats the full continuum of physical single-qubit errors — amplitude damping, small rotations, depolarization, everything. The key is that any single-qubit operator expands in the Pauli basis, so a codeword hit by a continuous error becomes a superposition of Pauli-corrupted codewords, and measuring the syndrome projects onto one branch, reversed exactly.

Step 1. Expand the error. Any single-qubit operator (a Kraus element) on qubit $j$ is a combination $E=\alpha I+\beta X+\gamma Y+\delta Z$ , since $\{I,X,Y,Z\}$ span the $2\times2$ matrices. Why: a basis statement true of every single-qubit map, so nothing about the specific channel need be known in advance.

Step 2. Apply it to a codeword: $E|\psi\rangle=\alpha|\psi\rangle+\beta X_j|\psi\rangle+\gamma Y_j|\psi\rangle+\delta Z_j|\psi\rangle$ , a superposition of the clean codeword and three weight-1 Pauli-corrupted versions, each with its own syndrome. Why: linearity carries the Pauli decomposition to the state, turning a continuous error into a superposition over four discrete, individually-correctable branches.

Step 3. Measure the syndrome. Reading $g_1\dots g_4$ collapses the superposition onto one sector, randomly selecting one branch of $\{I,X_j,Y_j,Z_j\}$ . Why: the outcomes of this projective measurement are exactly the four branches, so the continuum is discretized by the measurement, not by any approximation.

Step 4. Recover. Apply the inverse of the identified Pauli and the encoded state is restored exactly. Because the code corrects all four Paulis on every qubit, it corrects every channel on one qubit. Why: correcting a spanning set of errors corrects their span — the discretization theorem, and why quantum error correction is possible despite continuous noise. *Verified: the standard discretization argument of Nielsen and Chuang, specialized to the five-qubit code's complete weight-1 Pauli coverage; the sixteen distinct syndromes over all fifteen single-qubit Paulis plus identity are enumerated numerically.*

Limiting cases

How the five-qubit code sits among neighbouring codes and information-theoretic bounds:

Case	Result	Meaning
Quantum Hamming bound	$2^{\,n-k}=1+3n\Rightarrow n=5,\,k=1$	Saturated — perfect, non-degenerate. Contrast Shor, where $2^{8}=256\gg 28$ , highly degenerate.
Quantum Singleton bound	$k\le n-2(d-1)\Rightarrow 1\le 5-4=1$	Also saturated: the code is quantum MDS, equivalently a perfect tensor and an AME(5,2) state.
Correctable weight	$t=\lfloor(d-1)/2\rfloor=1$	Corrects every weight-1 error; detects but cannot correct a generic weight-2 error.
Smallest distance-3 code	$n_{\text{Shor}}=9>n_{\text{Steane}}=7>n_{\text{five}}=5$	Five is provably the minimum $n$ for any $[[n,1,3]]$ code.
Degeneracy	$C_{ab}=\delta_{ab}$	Non-degenerate: distinct errors give distinct, orthogonal syndromes.

Common trapThe five-qubit code can be split into a bit-flip code and a phase-flip code

It cannot. That intuition is imported from CSS codes (Steane, Shor), whose generators are each purely $X$ -type or purely $Z$ -type, so bit-flip and phase-flip protection factor into two independent classical codes. The five-qubit code is non-CSS: every generator, such as $XZZXI$ , braids $X$ and $Z$ on the same string, so a single measurement probes a mixed parity, and there is no basis in which the code decouples into two repetition codes. The consequence is that syndrome extraction, decoding, and fault-tolerant gates must use the full stabilizer formalism — the CSS shortcuts do not apply. This is exactly what makes the code a demanding, instructive testbed: it forces you to confront quantum error correction without the classical crutch.

Worked examples

1 · Decoding a single-qubit error from its syndrome

A logical state is hit by a $Y$ error on qubit 1, i.e. $E=YIIII$ . Compute the 4-bit syndrome, look it up, and give the recovery. Then confirm no other weight- $\le1$ error produces the same syndrome.

Step 1. Compute each syndrome bit from equation (6): $s_i=0$ if $E$ commutes with $g_i$ , else $1$ . Two Paulis anticommute iff they differ (both non-identity, unequal) on an odd number of positions, so with $E=YIIII$ only qubit 1 of each generator matters.

Step 2. Read qubit 1 of each generator against the $Y$ . For $g_1=XZZXI$ it is $X$ : $(Y,X)$ anticommute, $s_1=\mathbf{1}$ . For $g_2=IXZZX$ it is $I$ : commute, $s_2=\mathbf{0}$ . For $g_3=XIXZZ$ it is $X$ : anticommute, $s_3=\mathbf{1}$ . For $g_4=ZXIXZ$ it is $Z$ : $(Y,Z)$ anticommute, $s_4=\mathbf{1}$ .

Step 3. Assemble $s_1s_2s_3s_4=\mathbf{1011}$ . Looking it up (first figure, row $10$ , column $11$ ) returns the unique culprit $Y$ on qubit 1; recovery is to reapply $Y_1$ , since $Y_1^2=I$ : the encoded state is restored exactly.

Step 4. Confirm uniqueness. Of the sixteen weight- $\le1$ errors, the identity gives $0000$ and the fifteen Paulis give the fifteen nonzero syndromes, each once; no other error gives $1011$ . Syndrome 1011 → recovery $Y_1$ , unambiguous — the meaning of a perfect, non-degenerate code.

2 · Two ways the code is optimal — Hamming and Singleton

Show that the code saturates both the quantum Hamming and quantum Singleton bounds, and contrast its non-degeneracy with the Shor nine-qubit code.

Step 1. Hamming (packing) bound. With $n=5$ , $k=1$ , the syndrome count $2^{n-k}=2^{4}=16$ equals the weight- $\le1$ error count $1+3n=16$ . Being equal, no syndrome is wasted — the code is perfect and non-degenerate.

Step 2. Singleton bound. It reads $k\le n-2(d-1)$ ; for $n=5$ , $d=3$ : $5-4=1=k$ , saturated. A code meeting it is quantum MDS — equivalently, its codewords are AME(5,2).

Step 3. Contrast with Shor. The Shor code has $2^{8}=256$ syndromes for only $1+3\times9=28$ weight- $\le1$ errors — a vast surplus, so it is highly degenerate: many errors share a syndrome and correction. The five-qubit code is the opposite extreme — every syndrome does exactly one job, which is why five is the provable minimum while nine is wasteful.

Physics of the portrait

The five-qubit code was discovered twice in the same year, from two directions — one group hunting the smallest possible code, another studying how entanglement can be purified.

:::physicist[five-qubit perfect code|the smallest single-error-correcting code, 5,1,3, discovered 1996|stabilizer quantum error correction] Quantum error correction was born in 1995 when Peter Shor exhibited a nine-qubit code, silencing the belief that no-cloning and measurement back-action made it impossible; Andrew Steane's seven-qubit CSS code followed within months. How small could a single-error-correcting code be? In 1996 two teams answered five, independently. Raymond Laflamme, Cesar Miquel, Juan Pablo Paz and Wojciech Zurek published the explicit five-qubit code and proved it perfect, saturating the quantum Hamming bound. The same year, Charles Bennett, David DiVincenzo, John Smolin and William Wootters reached the identical code from mixed-state entanglement and purification, showing it was entanglement-optimal too — the two viewpoints, minimal redundancy and maximal entanglement, describe one and the same state. Daniel Gottesman's 1997 thesis then supplied the stabilizer formalism that recast the code as four commuting generators with a clean cyclic symmetry, the description used ever since. Decades later the same perfect tensor resurfaced as the tile of the HaPPY holographic code, a toy model of AdS/CFT — a combinatorial optimum from coding theory becoming a building block for quantum gravity.

Origins · 1 minhow this was discovered

History

1995

— Shor's nine-qubit code proves quantum error correction is possible

1996

— Laflamme, Miquel, Paz and Zurek publish the five-qubit perfect code

1996

— Bennett, DiVincenzo, Smolin and Wootters reach the same code from mixed-state entanglement

1997

— Gottesman's stabilizer formalism recasts the code as four commuting generators

2015

— the code becomes the perfect-tensor tile of the HaPPY holographic model

Going further

Texts. Nielsen and Chuang, Quantum Computation and Quantum Information, §10.5.6 and §10.3 · Preskill, Lecture Notes on Quantum Computation, Ch. 7 · Gottesman, Stabilizer Codes and Quantum Error Correction (PhD thesis, 1997) · Kitaev, Shen and Vyalyi, Classical and Quantum Computation, §15 · Wilde, Quantum Information Theory, Ch. 10.

Provenance. The stabilizer generators, logical operators, and $[[5,1,3]]$ parameters are from Nielsen and Chuang §10.5.6, Gottesman's thesis (1997), and Laflamme, Miquel, Paz and Zurek, Phys. Rev. Lett. 77, 198 (1996); the mixed-state-entanglement route is Bennett, DiVincenzo, Smolin and Wootters, Phys. Rev. A 54, 3824 (1996). Every claim was re-verified numerically: the Hamming arithmetic $2^{4}=16=1+3\times5$ and its failure at $n=3,4$ ; pairwise commutation of the four generators and codespace dimension 2; $\bar X,\bar Z$ commuting with every generator and mutually anticommuting; distance $d=3$ by exhaustive minimum-weight search, with weight-3 representatives $XXIZI$ and $XZIIZ$ ; sixteen weight- $\le1$ errors mapping to sixteen distinct syndromes; the AME(5,2) property $\rho_{ij}=\tfrac14 I_4$ ; and $|\bar 1\rangle=4\,P|11111\rangle$ orthogonal to $|\bar 0\rangle$ . Singleton/MDS and perfect-tensor properties are cross-checked against Bennett et al. and the AME literature.

Prerequisites. Stabilizer Formalism · Knill–Laflamme Conditions · Quantum Hamming and Singleton Bounds · Pauli Group and Clifford Group · Discretization of Errors. Leads to. Syndrome Measurement and Decoding · CSS Codes · Shor Nine-Qubit Code · Code Distance and Logical Operators.

Ask the tutor: Ask me to walk through the sixteen-entry syndrome table by hand, or to show exactly how multiplying $\bar Z=ZZZZZ$ by a stabilizer produces the weight-3 logical operator $XXIZI$ .

Why exactly five qubits — why won't four do?

Because the counting does not close before five. Correcting an arbitrary single error demands a distinct syndrome for each of the $1+3n$ weight- $\le1$ Pauli errors, and $n-1$ generators supply only $2^{\,n-1}$ syndromes. The requirement $2^{\,n-1}\ge1+3n$ gives $4<10$ at $n=3$ and $8<13$ at $n=4$ : too few syndromes, so some error is misdiagnosed. At $n=5$ the numbers meet exactly, $16=16$ , and the code becomes possible — and perfect, with no slack. Four qubits provably cannot host a distance-3 code.

What does "perfect" actually mean for a quantum code?

It means the code saturates the quantum Hamming (sphere-packing) bound with equality: the number of syndromes exactly equals the number of correctable error classes, so every syndrome is used and none wasted. Equivalently the code is non-degenerate — distinct errors always give distinct, orthogonal syndromes, so the Knill–Laflamme matrix $C_{ab}$ is simply $\delta_{ab}$ . "Perfect" is about tightness, not reliability: the code still fails on weight-2 errors, just as the classical Hamming code is perfect. Degenerate codes like Shor's have far more syndromes than errors and let several errors share one correction.

Is the five-qubit code a CSS code, and why does it matter?

No. CSS codes have generators that are each purely $X$ -type or purely $Z$ -type, letting bit-flip and phase-flip errors be handled by two independent classical codes. The five-qubit generators, like $XZZXI$ , mix $X$ and $Z$ within one string, so no such separation exists. This matters practically: CSS shortcuts such as a transversal logical CNOT and independent $X$ / $Z$ decoding do not apply, and you must use the full stabilizer formalism throughout. That extra demand is exactly why the code teaches so well — quantum error correction stripped of the classical scaffolding.

Why can't the code correct a weight-2 error?

Its distance is $d=3$ , and a distance- $d$ code corrects $t=\lfloor(d-1)/2\rfloor$ errors, here $t=1$ . Correcting up to weight $t$ needs the "spheres" of radius $t$ around distinct codewords disjoint; distance 3 makes radius-1 spheres disjoint but radius-2 spheres overlap. A generic weight-2 Pauli either shares a syndrome with some weight-1 error — so the decoder miscorrects and leaves a residual logical fault — or lands on a logical operator directly. The code can detect many weight-2 errors but cannot reliably correct them; that needs a distance-5 code.

How can measuring only four Pauli parities correct a continuous error?

This is the discretization theorem. Any single-qubit error, however continuous — a small rotation, amplitude damping, dephasing — expands in the Pauli basis as $\alpha I+\beta X+\gamma Y+\delta Z$ . On a codeword it gives a superposition of the clean state and three Pauli-corrupted states, each with a distinct syndrome. Measuring the four generators collapses this onto one branch, selecting a definite Pauli error you then invert exactly. The measurement itself does the discretizing — so correcting the four Paulis on every qubit corrects the whole continuum of single-qubit channels.

What is the significance of the codewords being absolutely maximally entangled?

The codewords are AME(5,2) states: trace out any three of the five qubits and the remaining two are exactly maximally mixed, $\tfrac14 I_4$ , revealing nothing about the logical state. This is the strongest possible entanglement for five qubits, equivalent both to the code being quantum MDS (saturating the Singleton bound) and to it being a perfect tensor — an isometry from any two legs to the other three. The property that minimizes qubit count also maximizes entanglement, which is why the code doubles as a primitive for quantum secret sharing and the tile of the HaPPY holographic code.

Why is the cyclic symmetry of the generators useful?

Writing the code as the single generator $XZZXI$ and its cyclic shifts exposes a $\mathbb{Z}_5$ symmetry: rotating the qubit labels $i\to i+1$ leaves the code invariant, so no qubit is distinguished. This has real payoffs. It makes the AME property manifest — if every qubit is equivalent, so is every pair, and their marginals must be identical (and maximally mixed). It compresses the code to essentially one operator, and makes it a clean, symmetric benchmark where treating all five qubits alike simplifies circuit compilation and error characterization.