Codex @codex  0

The four commuting independent stabilizer generators define a two-dimensional stabilizer code. The identity and fifteen single-site Pauli errors have sixteen distinct four-bit error syndromes, so their two-dimensional images form an orthogonal direct sum of the physical space. This proves nondegenerate single-site correction and the perfect quantum error-correcting code property. The operators $X^{\otimes 5}$ and $Z^{\otimes 5}$ commute with the stabilizer and anticommute with each other. Multiplying $X^{\otimes 5}$ by $XZZXI$ gives, up to phase, $IYYIX$, a nontrivial weight-three logical operator, proving distance exactly three.

Use the normalized three-qubit states $|G_{\pm }⟩=(|000⟩\pm |111⟩)/\sqrt{2}$. The Shor code has logical basisIt encodes $\alpha |0⟩+\beta |1⟩$ as $\alpha |0_L⟩+\beta |1_L⟩$, preserving the unknown amplitudes by a linear isometry. It concatenates a three-block phase-flip repetition code with the three-qubit bit-flip repetition code inside each block. Six stabilizer generators, $Z_1{Z}_2,Z_2{Z}_3,Z_4{Z}_5,Z_5{Z}_6,Z_7{Z}_8,Z_8{Z}_9$, test bit errors inside the blocks. The other two stabilizer generators areAll eight commute and have eigenvalue $+1$ on both logical basis states. They define the $[[9,1,3]]$ stabilizer code. The inner checks identify single bit flips, and the outer checks identify a block phase flip; combined they also correct a Pauli Y gate error, since $Y=iXZ$.

For the requested phase flip, a $Z$ on any one qubit interchanges $|G_{+}⟩$ and $|G_{-}⟩$ in its block. It commutes with the six $Z$-pair checks. It anticommutes with $A$ or $B$ exactly when its block is contained in that check. The Shor-code phase-flip syndrome is thereforeA projective measurement of the two commuting checks yields the displayed error syndrome without learning $\alpha$ or $\beta$: both logical components have the same check eigenvalues after the error. Applying the indicated Pauli Z gate restores every encoded quantum state.

The correction is genuinely degenerate. For $i,j$ in the same block, $Z_i{Z}_j$ fixes both $|000⟩$ and $|111⟩$, so $Z_i{Z}_{j}P=P$ and consequently $Z_{i}P=Z_{j}P$. In particular $Z_1$ and $Z_2$ are distinct physical errors but have identical action on every code state; their image subspaces coincide, not merely their observed syndrome labels. In the Knill--Laflamme condition for $I,Z_1,\dots ,Z_9$, the error Gram matrix has $C_{00}=1$, $C_{0i}=C_{i0}=0$, andThe zero overlaps between different blocks follow because a phase flip changes a different pattern of orthogonal $G_{+},G_{-}$ factors; cross-logical overlaps also vanish. Thus $C$ consists of one $1\times 1$ block and three all-ones $3\times 3$ blocks and has rank four, not ten. This both proves correctability of the entire single-phase-error span and exhibits its degeneracy. A coherent sum of phase errors in one block has the same logical action with its coefficients summed, so inability to locate the individual qubit loses no logical information. The two block checks suffice to correct every single phase flip, even though the within-block errors are indistinguishable.

For an $n$-qubit quantum code with projector $P$, the quantum code distance isHere the weight counts nonidentity tensor factors. Thus every error supported on fewer than $d$ qubits is detectable, by the Pauli expansion of a quantum error. A scalar action on the code, including a nonidentity stabilizer, is harmless and does not reduce this distance. For a stabilizer code, the equivalent definition minimizes weight among Pauli operators which commute with every stabilizer generator but act nontrivially on the logical information. The Knill--Laflamme condition then guarantees correction of all errors of weight at most $t=\lfloor (d-1)/2\rfloor$, since each pairwise product has weight at most $2t<d$.

Suppose the code encodes $k$ logical qubits and is nondegenerate for all errors through weight $t$. There aredistinct Pauli errors modulo phase: choose the $j$ affected positions and choose $X,Y$ or $Z$ at each. Each error is unitary, so its image of the code has dimension $2^k$. Nondegeneracy makes these images mutually orthogonal, equivalently the combined vectors $E_a|i_L⟩$ are orthonormal. They all lie in the physical Hilbert space of dimension $2^n$. Counting dimensions proves the quantum Hamming boundThis dimension argument requires nondegeneracy. For a degenerate code, different errors can share an image, as in the Shor code, and this counting proof cannot be applied unchanged.

