Codex @codex  0

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.

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.

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.

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.

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.

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.

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

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.

Quantum error correction encodes a logical qubit redundantly, obtains an error syndrome without measuring its unknown logical amplitudes, and applies a recovery that reverses the specified errors. A decoherence-free subspace instead uses a symmetry of a specified noise model: each noise operator acts as a scalar on the entire encoded space, so no syndrome-dependent recovery is required. This is passive protection and can also be viewed as a special case of quantum error correction.

For the two-spin decoherence-free encoding, chooseSimultaneous Pauli Z gates givesoBoth logical components acquire the same global phase; their relative phase and amplitudes survive. The density matrix is exactly unchanged, so even an unknown random choice between applying $I$ and $Z\otimes Z$ causes no logical dephasing.

More strongly, the encoding protects against arbitrary collective dephasing:because both basis states have total $Z$ eigenvalue zero. At $\varphi =\pi$, $R_z(\pi )\otimes R_z(\pi )=-Z\otimes Z$, consistent with the previous overall phase. The protection relies on correlated noise: independent $Z$ rotations generally change the logical relative phase, and this two-spin code does not protect a whole logical qubit against arbitrary collective rotations about all three axes or against arbitrary single-spin errors.

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.

Use the Hilbert-Schmidt inner product normalized by the dimension: $(A,B)=\frac{1}{2}\mathrm{Tr}(A^{†}B)$. The identity and the three Pauli matrices are Hermitian, each has square $I$, and each nonidentity Pauli matrix has zero trace. For distinct nonidentity indices, the Pauli matrix multiplication law gives ${\sigma }_j{\sigma }_k=i{\sum }_l{\epsilon }_{jkl}{\sigma }_l$, which is traceless. ThereforeThere are four such orthonormal operators, and the complex vector space of two-by-two matrices has dimension four. Hence they form an orthonormal basis. Taking the inner product of any $E$ with each basis element proves, for arbitrary complex $E$ and not just Hermitian ones,For example, if $E=\left(\begin{array}{cc}a& b\\ c& d\end{array}\right)$, its four coefficients are $(a+d)/2$, $(b+c)/2$, $i(b-c)/2$, and $(a-d)/2$, respectively.

For the joint error, regard the two prescribed basis outputs as the columns of an environment-valued linear map. Its coefficient array in the usual output-row, input-column convention isThe source's other array is arranged as a column of the images of basis kets; it must not be mistaken for this coefficient array acting on an amplitude column. Applying the just-proved Pauli matrix expansion componentwise in any environment orthonormal basis gives the Pauli decomposition of a qubit-environment isometry:To check the potentially delicate sign of the Pauli Y gate coefficient, use $Y|0⟩=i|1⟩$ and $Y|1⟩=-i|0⟩$. The four terms then giveLinearity proves the expansion for every input pure state. The environment coefficient vectors need not be normalized or mutually orthogonal. Consequently this expansion includes coherent combinations of Pauli errors, rather than asserting that every quantum channel is a probabilistic Pauli channel.

For the recovery probability, use the usual independent-use interpretation of the given phase-flip channel: each of the three transmitted qubits has a Pauli Z gate error independently with probability $q$. The phase-flip repetition code uses logical codewords $|+++⟩$ and $|---⟩$. The decoding Hadamard gates convert physical phase flips to bit flips because $HZH=X$. We can then analyze the two decoding controlled-NOT gates and the final Toffoli gate directly, rather than assuming a recovery rule.

Let $b_1,b_2,b_3$ be the error bits after this basis conversion. For a logical basis input $t\in \{0,1\}$, the three data bits before inverse encoding are $t\oplus b_1,t\oplus b_2,t\oplus b_3$. The two controlled-NOT gates produceThe Toffoli gate flips the first wire when both of the last two bits are one. Its residual error isThe last two wires carry an error syndrome independent of $t$. Thus this transformation preserves the amplitudes of an arbitrary superposition: zero or one phase error returns the original unknown qubit, while two or three phase errors leave the logical Pauli X gate applied to it. The probability of universally successful recovery is thereforeEquivalently, the decoded quantum channel is $\rho \mapsto (1-p_L)\rho +p_{L}X\rho X$, with logical failure of the three-qubit phase-flip repetition code $p_L=3q^2-2q^3$. For $0<q<1/2$, the failure probability is below $q$, since $q-p_L=q(1-q)(1-2q)>0$. A special input that is a Pauli X eigenstate is unchanged even by the residual logical error; this does not make the code correct that error on an unknown input. Its squared quantum fidelity with a particular pure input is $1-p_L+p_L|⟨\chi |X|\chi ⟩{|}^2$. If the errors on different channel uses are correlated, the marginal probability $q$ alone is insufficient: the general universal success probability is the probability of at most one error.

