Quantum error correction (QEC)

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 quantum error-correcting code is a subspace encoding a logical Hilbert space, together with a specified family of noise operators that a common recovery quantum channel reverses on every encoded state. A K-dimensional code carries ${\log }_{2}K$ logical qubits. For a code projector $P$, correctability is characterized by the Knill--Laflamme condition; code distance is defined by the smallest undetectable operator weight, not merely by the number of generators.

A logical qubit is a two-dimensional encoded quantum subsystem with chosen orthonormal logical basis states $|0_L⟩,|1_L⟩$. An encoding linear isometry sends $\alpha |0⟩+\beta |1⟩$ to $\alpha |0_L⟩+\beta |1_L⟩$. In a concatenated quantum error-correcting code, one level's logical qubit supplies one qubit of the next outer code.

A concatenated quantum code replaces each physical qubit of an outer code by a logical qubit of an inner code. Correction proceeds from inner blocks to outer blocks. For independent errors and ideal correction, a logical-error map $f$ iterates as $p_{\ell +1}=f(p_{\ell })$. This recursion describes the code/channel model and does not by itself include errors in encoding and recovery gates.

// Target: quantum-error-correction.bigb

Assume independent physical-error probability $p$, correction of zero or one errors, and failure on every block with at least two errors. The failure map is $f(p)=1-(1-p{)}^5-5p(1-p{)}^4$. Factoring $f(p)-p$ gives $p(1-p)(4p^3-11p^2+9p-1)$. The unique interior threshold is the root of $4p^3-11p^2+9p-1=0$. Below it concatenation decreases the failure probability toward zero. Two levels give $f(f(p))=1000p^4+O(p^5)$, compared with $10p^2+O(p^3)$ at one level.

// Target: quantum-information-theory.bigb

The five-qubit code encodes one logical qubit into five physical qubits and corrects an arbitrary error on one physical qubit. In a nondegenerate realization, the identity and fifteen one-qubit Pauli operators take the two-dimensional code into sixteen mutually orthogonal syndrome subspaces, filling the 32-dimensional physical Hilbert space.

// Target: quantum-error-correction.bigb

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.

A code with orthogonal projector $P$ detects an error $E$ when its compression to the code is scalar. A projective measurement of $P$ then either flags departure from the code or, on a successful code-space outcome, leaves the logical state unchanged up to normalization. This includes harmless scalar errors, even though they need not produce a nonzero error syndrome. Detectability extends by linearity to the span of a set of errors. Every Pauli operator of weight less than the quantum code distance is detectable.

Split the support of a Pauli operator of weight at most $2t$ into two sets of size at most $t$. It is, up to a scalar phase, $E_a^{†}{E}_b$ for two errors in the correctable family. The Knill--Laflamme condition makes its compression to the code scalar, which is quantum error detection. Expansion in the Pauli basis extends the assertion to every operator supported on at most $2t$ qubits. The number $t$ counts affected qubits, not the cardinality of an arbitrary selected family of errors.

For a specified correctable set of distinct Pauli operators modulo phase, a nondegenerate code has mutually orthogonal error images $E\mathcal{X}$. Equivalently, the matrix in the Knill--Laflamme condition is diagonal for that Pauli error set. Each error therefore requires a separate syndrome subspace of dimension equal to the logical code dimension. Degenerate codes can have distinct errors with the same action on the code and do not satisfy this orthogonality counting argument.

For unknown-location Pauli operators of weight at most $t$, there are $N(t)={\sum }_{j=0}^t{3}^j\left(\genfrac{}{}{0ex}{}{n}{j}\right)$ physically distinct errors modulo phase, including the identity. A nondegenerate quantum code assigns them mutually orthogonal error-image subspaces, each of dimension $2^k$, within the $2^n$-dimensional physical Hilbert space. Hence $N(t)2^k\le 2^n$. The hypothesis of nondegeneracy is essential to this dimension count.

A nondegenerate quantum code is perfect at correction radius $t$ if its distinct correctable Pauli error images exhaust the physical Hilbert space. Each image has dimension $2^k$, and their orthogonal direct sum is the whole $2^n$-dimensional space precisely when the quantum Hamming bound is an equality. This perfectness concerns unknown-location errors of weight at most $t$; it does not imply correction of every higher-weight error.