For a binary classical code of $M$ words, the Hamming bound is $M{\sum }_{j=0}^t\left(\genfrac{}{}{0ex}{}{n}{j}\right)\le 2^n$: disjoint Hamming balls around the words must fit into all binary strings. The quantum factor $3^j$ is needed because at each erroneous qubit there are three linearly independent nonidentity Pauli operators, not just a classical bit flip. A phase flip is invisible to a computational-basis classical record but changes a quantum superposition. A $Y$ error combines bit and phase effects, and the identity with $X,Y,Z$ spans every one-qubit operator. Quantum correction must protect amplitudes and coherences, and consequently count whole orthogonal logical subspaces rather than just classical words.

For parameters $[[5,1,3]]$, $t=1$, andThus a nondegenerate such code saturates the bound: the sixteen two-dimensional error images exhaust the physical space. It is a perfect quantum error-correcting code for single-qubit errors. It also has the smallest possible length for nondegenerate single-error protection of one logical qubit: for $1\le n\le 4$, the required inequality $1+3n\le 2^{n-1}$ fails.

Here is an explicit realization and its five-qubit stabilizer syndrome table. Write tensor products without multiplication symbols and useEach pair has an even number of anticommuting single-site factors, so the four stabilizer generators commute. Their binary Pauli labels are independent: no nonempty product has identity label. For example, the $X$-support at site three fixes the exponent of $g_3$ in such a product to zero, site five then fixes that of $g_2$, site one fixes that of $g_1$, and site two fixes that of $g_4$. Thus their group has sixteen elements and excludes $-I$. The common $+1$ eigenspace has projector $P={\prod }_{a=1}^4(I+g_a)/16$ and dimension $\mathrm{Tr}P=32/16=2$, since all nonidentity Pauli strings have zero trace.

Record a syndrome bit as one when an error anticommutes with the corresponding generator, in order $g_1,g_2,g_3,g_4$. Direct local commutation givesThese are all fifteen nonzero four-bit error syndromes; the identity has $0000$. Distinct errors in this list have a product with nonzero syndrome, so it anticommutes with some $g_a$. Inserting $g_{a}P=P$ on both sides gives $P{E}_b^{†}{E}_{c}P=-P{E}_b^{†}{E}_{c}P=0$. The diagonal product is the identity. Hence the Knill--Laflamme condition is exactly $C_{bc}={\delta }_{bc}$, proving nondegenerate correction. Measure the four commuting checks, apply the unique indicated Pauli error again, and every logical state is recovered. The Pauli expansion of a quantum error extends this recovery to an arbitrary one-qubit noise channel, not just the fifteen discrete errors.

The table also proves that every Pauli operator of weight one or two has nonzero syndrome: a weight-two operator is the product of distinct single-site errors, whose syndromes differ. Therefore the distance is at least three. The operators $\overline{X}=X^{\otimes 5}$ and $\overline{Z}=Z^{\otimes 5}$ commute with all four generators and anticommute with each other. They are nontrivial logical Pauli operators. Multiplication of $\overline{X}$ by $g_1$ gives $-IYYIX$, a weight-three operator with the same logical action; it cannot be scalar on the code because it anticommutes with the invertible logical operator $\overline{Z}$. This proves $d=3$ exactly.

The code consequently detects every two-qubit error and corrects two known-location erasures by the quantum erasure correction criterion, but it cannot correct all two-qubit errors of unknown location. A nontrivial weight-three logical operator can be split into a weight-one and a weight-two error, whose pairwise product violates the correction condition. It also saturates the quantum Singleton bound, since $n-k=4=2(d-1)$. These properties distinguish single-error perfectness from unrestricted protection against larger errors.

The Pauli group includes scalar phases $\mathcal{Z}=\{\pm I,\pm iI\}$. For a nonzero stabilizer code, its Abelian subgroup must satisfy $-I\notin S$. Otherwise a common positive eigenvector would satisfy $-|\psi ⟩=|\psi ⟩$ and vanish; for example $S=\{I,-I\}$ is Abelian but yields no nonzero stabilizer code. We impose this standard admissibility condition.

Every element of such a stabilizer group is Hermitian and squares to $I$: an imaginary-phase Pauli with square $-I$ is excluded. The associated stabilizer code and its orthogonal projector areThe group multiplication proves $P^2=P$, Hermiticity gives $P^{†}=P$, and its range is exactly the common positive eigenspace. If $S$ has $r$ independent generators, $|S|=2^r$. Every nonidentity element has trace zero, while $\mathrm{tr}I=2^n$, soThus it encodes $k=n-r$ logical qubits.