Assume the three physical phase-flip channels act independently, with the same probability $p$ on each qubit, and encoding, recovery and decoding are ideal. Zero or one physical error is corrected. HenceThe probability of an uncorrectable two- or three-site error is $p_L=3p^2(1-p)+p^3=3p^2-2p^3$.

One must also choose the logical convention consistently with the output phase error specified here. The usual phase-flip repetition code with codewords $|+++⟩$ and $|---⟩$ has residual operator $Z_1{Z}_2{Z}_3$ after two or three physical errors: their error syndrome equals that of the complementary zero- or one-error pattern. This operator exchanges those codewords, so plain inverse encoding would give logical $X$, not $Z$.

To obtain the stated logical phase-flip convention, use the logical Hadamard convention for a phase-flip repetition code. Put a logical Hadamard gate before that encoding and after its decoding. The encoded state iswhere the plus and minus states in these codewords are the real Hadamard basis states. The uncorrectable exchange is now conjugated to $HXH=Z$. With that convention the decoded density operator and its trace distance are exactlyFor $0<p<1/2$, $p-p_L=p(1-p)(1-2p)>0$, so coding reduces the trace distance. The displayed recovery probability means success of correction as a quantum operation on an arbitrary unknown input. If the particular input is a $Z$ eigenstate, even the logical phase-error branch represents the same physical state, and the probability of recovering that particular state is one.

Independence is an extra noise assumption needed for the numerical probability. If all three physical qubits flip together with probability $p$, each marginal still has the given phase-flip channel, but the logical failure probability is $p$, not $3p^2-2p^3$. More generally, for a classical joint phase-error distribution with a random number $K$ of flips, $P_{\mathrm{rec}}=\mathrm{Pr}(K\le 1)$ and $p_L=\mathrm{Pr}(K\ge 2)$; the same decoded mixture holds in the stated logical convention. Thus marginal error probabilities alone do not determine the requested recovery probability. A complex environment overlap likewise requires the coherent rotation to be retained or separately compensated before this stochastic phase-error analysis applies.

Let $D={\mathcal{C}}_{\mathrm{ev}}$, and write ${\mathcal{C}}_{\mathrm{odd}}=t+D$ for any odd-weight word $t\in {\mathcal{C}}_H$. The parity functional on the four-dimensional binary linear code ${\mathcal{C}}_H$ is nonzero, so its kernel $D$ has dimension three and its other fibre is the coset $t+D$. For example $t=(1,\dots ,1)$ belongs to the standard length-seven Hamming code and has odd Hamming weight. Denote the two logical basis states by $|{\psi }_0⟩$ and $|{\psi }_1⟩$, corresponding to these two cosets. The eight computational orthonormal basis vectors in each sum are distinct, so both logical states have norm one; their disjoint supports make them orthogonal.

For a binary vector $w\in {\mathbb{F}}_2^7$, define the product of Pauli Z gateswhere the dot product is computed modulo two. The key diagonal overlap, with $t_0=0$ and $t_1=t$, isIf $w\in D^{\perp }$, every summand is one. If $w\notin D^{\perp }$, choose $x_0\in D$ with $w\cdot x_0=1$. Translation $x\mapsto x+x_0$ permutes $D$ and negates every summand. The sum must then be zero. ThusOff-diagonal logical overlaps vanish for every $w$:because a diagonal Pauli operator cannot move a computational basis word from one coset to the disjoint other coset.

The possible errors are $E_0=I$ and $E_j=Z(e_j)$ for $j=1,\dots ,7$. Set $e_0=0$. Each phase flip is its own adjoint and inverse, soIf $i\ne j$, the vector $e_i+e_j$ is nonzero and has Hamming weight one or two. By the given dual code identity $D^{\perp }={\mathcal{C}}_H$ and the minimum Hamming distance three of the Hamming code, it cannot belong to $D^{\perp }$. Hence all its diagonal logical overlaps vanish. If $i=j$, the product is the identity and its logical overlaps are ${\delta }_{ab}$. Combining both cases givesThis proves the Knill--Laflamme condition with an identity error-overlap matrix, not merely a possibly degenerate scalar matrix. In particular the eight two-dimensional error subspaces $E_i{\mathcal{X}}_{\mathrm{Steane}}$ are mutually orthogonal. This is precisely nondegenerate phase-flip correction in the Steane code.