An $[[n,k,d]]$ quantum error correction code is a $2^k$-dimensional subspace of $n$ qubits. Its distance $d$ is the minimum weight of a Pauli operator $E$ for which $PEP$ is not a scalar multiple of the code projector $P$. Thus every operator supported on fewer than $d$ qubits has scalar compression to the code, by expansion in the Pauli basis. This definition includes degenerate codes; a low-weight operator acting as a scalar does not reduce the distance.

The guaranteed radius is the largest integer $t$ for which all unknown-location Pauli operators of weight at most $t$ can be corrected together. Pairwise products have weight at most $2t$, so $2t<d$ suffices by the Knill--Laflamme condition. Conversely, split a minimum-weight undetectable Pauli operator between two subsets of its support. If $d\le 2t$, this gives two errors of weight at most $t$ whose pairwise product violates that condition. Consequently $d$ is either $2t+1$ or $2t+2$; parity cannot be recovered from $t$ alone.

For a code carrying $k>0$ logical qubits, two disjoint subsets $A,B$ of $d-1$ physical qubits are each correctable erasures. Purify the maximally mixed logical input using a reference $R$, and call the remaining physical subsystem $C$. Erasure decoupling gives $S(RA)=S(R)+S(A)$ and $S(RB)=S(R)+S(B)$. Purity and Subadditivity of Von Neumann entropy imply $2S(R)\le 2S(C)$, hence $k\le n-2(d-1)$. If two such disjoint subsets would not fit, partition the entire physical system into two correctable subsets; purity and decoupling then force $S(R)=0$, a contradiction. Thus the partition used in the proof is justified independently of the bound.

Errors on a known subset of $m$ qubits are correctable by a distance-$d$ code whenever $m<d$. Every product $E_a^{†}{E}_b$ of errors supported on that subset still has support in the same subset, so its compression is scalar. The Knill--Laflamme condition therefore supplies one recovery for every channel on that subset. Equivalently, erasing the subset leaks no logical information to it: if a reference is maximally entangled with the encoded logical system, its joint density operator with the erased subsystem is a product state.

Suppose fixed unitary encoding and recovery correct each error $E_j$ by mapping every logical input $|\psi ⟩$ to $|\psi ⟩\otimes |{\eta }_j⟩$. The syndrome vector can be taken independent of the logical input: applying linearity to basis inputs and their equal superposition forces their syndrome vectors to agree. Hence an error $E={\sum }_j{c}_j{E}_j$ is mapped to $|\psi ⟩\otimes {\sum }_j{c}_j|{\eta }_j⟩$. If $E$ is unitary, this final syndrome vector is normalized and the circuit corrects $E$. Orthogonality of the syndrome states is not needed for the linear-span argument; it is a separate condition concerning distinguishability of errors.

A code projector $P$ corrects errors $\{E_a\}$ exactly when $P{E}_a^{†}{E}_{b}P=C_{ab}P$ for every pair.

If a common recovery quantum channel with Kraus operators $R_{\mu }$ restores every pure code state after each error $E_a$, then each vector $R_{\mu }{E}_a|\psi ⟩$ is parallel to $|\psi ⟩$. Linearity on basis vectors and their pairwise superpositions forces $R_{\mu }{E}_{a}P=c_{\mu a}P$, with the scalar independent of the logical state. Insert ${\sum }_{\mu }{R}_{\mu }^{†}{R}_{\mu }=I$ between two error operators to obtain the displayed Knill--Laflamme condition. This proves necessity without presuming an orthogonal syndrome description of recovery.

The matrix $C$ in the Knill--Laflamme condition is positive semidefinite, since $v^{†}Cv$ is the squared norm of ${\sum }_a{v}_a{E}_a|\psi ⟩$ for any normalized code state. Diagonalizing it gives linear combinations $F_j$ with $P{F}_j^{†}{F}_{l}P=c_j{\delta }_{jl}P$. For $c_j>0$, $V_j=F_{j}P/\sqrt{c_j}$ is an isometry of the code into an error-image subspace, and these subspaces are orthogonal. Measuring their projectors and applying $V_j^{†}$ recovers the logical state. Complete the operation arbitrarily on the orthogonal complement to obtain a quantum channel. This construction corrects every noise map whose Kraus operators lie in the specified error span, including coherent superpositions of error operators.

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].