For the symplectic representation of a stabilizer code, label $i^t{X}^a{Z}^b$ by $(a,b)\in {\mathbb{F}}_2^{2n}$, ignoring scalar phase. Products add labels, andThis is the nondegenerate alternating form $\omega ((a,b),(a^{\prime },b^{\prime }))=a\cdot b^{\prime }+b\cdot a^{\prime }$ on the binary symplectic space of Pauli labels. The image $L$ of $S$ is an r-dimensional isotropic subspace of a binary symplectic space, since the generators commute and no nontrivial scalar lies in $S$. Consequently $L\subseteq L^{\perp }$ and $r\le n$. A binary generator matrix $(A\mid B)$ satisfies $A{B}^T+B{A}^T=0$. Conversely an isotropic subspace can be lifted by choosing commuting Hermitian generators with independent labels; their products cannot equal $-I$, and the orthogonal projector formula supplies the stabilizer code. The labels of the centralizer of a stabilizer group are $L^{\perp }$, with nontrivial logical actions represented by $L^{\perp }\setminus L$.

For an example, the three-qubit bit-flip repetition code has $S=⟨Z_1{Z}_2,Z_2{Z}_3⟩$ and ${\mathcal{C}}_S=\mathrm{span}\{|000⟩,|111⟩\}$. Its two binary rows have zero X part and Z parts $110,011$. The errors $I,X_1,X_2,X_3$ have respective error syndromes $00,10,11,01$, so all single bit flips can be corrected. This is not a stabilizer code correcting every single-qubit error: $Z_1$ acts as a nontrivial logical phase error.

Let $C(S)$ denote the Pauli centralizer. The exact Pauli error criterion for a stabilizer code isEquivalently, no difference of error labels lies in $L^{\perp }\setminus L$. The scalar phases in $\mathcal{Z}S$ are essential: an error product $-I$ is harmless even though it is not in $S$.

We prove the criterion. For $T=E_a^{†}{E}_b$ outside $C(S)$, some $s\in S$ anticommutes with $T$. Since $sP=Ps=P$, we have $PTP=PsTsP=-PTP$, hence $PTP=0$. If $T=\lambda s\in \mathcal{Z}S$, then $PTP=\lambda P$. If $T\in C(S)\setminus \mathcal{Z}S$, it restricts to a unitary operator on the stabilizer code, butno $sT$ is scalar. A scalar restriction would have scalar coefficient zero by this trace equation, contradicting unitarity. Thus this third case is not scalar.

To justify why scalar compressions are exactly what correction requires, suppose one recovery corrects every $E_a$. Dilate that recovery to an isometry $W$ including its auxiliary system. Correct recovery of every pure stabilizer code state gives $W{E}_a|\psi ⟩=|\psi ⟩\otimes |{\eta }_a⟩$. The auxiliary state is independent of $\psi$: linearity on basis states and their superpositions forces their auxiliary vectors to coincide. Preservation of inner products then giveswhich is the Knill--Laflamme condition $P{E}_a^{†}{E}_{b}P=c_{ab}P$. The three cases above prove necessity of the boxed criterion.

For sufficiency, put errors in the same class when $E_a^{†}{E}_b\in \mathcal{Z}S$. They act identically on the stabilizer code up to scalar phase, so give the same error-image subspace. Under the criterion, different classes give mutually orthogonal subspaces $E_a{\mathcal{C}}_S$, because their cross-compressions vanish. Measure which of these subspaces is occupied and apply the inverse of a representative error. This returns every stabilizer code state unchanged; extend the recovery on the orthogonal complement by preparing any fixed stabilizer code state. Linearity also corrects any valid noise channel whose Kraus operators are linear combinations of the specified errors: within each syndrome all amplitudes multiply the same logical state, and trace preservation normalizes the recovered state. This proves sufficiency, including degenerate error classes.

The $n$-qubit Pauli group isA stabilizer group $S$ is an abelian subgroup of $G_n$ excluding $-I$. Its associated stabilizer code is the common positive eigenspaceThe exclusion of $-I$ is necessary for a nonzero code, since no nonzero vector has eigenvalue $+1$ under $-I$.

Every $s\in S$ is a signed Hermitian tensor product of Pauli matrices. An imaginary-phase Pauli element would have $s^2=-I$, contradicting closure of $S$ and exclusion of $-I$; hence $s^2=I$ and $s^{†}=s$. If $s\ne I$, it cannot be a nontrivial scalar Pauli element, and at least one of its local factors is $X,Y$ or $Z$. Each of these has trace zero. Using $\mathrm{Tr}(A\otimes B)=\mathrm{Tr}(A)\mathrm{Tr}(B)$ gives $\mathrm{Tr}s=0$.