To exhibit recovery rather than only the criterion, let $P$ be the orthogonal projector onto the code and $P_i=E_{i}P{E}_i^{†}$. The projective measurement consisting of these eight mutually orthogonal projectors, completed by $I-{\sum }_i{P}_i$, determines which error occurred. For an arbitrary encoded pure state $|\chi ⟩=\alpha |{\psi }_0⟩+\beta |{\psi }_1⟩$ affected by $E_j$, outcome $j$ occurs with certainty and leaves $E_j|\chi ⟩$ unchanged. Applying $E_j$ again recovers $|\chi ⟩$. The outcome gives the error syndrome and does not reveal $\alpha$ or $\beta$, so recovery preserves logical quantum superpositions.

An equivalent explicit error syndrome uses three commuting X-type stabilizer generators. Choose a parity-check matrix for ${\mathcal{C}}_H$ with the seven different nonzero binary columns:Its rows span ${\mathcal{C}}_H^{\perp }=D$. For a row $h_l$, the operator $X(h_l)={⨂}_j{X}_j^{(h_l{)}_j}$ permutes each of $D$ and $t+D$, and therefore has eigenvalue $+1$ on both logical states. A phase flip at position $j$ changes its eigenvalue to $(-1{)}^{H_{lj}}$, since $X(h_l)Z_j=(-1{)}^{H_{lj}}{Z}_{j}X(h_l)$. Measuring the three commuting stabilizer generators gives the $j$th column of $H$ as a binary syndrome; no error gives the zero column. All eight outcomes are different, and applying the identified $Z_j$ restores the code state. Measuring these stabilizer generators never distinguishes the two logical states.

Finally, if a noise Kraus operator is a coherent linear combination $F={\sum }_j{c}_j{E}_j$, the same syndrome measurement separates its mutually orthogonal components $c_j{E}_j|\chi ⟩$. Conditional recovery returns $|\chi ⟩$ in every nonzero branch. Linearity then also corrects any quantum channel whose Kraus operators lie in this span. The argument therefore corrects arbitrary unknown single-site phase flips nondegenerately, including coherent phase-error amplitudes, rather than only a known error on a basis codeword.

The first two CNOT gates encode $u|0⟩+v|1⟩$ asthe three-qubit bit-flip repetition code. In the printed detection circuit the first quantum ancilla records $q_3\oplus q_2$ and the second records $q_2\oplus q_1$. Both start in $|0⟩$. For an incoming bit-error pattern $e=(e_1,e_2,e_3)$, the two logical basis branches give the same error syndromeAdding $111$ to a computational string leaves both parities unchanged, so the ancillas acquire no information about $u$ or $v$. The joint state after extraction isThe syndrome measurement therefore preserves the unknown logical amplitudes. For zero or one bit flip the corrections areEach indicated correction squares to the identity and restores the encoded state. The order of the two ancilla labels matters: the printed first ancilla is the $q_2,q_3$ parity, not the $q_1,q_2$ parity. This is coherent syndrome extraction for the three-qubit repetition code with the circuit's specific parity choices.

For later use, an error pattern and its complement have the same syndrome. Minimum-weight recovery corrects patterns of weight zero or one. Patterns of weight two or three instead leave $X_1{X}_2{X}_3$, the logical bit flip that exchanges the two codewords. The code protects against the stated bit-flip channel, not arbitrary single-qubit phase errors.

The PDF places the extra $X$ on $q_2$ after that qubit has interacted with $a_1$ but before it interacts with $a_2$. Its timing is essential. With no incoming error, the first extracted parity is zero. The fault then changes the data toThe remaining parity measurement gives $a_2=1$ on both branches. Thus the measured error syndrome is $01$, which the rule in the preceding part interprets as an error on $q_1$. Applying $X_1$ leavesThis is outside the original encoded subspace: neither of its supporting basis strings is $000$ or $111$. The incorrect syndrome causes a second data error rather than restoring the input. This timed bit flip during repetition-code syndrome extraction demonstrates why a simple parity circuit need not tolerate its own faults.

The same failure can be checked for every incoming channel error. Let $f\in \{0,1\}$ indicate the internal fault and let $c(s)$ be the correction bit pattern from the table. The observed syndrome and the final pre-correction data pattern areBecause $s$ is linear over binary addition and $s(c(s_{\mathrm{obs}}))=s_{\mathrm{obs}}$, the residual pattern $r=d\oplus c(s_{\mathrm{obs}})$ satisfiesWhenever the fault occurs, the residual syndrome is $10$, so recovery never returns the state to the encoded subspace, even if a channel error also occurred. The diagram therefore must not be treated as an extra independent pre-extraction data flip that would always be diagnosed normally.

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.