A stabilizer group with $r$ independent generators maps injectively to an r-dimensional isotropic subspace of the binary symplectic space of Pauli labels. For generator rows $(A\mid B)$, commutation is $A{B}^T+B{A}^T=0$ over ${\mathbb{F}}_2$. Its stabilizer subspace has dimension $2^{n-r}$. The labels of the centralizer of a stabilizer group form $L^{\perp }$; labels in $L^{\perp }\setminus L$ act as nontrivial logical Pauli operators.

For binary linear codes $C_2\subseteq C_1\subseteq {\mathbb{F}}_2^N$, the CSS code has basis $|x+C_2⟩=|C_2{|}^{-1/2}{\sum }_{y\in C_2}|x+y⟩$ for $x\in C_1/C_2$. Its X stabilizers come from $C_2$ and its Z stabilizers from the dual code $C_1^{\perp }$; their commutation follows from orthogonality. For positive logical dimension, $d_X=\min \{\mathrm{wt}(x):x\in C_1\setminus C_2\}$ and $d_Z=\min \{\mathrm{wt}(z):z\in C_2^{\perp }\setminus C_1^{\perp }\}$, with quantum code distance $d=\min (d_X,d_Z)$. Thus arbitrary errors on at most $\lfloor (d-1)/2\rfloor$ qubits are correctable. Stabilizer errors are harmless even if their weight is small; the distances exclude them.

For binary linear codes $C\subseteq C^{\prime }$, the coset superpositions of the CSS code have $X$ checks labelled by $C$ and $Z$ checks by $(C^{\prime }{)}^{\perp }$. A bit-error pattern $a$ gives the classical syndrome for $C^{\prime }$, and a phase-error pattern $b$ gives the syndrome for the dual code $C^{\perp }$. Errors with $2t_X<{\min }_{a\in C^{\prime }\setminus C}\mathrm{wt}(a)$ and $2t_Z<{\min }_{b\in C^{\perp }\setminus (C^{\prime }{)}^{\perp }}\mathrm{wt}(b)$ are jointly correctable. Every pairwise Pauli-error product either anticommutes with a check, giving zero code compression, or its low-weight components belong to the stabilizer and give scalar compression. Thus the Knill--Laflamme condition covers coherent superpositions and quantum channels as well as definite bit and phase errors.

The Pauli centralizer $C(S)$ consists of Pauli operators commuting with every stabilizer. Elements of $C(S)\setminus S$, modulo stabilizers and phases, are the nontrivial logical Pauli operators.

If every pairwise product $E_a^{†}{E}_b$ has weight below the code distance, it cannot be a nontrivial logical operator. The Knill--Laflamme conditions then hold for the whole error set.

Let $S$ exclude $-I$, let $C(S)$ be its Pauli centralizer, and let $\mathcal{Z}=\{\pm I,\pm iI\}$. A set of Pauli errors is jointly correctable exactly when every product $E_a^{†}{E}_b$ belongs to $\mathcal{Z}S$ or lies outside $C(S)$. Outside the centralizer its code compression is zero by anticommutation; in $\mathcal{Z}S$ it acts as a scalar. A centralizing operator outside $\mathcal{Z}S$ has zero trace on the code but is unitary there, so cannot be scalar. This gives precisely the Knill--Laflamme condition. Scalar phases must be retained when formulating the group criterion.

Quasi-adiabatic continuation carries each stabilizer to a quasi-local conserved operator for the perturbed low-energy space. Bare Pauli errors are then only approximately correctable because the dressed operators have exponentially small non-Pauli tails.

The distance is the minimum weight of a Pauli operator that preserves the code space but acts nontrivially on its logical information.

An error syndrome is the list of outcomes obtained by measuring a chosen ordered family of stabilizer generators. Write $s_j=0$ for eigenvalue $+1$ and $s_j=1$ for eigenvalue $-1$. For a definite Pauli error $E$ on a code state, the rule isThe commuting checks admit joint orthogonal projectorsFor density operator $\rho$, the Born rule gives outcome probability $\mathrm{tr}({\Pi }_s\rho )$ and conditional state ${\Pi }_s\rho {\Pi }_s/\mathrm{tr}({\Pi }_s\rho )$ when that probability is nonzero. A definite Pauli error has one deterministic error syndrome independent of the encoded amplitudes. A coherent linear combination of Pauli errors may occupy several sectors, so measuring the error syndrome selects a sector; recovery preserves the logical qubit when the entire error family is jointly correctable. ^[ref].