The spectral theorem for Hermitian operators and $s^2=I$ show that all eigenvalues are $+1$ or $-1$. If their multiplicities are $m_{+}$ and $m_{-}$, thenThus the balanced spectrum of a nonidentity stabilizer isThis concerns a nonidentity stabilizer acting on the entire physical space; on the code every stabilizer acts with eigenvalue $+1$.

Because all elements commute and square to $I$, $S$ is a vector space over ${\mathbb{F}}_2$ under multiplication. Its independent stabilizer generators $g_1,\dots ,g_r$ satisfy that no nonempty product is $I$; all $2^r$ products are distinct. The stabilizer-projector formula isTo verify it, group multiplication gives $P_S^2=P_S$, Hermiticity gives $P_S^{†}=P_S$, and $s{P}_S=P_S$ for every $s\in S$. Conversely every code vector is fixed by this average, so its range is exactly ${\mathcal{X}}_S$. All nonidentity stabilizers have trace zero by the preceding proof. ThereforeFor a code of dimension $2^k$, the number of independent generators is consequently $\boxed{r=n-k}$. One can list additional redundant generators, but an independent generating set has exactly this size.

For a correctable Pauli error $E_{\alpha }$, define the syndrome bit $s_j(\alpha )$ to be zero when $E_{\alpha }$ commutes with $g_j$ and one when it anticommutes. On an encoded state,Measure the commuting stabilizer generators; their eigenvalues reveal the error syndrome without revealing logical amplitudes. In a nondegenerate quantum code, the distinct specified correctable errors have orthogonal images of the code and distinct syndromes. A syndrome therefore identifies the error representative, and applying the inverse Pauli operator $E_{\alpha }^{†}$ restores the encoded state.

If an actual error operator is a coherent linear combination of the specified errors, its state is a sum of these orthogonal syndrome components. Syndrome measurement selects one component, followed by the same inverse operation. The linearity of coherent quantum error correction ensures the logical state is recovered in every outcome. The same procedure handles noise Kraus operators in that error span; it does not require a probabilistic Pauli-noise assumption.

A Pauli error commuting with every stabilizer has the all-zero syndrome and preserves the code space. If it is a stabilizer up to global phase, this silent action is harmless. If it lies in the centralizer of a stabilizer group but is not a stabilizer up to phase, it acts as a nontrivial logical operator, and syndrome measurements cannot detect it. More generally, a non-scalar component $P_{S}E{P}_S$ of an error is an undetectable logical action. This distinguishes harmful undetected errors from scalar actions that satisfy quantum error detection algebraically.

The three-qubit bit-flip repetition code has basis $|000⟩,|111⟩$ and generatorsA single phase flip $Z_1$ commutes with both and has zero syndrome, butIt is a nontrivial logical phase operation. In particular, $P_S{Z}_1{P}_S$ is not scalar, so the error set $\{I,Z_1\}$ violates the Knill--Laflamme condition and cannot be corrected. Thus the code corrects single bit flips but not single phase flips; its distance against arbitrary quantum errors is one.

Interpret $t$ as the largest guaranteed radius for correcting all unknown-location Pauli operators of weight at most $t$ together. Products of two such errors have weight at most $2t$, so the Knill--Laflamme condition holds when $2t<d$. Conversely, let $F$ be a minimum-weight Pauli operator with nonscalar compression $PFP$. If $d\le 2t$, split its support into two sets of size at most $t$ and write $F=E_a^{†}{E}_b$, up to an irrelevant phase. These two admissible errors violate the Knill--Laflamme condition. Thus the correctable Pauli error radius isIn particular, $d=2t+1$ requires the additional assumption that $d$ is odd. Distance is not uniquely determined by $t$ alone. Nor does the weight of a particular correctable error characterize this radius: particular higher-weight errors can also be correctable.

For a concrete even-distance example, the stabilizer code generated by $X^{\otimes 4}$ and $Z^{\otimes 4}$ has parameters $[[4,2,2]]$. Every single-qubit nonidentity Pauli operator anticommutes with a generator, so it has zero compression. But $Z_1{Z}_2$ commutes with both generators and acts nonscalarly on the code: it is unitary there and its code trace is zero. Hence the distance is two and its guaranteed radius is zero. This shows why an unconditional odd-distance formula would be incorrect.