An error syndrome locates an error only relative to an assumed family and a recovery rule. Two Pauli errors differing by a logical operator can share an error syndrome; see stabilizer-syndrome coset. In the three-qubit bit-flip syndrome table, $X_3$ and $X_1{X}_2$ both give $01$. Recovering with $X_3$ corrects the first but converts the second into the logical operator $X_1{X}_2{X}_3$. Likewise, $Z_1$ has error syndrome $00$ yet changes the encoded relative phase.

Two Pauli errors have the same stabilizer syndrome exactly when their product lies in the centralizer of the stabilizer group. Thus a syndrome identifies a coset $E_{s}C(S)$, while logical operators inside that coset remain indistinguishable.

The $n$-qubit phase-flip repetition code is stabilized by $X_j{X}_{j+1}$ and has codewords $|+{⟩}^{\otimes n}$ and $|-{⟩}^{\otimes n}$. It has logical operators $\overline{Z}=X_1$ and $\overline{X}=Z_1\cdots Z_n$, so its distance against phase flips is $n$.

The codewords $|+++⟩,|---⟩$ have residual logical Pauli X gate after an uncorrectable two- or three-site phase error. Precede their encoding by a logical Hadamard gate and follow decoding by its inverse. Since $HXH=Z$, the same error now acts as a logical Pauli Z gate. Explicitly the encoded coefficients are $(\alpha +\beta )/\sqrt{2}$ and $(\alpha -\beta )/\sqrt{2}$ for an input $\alpha |0⟩+\beta |1⟩$. This convention matters when translating physical phase errors into a claimed decoded phase-error channel.

The phase-flip repetition code with codewords $|+++⟩,|---⟩$ corrects any one physical Pauli Z gate error. Its two adjacent-pair error syndromes cannot distinguish an error pattern from its three-bit complement. Minimum-weight recovery therefore leaves no residual error at weight zero or one, and leaves $Z_1{Z}_2{Z}_3$ at weight two or three. This residual operator exchanges the codewords, so inverse encoding gives a logical Pauli X gate. For independent physical phase errors of probability $ϵ$, the decoded quantum channel is $(1-p_L)\rho +p_{L}X\rho X$, where $p_L=3{ϵ}^2(1-ϵ)+{ϵ}^3$. For $0<ϵ<1/2$, $ϵ-p_L=ϵ(1-ϵ)(1-2ϵ)>0$.

Insert Hadamard gates on every data qubit immediately after encoding by a bit-flip repetition code and immediately before its bit-flip detection and recovery. The intervening physical error is thereby conjugated by $H^{\otimes n}$, and $HZH=X$ turns a single Pauli Z gate error into a single bit flip for the original correction circuit. The encoded logical codewords are now $|+{⟩}^{\otimes n}$ and $|-{⟩}^{\otimes n}$. The syndrome ancillas and the final inverse encoding stay unchanged. This protects against phase flips in the new basis; it does not simultaneously correct arbitrary bit flips in the physical basis.

For independent errors of probability $p<1/2$, maximum-likelihood decoding of a repetition code chooses the lower-weight error compatible with the syndrome. This is majority voting, with threshold $p_c=1/2$ and exponentially vanishing logical-error probability below threshold.

The $m$-qubit bit-flip repetition code stores one logical qubit in $|0_L⟩=|0{⟩}^{\otimes m}$ and $|1_L⟩=|1{⟩}^{\otimes m}$. Its stabilizer generators are $Z_j{Z}_{j+1}$ for $j=1,\dots ,m-1$, and its logical operators are $\overline{X}=X_1\cdots X_m$ and $\overline{Z}=Z_1$. Interchanging the Pauli X gate and Pauli Z gate gives the phase-flip repetition code. For odd $m$, majority-vote decoding of a repetition code corrects up to $(m-1)/2$ physical Pauli X gate errors, assuming ideal operations and a noise family containing only these bit flips.

For $m=3$, prepare two quantum ancillas in $|00⟩$ and apply controlled-NOT gates from the input qubit to each of them. By linearity, encoding sendsThis does not produce $(\alpha |0⟩+\beta |1⟩{)}^{\otimes 3}$, which would contain cross terms. For example, encoding $|+⟩=(|0⟩+|1⟩)/\sqrt{2}$ produces $(|000⟩+|111⟩)/\sqrt{2}$, whereas three independent copies would have eight equal computational basis amplitudes. The encoding creates quantum entanglement when both coefficients are nonzero and respects the no-cloning theorem.

The three-qubit bit-flip syndrome table corrects the family $\{I,X_1,X_2,X_3\}$ and its entire linear span, as specified by the Knill--Laflamme condition. It cannot correct arbitrary errors on one physical qubit: the phase flipcommutes with both checks and acts as logical $\overline{Z}$. In particular, it takes the encoded $|+⟩$ to the orthogonal encoded $|-⟩$ with error syndrome $00$. Thus its full quantum code distance is one, despite correcting one error of the restricted Pauli X gate type. The Shor code, Steane code and five-qubit error correcting code provide protection against arbitrary one-qubit errors.

Measure the commuting stabilizer generators $g_1=Z_1{Z}_2$ and $g_2=Z_2{Z}_3$ in that order. Use error syndrome bit $0$ for eigenvalue $+1$ and bit $1$ for eigenvalue $-1$. For $X_j$ the Pauli X gate on physical qubit $j$, every row holds for arbitrary normalized $\alpha ,\beta$. This ordered parity-check convention follows ^[ref]:

Each pair of computational basis words within a row has the same two parities. Consequently the projective measurement reveals the row without distinguishing its two amplitudes. For example, $|{\psi }_L⟩=(\sqrt{3}/2)|000⟩+(i/2)|111⟩$ becomes $(\sqrt{3}/2)|010⟩+(i/2)|101⟩$ under $X_2$. Both checks give $-1$ with probability one, and applying $X_2$ restores both coefficients exactly, including the relative phase $i$.

One implementation uses two quantum ancillas initialized to $|00⟩$. Two controlled-NOT gates from data qubits 1 and 2 to the first quantum ancilla write their parity; two more from data qubits 2 and 3 to the second quantum ancilla write the other parity. Measuring only the quantum ancillas in the computational basis gives $(s_1,s_2)$. Measuring the individual data qubits instead would reveal the encoded computational basis value and destroy the unknown quantum superposition. The existing coherent syndrome extraction for the three-qubit repetition code uses the alternative ordered checks $(Z_2{Z}_3,Z_1{Z}_3)$, so its bit labels differ from this table.

The recovery also handles coherent errors. Put $E_0=I,E_1=X_1,E_2=X_2,E_3=X_3$. Their images of the code are mutually orthogonal, giving $P{E}_a^{†}{E}_{b}P={\delta }_{ab}P$, the Knill--Laflamme condition for this family. For any linear combination $E={\sum }_{a=0}^3{c}_a{E}_a$, its component in sector $s(E_a)$ is $c_a{E}_a|{\psi }_L⟩$. Measuring that error syndrome has probability $|c_a{|}^2/{\sum }_b|c_b{|}^2$ on the normalized erroneous state, and recovery $E_a$ returns $|{\psi }_L⟩$. More generally one recovery quantum channel corrects every noise quantum channel whose Kraus operators belong to this span. The assumption concerns the whole jointly correctable family; it does not extend to the span of arbitrary single-site Pauli errors. ^[ref].

A fully computed coherent example is the unitary operator $U=\exp (-i\theta X_2)=\cos \theta I-i\sin \theta X_2$. At $\theta =\pi /6$ it givesThe error syndromes $00$ and $11$ occur with probabilities $3/4$ and $1/4$, independently of $\alpha ,\beta$. Doing nothing for $00$ and applying $X_2$ for $11$ restores the same logical qubit in both branches; the scalar $-i$ in the second branch is an irrelevant global phase. This is an example of linearity of coherent quantum error correction, rather than an assumption that the original error was a classical random bit flip.