Ignoring overall phases, an error of weight $j$ has $\left(\genfrac{}{}{0ex}{}{n}{j}\right)$ choices of support and three choices, $X,Y,Z$, at each affected qubit. The identity is the weight-zero term, soFor a nondegenerate quantum code, distinct correctable Pauli errors have orthogonal error-image subspaces. Each has dimension $2^k$, since a Pauli operator is unitary. All $N(t)$ subspaces lie in the physical Hilbert space of dimension $2^n$. Counting dimensions proves the quantum Hamming boundDegeneracy would allow distinct errors to share an error-image subspace, so this particular counting argument would then fail.

Every element of the $n$-qubit Pauli group squares to either $1$ or $-1$. If a stabilizer generator $S_j$ had $S_j^2=-1$, closure of the group would put $-1$ in $S$, contrary to the definition. Thus $S_j^2=1$. Since Pauli operators are unitary,and $S_j^{-1}=S_j$ proves $S_j=S_j^{†}$.

If two stabilizers $g,h$ anticommute and a nonzero vector $|\psi ⟩$ belonged to the codespace, thena contradiction. Hence a nonzero stabilizer code requires $S$ to be Abelian. Its centralizer of a stabilizer group is

Quantum error correction protects a logical qubit by encoding its quantum state into a larger Hilbert space, where a specified family of physical errors can be diagnosed and reversed by a common recovery quantum channel. The requirement is to restore every encoded quantum superposition, including its relative phase, rather than only the computational basis states. A quantum error-correcting code specifies which errors have this protection; it does not promise recovery from every possible disturbance.

The beautiful idea is to measure relations between physical qubits that reveal an error syndrome while revealing nothing about the protected logical qubit. For example, the bit-flip repetition code compares neighboring qubits without reading their individual values. Its parity checks can locate one Pauli X gate error while leaving the unknown coefficients intact. Encoding is a linear isometry, consistent with the no-cloning theorem: redundancy in a shared quantum state supplies protection without making independent copies of the unknown input.

Peter W. Shor's 1995 paper ^[ref], published on 1 October, introduced the nine-qubit Shor code to reduce quantum decoherence in memory. Andrew M. Steane's ^[ref], published on 29 July 1996 and ^[ref], connected quantum error correction to classical linear codes; the seven-qubit Steane code protects against arbitrary errors on one physical qubit. These constructions protect relative phase as well as computational basis values, going beyond the elementary bit-flip repetition code.

For an authored account of the mechanism, see John Preskill's ^[ref], especially section 7.1 on collective parity measurements and section 7.9 on stabilizer codes. Andrew Steane's A tutorial on quantum error correction develops the distinction between correcting a stored quantum state and operating with imperfect quantum gates.

A stabilizer code is the common $+1$ eigenspace of a stabilizer group $S$, an abelian subgroup of the Pauli group excluding $-I$. Choose $r$ independent stabilizer generators $g_1,\dots ,g_r$ on $n$ physical qubits. They are commuting Hermitian operators, each squaring to $I$. The stabilizer subspace and its orthogonal projector areThe stabilizer-projector formula gives $\dim \mathcal{C}=2^{n-r}$, so $k=n-r$ logical qubits remain. Independent here means that no nonempty product of the chosen stabilizer generators is $I$. Excluding $-I$ is necessary: a vector cannot simultaneously be fixed by $I$ and $-I$ unless it is zero.

For the three-qubit bit-flip repetition code, take $g_1=Z_1{Z}_2$ and $g_2=Z_2{Z}_3$, with $Z_j$ the Pauli Z gate on site $j$ and identities elsewhere. The stabilizer group is $S=\{I,Z_1{Z}_2,Z_2{Z}_3,Z_1{Z}_3\}$. Both stabilizer generators have eigenvalue $+1$ exactly on the span of $|000⟩$ and $|111⟩$, giving $2^{3-2}=2$ dimensions for one logical qubit. A projective measurement of these checks distinguishes four orthogonal two-dimensional sectors rather than eight individual computational basis states.

A Pauli error that anticommutes with a stabilizer generator changes that check's sign, producing an error syndrome. A Pauli operator commuting with every check can still act on the logical qubits; the centralizer of a stabilizer group describes these possibilities. Thus the number of checks determines the encoded dimension, while the quantum code distance determines protection against arbitrary local errors. The five-qubit error correcting code, for instance, has four stabilizer generators and quantum code distance three; the three-qubit bit-flip repetition code has two checks but quantum code distance one because a single phase flip is unflagged. ^[ref].