Assume that each physical qubit undergoes an independent quantum bit-flip channel with probability $p$ during one storage interval, and that encoding, error syndrome extraction, recovery and decoding are all ideal. Use the three-qubit bit-flip syndrome table to apply the indicated minimum-weight recovery. Zero or one bit flips are corrected. Two bit flips have the same error syndrome as the complementary one-site error: for example, $X_1{X}_2$ gives $01$, so recovery $X_3$ leaves $\overline{X}=X_1{X}_2{X}_3$. Three bit flips give $00$ and also leave $\overline{X}$. This exchanges $|000⟩$ and $|111⟩$, and therefore acts as a logical Pauli X gate after decoding.

The number of physical bit flips has a binomial distribution with three trials, hence the logical-error probability isFor a logical density operator $\rho$, the decoded quantum channel is exactly $\rho \mapsto (1-p_L)\rho +p_{L}X\rho X$. Here logical failure means a nontrivial logical Pauli X gate error; a particular input such as $|+⟩$ can be invariant under that error. At $p=0.1$, exactly two flips have probability $3(0.1{)}^2(0.9)=0.027$ and three flips have probability $(0.1{)}^3=0.001$, giving $p_L=0.028$. The block succeeds with probability $0.972$ compared with $0.9$ for an unencoded qubit. At $p=0.01$, $p_L=0.000298$, illustrating the quadratic suppression of rare independent bit flips.

Factoring the improvement givesThus one level reduces logical-error probability for $0<p<1/2$, is equal at $p=0,1/2,1$, and makes it worse for $1/2<p<1$ under this same decoder. The suppression arises because a logical error requires at least two physical bit flips. With independent disjoint inner blocks, the same noise model and ideal correction at every level, a concatenated quantum error-correcting code has $p_{\ell +1}=3p_{\ell }^2-2p_{\ell }^3$, with $p_0=p$. At $p_0=0.1$, two levels use nine data qubits and give $p_2=3(0.028{)}^2-2(0.028{)}^3=0.002308096$.

This calculation describes ideal correction of stored information with the specified quantum bit-flip channel. Repeated correction in time additionally requires a fresh specified noise model for each interval; imperfect quantum gates, faulty measurements and correlated errors change the calculation. The timed bit flip during repetition-code syndrome extraction and exact encoded-state failure with a faulty parity check show concretely why this storage calculation alone is not a fault-tolerance result.

Encode $u|0⟩+v|1⟩$ as $u|000⟩+v|111⟩$. Four controlled-NOT gates copy the displayed two data parities into initially zero quantum ancillas. No logical amplitude is measured. The error syndromes $00,01,10,11$ correspond respectively to no bit flip and bit flips on data qubits $1,2,3$. Conditional Toffoli gates, with temporary Pauli X gates implementing zero-valued controls, undo the indicated error. Inverse encoding yields the original logical state and a separate syndrome state. A phase flip has zero bit-flip syndrome and remains as a logical phase error; this three-qubit code is not a general single-qubit-error code.

Suppose the first ancilla records parity $q_2\oplus q_3$, then a fault of value $f$ flips $q_2$, and the second ancilla records parity $q_1\oplus q_2$. For incoming bit-error pattern $e$, the observed error syndrome is the displayed pair, while the final data error before recovery is $d=e\oplus (0,f,0)$. When $f=1$, the observed syndrome differs from the actual data syndrome by $(1,0)$. Applying the usual minimum-weight recovery leaves a nonzero syndrome, so the state is outside the code space even when the channel itself made no error. This is a timing-dependent failure of this simple extraction circuit, not a general obstruction to fault-tolerant quantum error correction.

For independent channel bit flips of probability $p$ and the specified extraction fault of probability $q$, require recovery of an arbitrary input in the original encoded subspace. Every extraction-fault event leaves nonzero error syndrome; without that fault, channel errors are corrected exactly at weight zero or one. Thus success probability is $(1-q)[(1-p{)}^3+3p(1-p{)}^2]$. Compared with a single unencoded bit-flip channel, strict improvement for $0<p<1/2$ requires $q<p(1-2p)/[(1-p)(1+2p)]$. A different decoder or an added later ideal recovery changes the performance criterion and must be specified separately.

Replacing every qubit of an $n$-qubit phase-flip repetition code by an $m$-qubit bit-flip repetition code gives a code with logical $Z$- and $X$-operator weights $m$ and $n$, respectively, and hence distance $\min (m,n)$.

The nine-qubit Shor code encodes one logical qubit with basis vectors $|0_L⟩=|G_{+}{⟩}^{\otimes 3}$ and $|1_L⟩=|G_{-}{⟩}^{\otimes 3}$, where $|G_{\pm }⟩=(|000⟩\pm |111⟩)/\sqrt{2}$. Six adjacent $Z$-pair stabilizer generators locate a single bit flip within a block, while $X_1\cdots X_6$ and $X_4\cdots X_9$ diagnose which block has had its relative phase changed. Together they correct every single-qubit Pauli operator, hence every single-qubit error by the Pauli expansion of a quantum error.

A Pauli Z gate on qubit four has phase-check eigenvalues $(-1,-1)$ and leaves all six $Z$-pair checks positive. Applying $Z_4$ restores the state. The same phase syndrome arises from $Z_5$ or $Z_6$; these have the same action on the code since their pairwise products are stabilizers. This is a degeneracy, not a failure of correction.

Group the nine physical qubits into three blocks and write $B_r$ for the product of three Pauli X gates in block $r$. The commuting stabilizer generators $B_1{B}_2$ and $B_2{B}_3$ have eigenvalue $+1$ on both logical codewords. A Pauli Z gate in blocks one, two or three gives syndromes $(-,+)$, $(-,-)$ or $(+,-)$ respectively. Apply a Z gate to any one qubit of the indicated block to recover the logical state. Z errors at distinct locations within a block act identically on the code, so this correction is degenerate.

The Steane code is a seven-qubit CSS stabilizer code encoding one logical qubit with distance three.

Write the Steane code basis as uniform quantum superpositions over a binary linear code $D$ and a disjoint coset $t+D$, where $D$ is the even-weight part of the length-seven Hamming code. For $Z(w)={⨂}_{j=1}^7{Z}_j^{w_j}$, diagonal Pauli Z gates cannot connect the two cosets. Within coset $t_a+D$, the overlap isIf $w\notin D^{\perp }$, translation by a word $x_0\in D$ with $w\cdot x_0=1$ negates this sum, so it vanishes. Since the dual code $D^{\perp }$ is the length-seven Hamming code of minimum Hamming distance three, every nonzero $w$ of Hamming weight one or two has vanishing overlap. Taking $u,v$ from $\{0,e_1,\dots ,e_7\}$ proves the displayed identity. The eight two-dimensional error images are orthogonal, so their projective measurement determines the error syndrome without revealing the logical state; applying the identified phase flip again recovers every code state. This proves nondegenerate quantum error-correcting code behaviour for the identity and all single-site phase flips, including their coherent linear span.

A color code places qubits on a three-colorable lattice and assigns X-type and Z-type stabilizers to each colored plaquette.

A string operator creates excitations at its endpoints. Multiplying by a successive segment moves an endpoint because the shared intermediate excitation is toggled twice.

The surface code is a topological stabilizer code whose electric and magnetic excitations are bosons with mutual-semion braiding.

Join $n$ spheres pole to pole and draw $m$ longitude edges on each sphere. Qubits on edges, two-edge face $Z$ stabilizers, and vertex $X$ stabilizers realize the concatenated phase-and-bit-flip repetition code. A pole-to-pole path has weight $n$, while a dual equatorial cut has weight $m$.

For independent bit flips, summing the probabilities of all error chains in one syndrome and logical class equals, up to a class-independent factor, the partition function of a random-bond Ising model. A reference error fixes bond signs and products of star stabilizers become Ising spin configurations.

On a cylinder with equal anyon-condensing boundaries, the two topological ground states split only through a virtual string implementing a logical operator. A perturbation of strength $h$ produces a splitting of order $J$ times a path-counting factor times $(|h|/J{)}^d$, where $d$ is the shortest supported logical-string length.

The toric code has commuting star and plaquette stabilizers. Its electric and magnetic excitations are bosons with mutual-semion statistics, and their fusion is a fermion.

The surface-code anyons are $1,e,m,f=e\times m$. They obey $e^2=m^2=f^2=1$; $e$ and $m$ are bosons with mutual full-braiding phase $-1$, while their composite $f$ is a fermion.