Steane Code

The Steane code encodes one logical qubit into seven physical qubits and exactly corrects an arbitrary error on any one of them. Its defining idea is unusually economical: the same three parity-check supports from the classical binary Hamming code diagnose both bit-flip and phase-flip components. In modern notation the result is a weakly self-dual CSS stabilizer code with parameters $[[7,1,3]]$.

That compact description hides several distinctions that matter in practice. The classical $[7,4,3]$ Hamming code is not equal to its $[7,3,4]$ dual; the dual is contained in it. The quantum code is nondegenerate for its one-qubit correctable Pauli basis, yet it is not a perfect quantum code. Bitwise Hadamard, a convention-sensitive bitwise phase gate, and bitwise CNOT between blocks implement logical Clifford operations, but those operations neither form a universal gate set nor supply a complete fault-tolerant protocol.

This page fixes one binary, tensor, syndrome, and recovery convention and then carries every claim through that convention. The codewords, six checks, logical representatives, twenty-two occupied one-error syndromes, Knill–Laflamme matrix, full-Pauli distance, transversal Clifford action, and a finite depolarizing calculation can therefore be checked against one another rather than accepted as disconnected facts. The construction follows Steane’s original Hamming-based presentation in his 1996 Physical Review Letters article and its fuller Royal Society development, while the stabilizer and fault-tolerant language follows Gottesman’s later systematic treatment.

Required background. Stabilizer Formalism supplies stabilizer groups, binary Pauli vectors, projectors, normalizers, logical cosets, syndrome algebra, and full-Pauli distance.

The Seven-Qubit Hamming Construction

One declared binary and qubit convention

Number the physical qubits from one through seven and read every binary or Pauli string from qubit one on the left to qubit seven on the right. All binary arithmetic is over $\mathbb F_2$. Freeze the three-by-seven matrix

$$H= \begin{pmatrix} 0&0&0&1&1&1&1\\ 0&1&1&0&0&1&1\\ 1&0&1&0&1&0&1 \end{pmatrix}.$$

Its ordered rows are

$$r_1=0001111, \qquad r_2=0110011, \qquad r_3=1010101.$$

The ordered columns are the seven nonzero three-bit words,

$$h_1=001,\quad h_2=010,\quad h_3=011,\quad h_4=100,\quad h_5=101,\quad h_6=110,\quad h_7=111.$$

This ordering is more than typography. It makes a Hamming syndrome directly identify a qubit: if $h_j$ is observed, the indexed location is $j$. Row operations or a permutation of columns would describe an equivalent code, but they would change the printed stabilizers and the lookup table. Every syndrome below therefore uses this matrix without an implicit reordering.

For a binary word $v=(v_1,\ldots,v_7)$, write

$$X(v)=\bigotimes_{j=1}^{7}X_j^{v_j}, \qquad Z(v)=\bigotimes_{j=1}^{7}Z_j^{v_j}.$$

The tensor identity on an omitted position is understood. Pauli phases are retained when an operator acts on a state, although binary vectors suffice for support and commutation calculations. A measured syndrome bit is zero for commutation and one for anticommutation, so it is also zero for a $+1$ check outcome and one for a $-1$ outcome.

The classical Hamming code and its dual

Define the classical code and its dual check code by

$$C=\ker H, \qquad C^\perp=\operatorname{row}(H).$$

The rows of $H$ are independent, so $\dim C=7-3=4$ and $\dim C^\perp=3$. Each row has weight four, and any two distinct rows overlap on exactly two positions. Consequently

$$HH^T=0, \qquad C^\perp\subset C.$$

The inclusion, rather than equality, is the classical statement needed for the quantum construction. Calling the $[7,4,3]$ Hamming code literally self-dual would be false because a binary self-dual length-seven code could not have integer dimension $7/2$. The useful symmetry is that its dual is self-orthogonal and can be used for both kinds of quantum check.

The seven columns of $H$ are nonzero and distinct. A weight-one word cannot lie in $C$ because its syndrome is one nonzero column. A weight-two word cannot lie in $C$ because the sum of two distinct columns is nonzero. On the other hand,

$$h_1+h_2+h_3=001+010+011=000,$$

so $1110000\in C$. Thus $C$ is the $[7,4,3]$ Hamming code. Its dual is the $[7,3,4]$ simplex code generated by the rows above. Their support-weight enumerators are

$$W_C(z)=1+7z^3+7z^4+z^7, \qquad W_{C^\perp}(z)=1+7z^4.$$

The second identity can also be seen geometrically: every nonzero linear combination of the three rows selects four of the seven nonzero points of $\mathbb F_2^3$. Steane’s detailed 1996 Royal Society paper uses precisely this simplex generator and then takes its complement coset to carry the second logical value. Calderbank and Shor’s independent code construction places the same inclusion in the general classical-to-quantum framework.

Normalized logical cosets

Let $\mathbf 1=1111111$. The two cosets used for the logical basis are $C^\perp$ and $\mathbf1+C^\perp$. With all amplitudes real and positive,

$$\begin{aligned} |\overline0\rangle=\frac{1}{\sqrt8}\big(& |0000000\rangle+|0001111\rangle+|0110011\rangle+|0111100\rangle\\ &+|1010101\rangle+|1011010\rangle+|1100110\rangle +|1101001\rangle\big), \end{aligned}$$

and

$$\begin{aligned} |\overline1\rangle=\frac{1}{\sqrt8}\big(& |1111111\rangle+|1110000\rangle+|1001100\rangle+|1000011\rangle\\ &+|0101010\rangle+|0100101\rangle+|0011001\rangle +|0010110\rangle\big). \end{aligned}$$

The eight strings in the first state are exactly the words of $C^\perp$. The eight in the second are their bitwise complements. The cosets are disjoint, so the two states are orthogonal; each contains eight orthogonal computational-basis vectors with amplitude $1/\sqrt8$, so both are normalized. Their span carries a general logical state

$$|\overline\psi\rangle =\alpha|\overline0\rangle+\beta|\overline1\rangle, \qquad |\alpha|^2+|\beta|^2=1.$$

Every word of $C^\perp$ has even weight, either zero or four. Every word of $\mathbf1+C^\perp$ has odd weight, either seven or three. This parity separation will make $Z^{\otimes7}$ a logical $Z$ and will also fix the direction of the transversal phase gate. The amplitudes $\alpha$ and $\beta$ remain unknown quantum data; none of the parity checks below is permitted to distinguish them.

The complete frozen record is:

Field	Frozen value
Physical qubits	Seven, ordered $1,\ldots,7$
Logical qubits	One
Full Pauli distance	$d=3$
Classical code	$C=\ker H$, the binary $[7,4,3]$ Hamming code
Dual check code	$C^\perp=\operatorname{row}(H)$, the binary $[7,3,4]$ simplex code
Parity-check matrix	Rows $0001111$, $0110011$, $1010101$, in that order
Six stabilizer generators	$g^Z_a=Z(r_a)$ followed by $g^X_a=X(r_a)$ for $a=1,2,3$
Code projector	$P=2^{-6}\prod_{a=1}^{3}(I+g^Z_a)(I+g^X_a)$
Logical basis	Uniform normalized states on $C^\perp$ and $\mathbf1+C^\perp$
Convenient logical X	$\overline X=X^{\otimes7}$
Convenient logical Z	$\overline Z=Z^{\otimes7}$
Structural status	$[[7,1,3]]$, Hamming-derived, weakly self-dual CSS, pure and nondegenerate, but not quantum perfect

Six CSS Stabilizers and Logical Paulis

Identical X- and Z-check supports

For a binary word $r=(r_1,\ldots,r_7)$, write

$$X(r)=\bigotimes_{j=1}^7X_j^{r_j}, \qquad Z(r)=\bigotimes_{j=1}^7Z_j^{r_j}.$$

Applying this notation to the three rows of $H$, and freezing the Z-type checks before the X-type checks, gives

$$\begin{aligned} g_1&=IIIZZZZ,& g_2&=IZZIIZZ,& g_3&=ZIZIZIZ,\\ g_4&=IIIXXXX,& g_5&=IXXIIXX,& g_6&=XIXIXIX. \end{aligned}$$

These are positive-signed generators. Checks within one Pauli sector commute automatically. A Z check $Z(r_a)$ and an X check $X(r_b)$ acquire the commutation sign $(-1)^{r_a\cdot r_b}$. Since $HH^{\mathsf T}=0$, every such overlap is even, including a row with itself, and all six generators commute. The three rows are independent. Moreover, no nonidentity product of only Z-type generators can equal a product of only X-type generators. The six binary symplectic generator rows therefore have rank six.

The same support matrix appears twice, so it is accurate to write $H_X=H_Z=H$. This property is often called weak self-duality. It must not be confused with equality of the underlying classical codes: $\dim C=4$, whereas $\dim C^\perp=3$, so $C\ne C^\perp$. The actual condition that makes the two check sectors compatible is $C^\perp\subset C$.

Support schematic for the Steane $[[7,1,3]]$ code in the frozen Hamming convention. The three upper $Z$-check rows and three lower $X$-check rows use the same parity-check matrix, $H_X=H_Z=H$. Lines indicate stabilizer support only; they are not ancilla circuits, extraction schedules, or fault-tolerance certificates.

The figure records algebraic support, not a method for measuring it. Simultaneous commutation does not by itself specify ancilla preparation, coupling order, verification, repeated rounds, or which faults can propagate. Those physical obligations have to be added when the abstract code is used in a fault-tolerant protocol.

Projector and code dimension

Let $\mathcal S=\langle g_1,\ldots,g_6\rangle$. Independence gives $|\mathcal S|=2^6=64$, and the absence of $-I$ follows because the displayed logical basis is a common $+1$ eigenspace. The projector onto that eigenspace can be written in either generator or group-average form:

$$P=\frac1{64}\prod_{a=1}^{6}(I+g_a) =\frac1{64}\sum_{s\in\mathcal S}s.$$

Each factor $(I+g_a)/2$ is a commuting Hermitian projector, so $P^2=P=P^\dagger$. Every nonidentity Pauli has zero trace. Only the identity term in the group average contributes, and consequently

$$\operatorname{tr}P=\frac{2^7}{64}=2.$$

Thus the common eigenspace has dimension two and encodes one qubit. The logical coset states are fixed by every generator. An X check translates the summation variable by a row of $H$, merely permuting $C^\perp$ within either coset. A Z check supplies phase $(-1)^{r\cdot u}$; this is $+1$ for $u\in C^\perp$ because the rows are mutually orthogonal. It is also $+1$ on the complement coset because every row has even weight. Hence $P|\overline b\rangle=|\overline b\rangle$ for $b=0,1$, and the two orthonormal states exhaust the range of $P$.

It is useful to audit the whole stabilizer rather than only its six generators. Its support-weight enumerator is

$$A_{\mathcal S}(z)=\sum_{s\in\mathcal S}z^{\operatorname{wt}(s)} =1+21z^4+42z^6.$$

The seven nonidentity pure-X elements and seven nonidentity pure-Z elements all have weight four. Of the forty-nine products $X(u)Z(v)$ with nonzero $u,v\in C^\perp$, seven have equal supports and become weight-four Y operators; the remaining forty-two have Pauli weight six. In particular, no nonidentity stabilizer has weight below four. This is the purity fact that will independently confirm nondegenerate correction of all one-qubit Paulis.

Logical Pauli representatives and equivalences

Choose

$$\overline X=X^{\otimes7}, \qquad \overline Z=Z^{\otimes7}, \qquad \overline Y=i\overline X\overline Z.$$

Both $\overline X$ and $\overline Z$ commute with every stabilizer: each check has even weight. Neither belongs to $\mathcal S$. Bitwise X takes every word to its complement, while the parity observation made above gives

$$\begin{aligned} \overline X|\overline0\rangle&=|\overline1\rangle,& \overline X|\overline1\rangle&=|\overline0\rangle,\\ \overline Z|\overline0\rangle&=|\overline0\rangle,& \overline Z|\overline1\rangle&=-|\overline1\rangle. \end{aligned}$$

They anticommute because their seven supports overlap an odd number of times, so these actions are the usual logical Pauli actions. The definition of $\overline Y$ then fixes the phase convention, for example $\overline Y|\overline0\rangle=i|\overline1\rangle$.

A logical operator is a stabilizer coset, not a unique physical string. Multiplying by a stabilizer changes no action on the code space. In the present convention,

$$\overline Xg_4=X_1X_2X_3, \qquad \overline Zg_1=Z_1Z_2Z_3.$$

Therefore $\overline X\sim X_1X_2X_3$ and $\overline Z\sim Z_1Z_2Z_3$, where $\sim$ means equality up to a stabilizer on encoded states. These weight-three representatives will be both upper bounds on distance and explicit residual logical faults in the alias examples below.

Twenty-Two Occupied One-Error Syndromes and Ideal Recovery

Ordered six-bit syndrome convention

For a Pauli $E$, define $s_a(E)=0$ if $E$ commutes with $g_a$ and $s_a(E)=1$ if it anticommutes. Store the bits in the generator order already declared:

$$s(E)=(s_1s_2s_3\mid s_4s_5s_6),$$

with the three Z-check bits before the three X-check bits. If $h_j$ is column $j$ of $H$, a bit flip at site $j$ anticommutes with precisely the Z checks containing that site, and a phase flip anticommutes with the corresponding X checks. Consequently,

$$s(X_j)=(h_j\mid000),\qquad s(Z_j)=(000\mid h_j),\qquad s(Y_j)=(h_j\mid h_j).$$

Syndromes add modulo two under Pauli multiplication. This convention removes two common ambiguities at once: it specifies which three-bit half is written first, and it assigns each nonzero binary column to one physical site. A different row order or qubit permutation describes an equivalent code, but its ledger is not the ledger below.

Complete one-error syndrome ledger

The identity and all twenty-one nonidentity one-qubit Paulis occupy distinct syndrome sectors:

Error	Hamming column	Six-bit syndrome	Chosen phase-free correction
$I$	$000$	$000\mid000$	$I$
$X_1$	$001$	$001\mid000$	$X_1$
$X_2$	$010$	$010\mid000$	$X_2$
$X_3$	$011$	$011\mid000$	$X_3$
$X_4$	$100$	$100\mid000$	$X_4$
$X_5$	$101$	$101\mid000$	$X_5$
$X_6$	$110$	$110\mid000$	$X_6$
$X_7$	$111$	$111\mid000$	$X_7$
$Z_1$	$001$	$000\mid001$	$Z_1$
$Z_2$	$010$	$000\mid010$	$Z_2$
$Z_3$	$011$	$000\mid011$	$Z_3$
$Z_4$	$100$	$000\mid100$	$Z_4$
$Z_5$	$101$	$000\mid101$	$Z_5$
$Z_6$	$110$	$000\mid110$	$Z_6$
$Z_7$	$111$	$000\mid111$	$Z_7$
$Y_1$	$001$	$001\mid001$	$Y_1$
$Y_2$	$010$	$010\mid010$	$Y_2$
$Y_3$	$011$	$011\mid011$	$Y_3$
$Y_4$	$100$	$100\mid100$	$Y_4$
$Y_5$	$101$	$101\mid101$	$Y_5$
$Y_6$	$110$	$110\mid110$	$Y_6$
$Y_7$	$111$	$111\mid111$	$Y_7$

Distinctness is immediate from the seven nonzero columns. Pure X errors have a nonzero first half and zero second half; pure Z errors have the reverse; Y errors have two equal nonzero halves. Counting the identity gives twenty-two occupied sectors out of the available $2^6=64$.

Separated lookup recovery and Pauli frames

The six-bit record also defines a finite decoder outside the one-error promise. Let $j(000)$ denote no site and let $j(h_i)=i$. For any $a,b\in\mathbb F_2^3$, choose the phase-free recovery

$$R(a\mid b)=X_{j(a)}Z_{j(b)},$$

omitting a factor when its half is zero and ignoring global phase. If $a=b\ne000$, this representative is recorded as $Y_{j(a)}$. On the twenty-two promised sectors it reduces exactly to the final column of the ledger. On a general syndrome, however, it may place an X and a Z on different sites. Calling the rule “separated” means that the two Hamming halves are decoded independently; it does not mean the underlying physical noise is independent.

An ideal recovery can either apply $R(s)$ to the data or update a Pauli frame. Frame tracking avoids an immediate physical pulse, but the equivalence is conditional: subsequent ideal Clifford operations must propagate the frame correctly, later measurements must reinterpret their outcomes, and no non-Clifford or hardware-level effect may be silently ignored. The Syndrome Measurement page owns the physical instruments that produce a record. This page assumes that the six stabilizer eigenvalues are reported perfectly and once.

Exact Correction and Full Distance Three

The nondegenerate Knill–Laflamme matrix

Let

$$\mathcal E_1=\{I,X_j,Y_j,Z_j:j=1,\ldots,7\}.$$

For distinct $E_a,E_b\in\mathcal E_1$, the product $E_a^\dagger E_b$ has nonzero syndrome. Indeed, equal syndromes would imply $s(E_a)=s(E_b)$, contradicting the ledger. A Pauli with nonzero syndrome maps the code space to an orthogonal stabilizer eigenspace, so

$$PE_a^\dagger E_bP=0\quad(a\ne b).$$

For $a=b$, the Pauli phases cancel and the expression is $P$. Hence this fixed basis obeys the exact Knill–Laflamme relation

$$PE_a^\dagger E_bP=\delta_{ab}P.$$

The coefficient matrix is therefore $I_{22}$, of rank twenty-two. This is nondegenerate correctability: the twenty-two error images of the two-dimensional code space are mutually orthogonal. Knill and Laflamme’s general theorem says that this operator identity, rather than a classical story about identifying a hidden error, is the necessary and sufficient condition for exact reversal on the selected error span. The page Why Quantum Error Correction Is Possible develops that general theorem and its assumptions.

Full-Pauli distance three

Represent a phase-free Pauli by binary vectors

$$E(x,z)=X(x)Z(z),\qquad x,z\in\mathbb F_2^7.$$

Commutation with every Z-type generator requires $Hx^{\mathsf T}=0$; commutation with every X-type generator requires $Hz^{\mathsf T}=0$. Thus every Pauli in the normalizer has $x,z\in C$. If its Pauli support had weight one or two, each nonzero one of $x,z$ would have Hamming weight at most two. The distance-three property of $C$ forces both vectors to be zero. There is therefore no nonidentity normalizer Pauli of weight below three.

The operators $X_1X_2X_3$ and $Z_1Z_2Z_3$ are weight-three normalizer elements and were shown above to act as nontrivial logical Paulis. They are not stabilizers, so the lower bound is attained:

$$d=\min_{E\in N(\mathcal S)\setminus\mathcal S}\operatorname{wt}(E)=3.$$

This proof treats arbitrary mixtures of X, Y, and Z support, rather than proving only separate classical bit- and phase-distance statements. It also separates two notions. Distance three says that all Pauli errors through weight one are correctable and all Pauli errors through weight two are detectable. Purity says that the stabilizer itself has no nonidentity member below distance; the enumerator $1+21z^4+42z^6$ proves that fact here.

Coherent and reference-entangled one-qubit noise

A physical disturbance on site $j$ need not select a classical Pauli label. Any operator on that qubit expands as

$$A_j=\alpha_I I+\alpha_X X_j+\alpha_Y Y_j+\alpha_Z Z_j.$$

Linearity of the Knill–Laflamme relation therefore extends exact recovery from $\mathcal E_1$ to the full operator span on any one site. Syndrome extraction can correlate the four orthogonal error sectors with a record without revealing $\alpha|\overline0\rangle+\beta|\overline1\rangle$; conditional recovery then returns the logical state. The Pauli basis is a calculation device, not an assumption that nature first samples a classical Pauli.

The claim also survives entanglement with an inaccessible reference. If $|\Psi\rangle_{LR}=\sum_b|\overline b\rangle_L|r_b\rangle_R$, let an environmental interaction on one physical qubit have Kraus operators $A_\mu$ in the same Pauli span. Exact correction acts as the identity channel on the encoded subsystem, so

$$(\mathcal R\circ\mathcal N\otimes\operatorname{id}_R) \bigl(|\Psi\rangle\langle\Psi|\bigr) =|\Psi\rangle\langle\Psi|.$$

Retaining the reference is essential: merely restoring two basis states would not prove preservation of their relative phase or of entanglement. This exact statement assumes that the noise support is confined to one data qubit and that recovery itself is ideal. It does not certify a faulty extraction circuit, leakage outside the qubit model, or a many-qubit correlated disturbance.

Weak Self-Duality and Transversal Clifford Operations

Hadamard exchanges the check sectors

The single-qubit Hadamard conjugates $X$ to $Z$ and $Z$ to $X$. Because the two check sectors have identical supports,

$$H^{\otimes7}g_iH^{\otimes7}=g_{i+3}, \qquad H^{\otimes7}g_{i+3}H^{\otimes7}=g_i \quad(i=1,2,3).$$

The six generators are merely permuted, so the code space is preserved. On the chosen logical representatives,

$$H^{\otimes7}\overline XH^{\otimes7}=\overline Z, \qquad H^{\otimes7}\overline ZH^{\otimes7}=\overline X.$$

These two conjugations determine logical Hadamard up to an irrelevant global phase. The phase can also be fixed directly: the uniform coset states are related by the binary Fourier transform in the way implied by the displayed logical Pauli action. Thus bitwise Hadamard implements $\overline H$, not merely some Clifford with the same action on one basis state.

“Transversal” here means that each physical gate acts within a single coordinate and never couples two qubits of the same code block. A one-gate fault at this ideal layer therefore cannot fan out within that block. This structural observation is not yet a complete fault-tolerance proof: error propagation through neighboring operations, syndrome extraction, and malignant fault combinations still depend on a specified circuit.

Bitwise CNOT between identical blocks

Take two blocks with the same qubit ordering, call them control $c$ and target $t$, and apply

$$\operatorname{CNOT}^{\otimes7}_{c\to t} =\prod_{j=1}^7\operatorname{CNOT}_{c_j\to t_j}.$$

The physical conjugation rules are

$$\begin{aligned} X_c&\longmapsto X_cX_t,& Z_c&\longmapsto Z_c,\\ X_t&\longmapsto X_t,& Z_t&\longmapsto Z_cZ_t. \end{aligned}$$

Apply them to each support row. A control-block X generator becomes the product of the matching X generator on control and target; a target-block Z generator becomes the product of the matching Z generator on both blocks. The remaining control Z and target X generators stay where they are. Accordingly, the full two-block stabilizer group is preserved.

The identical computation on the logical representatives gives

$$\begin{aligned} \overline X_c&\longmapsto\overline X_c\overline X_t,& \overline Z_c&\longmapsto\overline Z_c,\\ \overline X_t&\longmapsto\overline X_t,& \overline Z_t&\longmapsto\overline Z_c\overline Z_t. \end{aligned}$$

Those are exactly the standard logical-CNOT conjugations. Identical block ordering matters: an untracked coordinate permutation can change the pairing. Each faulty physical CNOT can affect at most one qubit in each block, which is the transversality advantage; whether the resulting two-block error is managed correctly remains a protocol-level question.

The phase-gate convention

Let

$$S=\operatorname{diag}(1,i).$$

The direction of the encoded phase gate is convention-sensitive. Single-qubit conjugation gives $SXS^\dagger=Y$ and $SZS^\dagger=Z$. Every X-type stabilizer here has weight four, so its four factors of $Y=iXZ$ contribute $i^4=1$. The paired-support relation then gives

$$S^{\otimes7}g_{i+3}(S^\dagger)^{\otimes7}=g_{i+3}g_i, \qquad S^{\otimes7}g_i(S^\dagger)^{\otimes7}=g_i \quad(i=1,2,3).$$

Thus bitwise $S$ preserves the stabilizer group. It does not, under the phase conventions frozen on this page, implement logical $S$. Since $Y^{\otimes7}=i^7\overline X\overline Z=-\overline Y$,

$$S^{\otimes7}\overline X(S^\dagger)^{\otimes7} =-\overline Y, \qquad S^{\otimes7}\overline Z(S^\dagger)^{\otimes7} =\overline Z.$$

These are the conjugation rules for logical $S^\dagger$. The same result is visible on the logical basis. All words in $|\overline0\rangle$ have weight zero or four, so bitwise S gives phase $1$; all words in $|\overline1\rangle$ have weight three or seven, so it gives $i^3=i^7=-i$. Therefore

$$S^{\otimes7}: \alpha|\overline0\rangle+\beta|\overline1\rangle \longmapsto \alpha|\overline0\rangle-i\beta|\overline1\rangle.$$

It follows that $S^{\otimes7}$ is logical $S^\dagger$, while $(S^\dagger)^{\otimes7}$ is logical $S$. Omitting the minus sign in the logical-X conjugation reverses this conclusion.

Clifford closure is not universality

Logical Pauli operators together with the transversal Hadamard, phase direction just derived, and blockwise CNOT generate the encoded Clifford group. Steane’s 1997 active-stabilization paper used the code’s encoded operations as part of a broader program that also addressed preparation, stabilization, and state synthesis. The algebra above establishes only the code-preserving ideal conjugations. It does not price the ancillas, certify a fault-tolerant implementation of every step, or supply a non-Clifford gate.

Clifford operations alone are not universal for quantum computation. Universal completion requires an additional protected resource, such as a suitable injected state, and the reliability of that resource is not implied by the six stabilizer checks. Moreover, the Eastin–Knill theorem rules out a universal set implemented entirely by transversal logical gates for a finite-dimensional quantum code under its stated assumptions. It does not say that transversal gates are useless, nor that every individual logical gate must be nontransversal. It limits the complete set.

The general questions—how gadgets contain fault spread, how non-Clifford resources are prepared and distilled, and when code switching is useful—belong to Fault-Tolerant Gates. The present claim is narrower: this fixed Steane block has the declared transversal logical Clifford actions.

Packing, Aliasing, and Ideal Decoder Limits

Nondegenerate but not perfect

For a nondegenerate $t=1$ code, the quantum Hamming bound counts one two-dimensional error image for the identity and for each of the $3n=21$ single-qubit Pauli errors. Here

$$2^1\left[1+3\binom71\right]=44<128=2^7.$$

Equivalently, only twenty-two of the sixty-four syndrome labels are occupied by weight-zero and weight-one errors. The inequality is strict, so this quantum code is not perfect. The word “Hamming” refers to its classical ingredient; the classical $[7,4,3]$ code is perfect for one classical bit error, but perfection does not carry through this quantum packing count.

Nor should nonperfect be mistaken for degenerate. Degeneracy asks whether distinct correctable errors have the same action on the code, or equivalently whether a low-weight product of two errors lies in the stabilizer. The $I_{22}$ Knill–Laflamme matrix and the minimum stabilizer weight four show that the promised one-error set is nondegenerate. Perfection instead asks whether its orthogonal error spaces fill the entire physical Hilbert space. This code is pure and nondegenerate yet has unused syndrome sectors. Preskill’s Chapter 7 presents these packing and degeneracy distinctions in the broader theory of quantum codes.

Two explicit higher-weight aliases

Syndrome measurement detects departure from the code space, but a syndrome does not reveal the physical error uniquely once the one-error promise is removed. Because syndromes add and $h_1+h_2=001+010=011=h_3$,

$$s(X_1X_2)=011\mid000=s(X_3).$$

The frozen lookup responds with $X_3$. The recovery is consistent with the record, but its residual action is

$$X_3X_1X_2=X_1X_2X_3\sim\overline X.$$

The analogous phase alias is

$$s(Z_1Z_2)=000\mid011=s(Z_3), \qquad Z_3Z_1Z_2=Z_1Z_2Z_3\sim\overline Z.$$

In both examples the stabilizer measurements and the specified decoder do exactly what their definitions say. What fails is the premise that the actual error belongs to $\mathcal E_1$. A different inference rule supplied with a nonuniform prior might choose a different representative for an ambiguous sector. Detection, guaranteed correction under a promise, and optimal inference under a noise model are three different claims.

Independent depolarizing fixture

For one deterministic finite validation, assign each data qubit independent depolarizing probabilities

$$\Pr(I)=1-p,\qquad \Pr(X)=\Pr(Y)=\Pr(Z)=\frac p3,$$

then apply the separated sixty-four-syndrome recovery $R(a\mid b)$. Enumerate all $4^7=16384$ phase-free physical Paulis. After recovery, each residual has zero syndrome and therefore lies in one of the four logical cosets $\mathcal S$, $\overline X\mathcal S$, $\overline Y\mathcal S$, or $\overline Z\mathcal S$. The exact ledger is:

Physical Pauli weight	Total	$I_L$	$X_L$	$Y_L$	$Z_L$
0	1	1	0	0	0
1	21	21	0	0	0
2	189	42	63	21	63
3	945	252	217	259	217
4	2835	609	714	798	714
5	5103	1281	1302	1218	1302
6	5103	1428	1239	1197	1239
7	2187	462	561	603	561

Every weight-$w$ row sums to $\binom7w3^w$; all totals sum to $4^7$; and each logical column sums to $4096$. The first two rows verify the correction promise. At weight two, the nonidentity logical columns contain $63+21+63=147$ failing Paulis, while forty-two happen to be mapped back to the identity logical class.

The classification can be reproduced without floating-point arithmetic or a probabilistic simulation. Encode a physical Pauli by its binary pair $(x\mid z)$, obtain its syndrome from the six symplectic inner products, and XOR the pair for the prescribed recovery. The residual has zero syndrome. To label its logical class, test its commutation with the frozen $\overline X$ and $\overline Z$, or compare it against the four normalizer cosets after generating the sixty-four stabilizers. Both routes must return the same label. Iterating the physical strings in a fixed lexicographic order, while counting only their input Pauli weight, produces integer counts that do not depend on a random seed.

The row and column checks test different possible defects. A row failure signals that a physical string was omitted, duplicated, or assigned the wrong weight. A logical-column sum other than $4096$ signals a bad coset classifier, because the four normalizer cosets are equal in size after the decoder maps each syndrome sector back to zero syndrome. Agreement in the weight-zero and weight-one rows tests the promised recovery, whereas the two explicit aliases test named entries in the weight-two failure classes. These independent invariants make the ledger a useful deterministic validation fixture rather than an unexplained list of integers.

Weighting the nonidentity logical counts in row $w$ by $(p/3)^w(1-p)^{7-w}$ gives

$$\begin{aligned} p_L={}&\frac{49}{3}p^2-56p^3+\frac{2380}{27}p^4 -\frac{6160}{81}p^5\\ &+\frac{8512}{243}p^6-\frac{4864}{729}p^7. \end{aligned}$$

Several exact checks constrain transcription and convention errors:

$$p_L(0)=0,\qquad p_L(3/4)=3/4,\qquad p_L(1)=575/729, \qquad p_L=\frac{49}{3}p^2+O(p^3).$$

The leading coefficient also follows directly from the 147 failing weight-two strings: $147(p/3)^2=49p^2/3$ to lowest order. At $p=3/4$, all four physical Paulis are equally likely, and the four equal-size residual logical cosets make the logical nonidentity probability $3/4$.

This polynomial is an exact ideal-block result for one channel convention and one fixed decoder. It is not a code-capacity threshold, an optimized-decoder claim, a circuit-level forecast, a correlated-noise or leakage model, or a device prediction. The channel convention itself is developed at Pauli Noise and Depolarizing Channels; general inference from priors, repeated noisy records, and confidence belongs to Decoders.

Canonical Owners and Boundaries

What this page owns and where to continue

This page owns the exact seven-qubit convention declared at its start: the ordered Hamming matrix, normalized logical cosets, six signed generators, projector, logical representatives, syndrome ledger, phase-free separated recovery, distance proof, transversal Clifford conjugations, two aliases, and finite depolarizing enumerator. The prerequisite Stabilizer Formalism page retains the general Pauli, symplectic, normalizer, and Clifford language. CSS Codes owns the general family construction, quotient distances, and generic algebraic gate conditions; this page retains its fixed Hamming matrix, logical cosets, twenty-two occupied syndromes, separated recovery, code-specific Clifford convention, and finite depolarizing polynomial.

Color Codes owns the equivalent triangular geometry and scalable 2-colex family; this page retains its Hamming convention, exact cosets, syndrome ledger, recovery, and code-specific gate fixture.

Two nearby distance-three codes sharpen the comparison. Five-Qubit Code owns the perfect non-CSS $[[5,1,3]]$ code and its sixteen-sector lookup. Shor Code owns the concatenated, degenerate $[[9,1,3]]$ construction. The Steane code is instead Hamming-derived, weakly self-dual, nondegenerate, and nonperfect. These adjectives describe different structures; none is a synonym for being “better” without a physical task and noise model.

Seven data qubits are not a hardware resource estimate. They omit state preparation, encoded ancillas, verification, coupling gates, repeated check rounds, measurement, reset, routing, connectivity, classical processing, latency, discarded trials, factories, scheduling, and spare capacity. Steane-style encoded-ancilla error correction is a protocol family associated with this code, but it is not the support-only algebra developed here. Dated experimental realizations and their actual resources belong to Error-Correction Case Studies. The Quantum Error Correction and Fault Tolerance guide provides the chapter map and keeps these owner boundaries explicit.

The distinction also protects historical interpretation. The existence of a compact encoded basis and transversal ideal gates establishes important code structure, but it does not retrospectively establish a modern logical-error rate, threshold, or scalable architecture. Such conclusions require a dated noise model, a complete fault-tolerant protocol, and resource accounting at the level actually implemented.

Exercises

1. Audit the Hamming inclusion and logical cosets

Starting only from the printed matrix $H$, recover its seven ordered columns, compute $HH^{\mathsf T}$, and prove $C^\perp\subset C$. Determine the dimensions of $C$ and $C^\perp$. Then use the explicit computational-basis expansions to verify normalization, orthogonality, and the parity separation of the two logical states.

Solution

Reading downward gives $001,010,011,100,101,110,111$, so no column is zero and no two columns coincide. Each row has weight four. Distinct rows overlap in two places, while a row overlaps itself in four places; every entry of $HH^{\mathsf T}$ is therefore zero modulo two. Each row of $H$ lies in $\ker H$, and hence $\operatorname{row}H=C^\perp\subset C$.

The three rows are independent: their leading nonzero coordinates occur at qubits four, two, and one, respectively. Thus $\operatorname{rank}H=3$, $\dim C=7-3=4$, and $\dim C^\perp=3$. Each logical expansion contains eight distinct basis strings with squared amplitude $1/8$, so its norm is one. The two supports are disjoint cosets because $\mathbf1\notin C^\perp$, giving zero inner product. Finally, $C^\perp$ contains the zero word and seven weight-four words; complementing them produces one weight-seven and seven weight-three words. This proves the even-versus-odd parity separation used by logical Z and transversal S.

2. Construct the six stabilizers and projector

Translate each Hamming row into its Z-type and X-type Pauli check. Verify the signs, commutation, binary rank, group size, projector identities and trace, and the stabilizer weight enumerator. Finally, apply the frozen logical X and Z to both logical basis states and find their weight-three equivalents.

Solution

The row strings give $IIIZZZZ,IZZIIZZ,ZIZIZIZ$, followed by $IIIXXXX,IXXIIXX,XIXIXIX$, all with positive sign. Same-type checks commute, and each cross-type commutator is $(-1)^{r_a\cdot r_b}=1$ because $HH^{\mathsf T}=0$. Three independent Z rows and three independent X rows give binary rank six and $64$ group elements.

Each $(I+g_a)/2$ is a commuting Hermitian projector, so their product $P$ is Hermitian and idempotent. In the group sum, only $I$ has nonzero trace; hence $\operatorname{tr}P=2^7/64=2$. There are twenty-one weight-four and forty-two weight-six nonidentity stabilizers, yielding $1+21z^4+42z^6$. Bitwise X complements each basis string and swaps the logical states. Bitwise Z reads their even or odd parity and acts with signs $+1,-1$. Thus they act as logical X and Z. Multiplication by $g_4=IIIXXXX$ and $g_1=IIIZZZZ$ gives $\overline Xg_4=X_1X_2X_3$ and $\overline Zg_1=Z_1Z_2Z_3$.

3. Reconstruct the one-error syndrome ledger

Derive the syndromes of all twenty-two members of $\mathcal E_1$ without copying the table. Explain why they are distinct. Then use the ideal lookup on $X_5$, $Z_6$, and $Y_2$, including the residual operator after correction.

Solution

An $X_j$ anticommutes with exactly the Z checks whose Hamming rows contain site $j$, giving $(h_j\mid000)$. The same reasoning with sectors exchanged gives $s(Z_j)=(000\mid h_j)$, and multiplication gives $s(Y_j)=(h_j\mid h_j)$. The seven nonzero columns are distinct. Moreover, the zero-half patterns separate X, Z, and Y families, so these twenty-one syndromes and $000\mid000$ are all different.

Since $h_5=101$, the record for $X_5$ is $101\mid000$, and the recovery is $X_5$. For $Z_6$, it is $000\mid110$ and the recovery is $Z_6$. For $Y_2$, it is $010\mid010$ and the phase-free recovery is $Y_2$, equivalently $X_2Z_2$ up to phase. In every case recovery times error is the identity up to global phase, so the logical residual is $I_L$.

4. Prove exact correction and distance three

Use the ledger to derive the $I_{22}$ Knill–Laflamme matrix. Extend the result to a coherent one-qubit operator while retaining an arbitrary reference system. Then prove distance three for the full Pauli normalizer, not only for separate pure-X and pure-Z errors.

Solution

For $a\ne b$, syndrome addition gives $s(E_a^\dagger E_b)=s(E_a)+s(E_b)\ne0$. The product maps the code into a stabilizer eigenspace orthogonal to the code, so $PE_a^\dagger E_bP=0$. For $a=b$, the product is identity up to a phase that cancels in $E_a^\dagger E_a$, giving $P$. Thus the coefficient matrix is exactly $I_{22}$.

Every one-qubit Kraus operator is a linear combination of $I,X_j,Y_j,Z_j$. Bilinearity extends the matrix identity to any channel whose Kraus operators lie in that span. The recovery acts as the identity channel on the encoded subsystem, so tensoring it with $\operatorname{id}_R$ preserves every encoded state entangled with a reference $R$, including all relative phases.

For a normalizer Pauli $X(x)Z(z)$, commutation with the Z and X check sectors gives $x,z\in C$. A total support below three would make every nonzero one of these vectors a codeword of Hamming weight below three, impossible because $C$ has distance three. The weight-three normalizer elements $X_1X_2X_3$ and $Z_1Z_2Z_3$ are nontrivial logical operators, so the lower bound is attained and the full Pauli distance is three.

5. Verify transversal Hadamard and CNOT

Compute the conjugation of every stabilizer sector and both logical Pauli generators under bitwise Hadamard. Repeat for bitwise CNOT between two identically ordered blocks, keeping the control and target conjugations distinct.

Solution

Hadamard exchanges X and Z on each coordinate, so it sends $g_i\leftrightarrow g_{i+3}$ for $i=1,2,3$. It also sends $\overline X\leftrightarrow\overline Z$. The stabilizer is preserved and the logical conjugations are exactly those of logical H.

Under physical CNOT, a control X copies to the target, a target Z copies to the control, and control Z and target X remain unchanged. Therefore each control X check becomes the product of the matching X checks on both blocks; each target Z check becomes the product of the matching Z checks; the other six generators remain in their original blocks. Replacing each support row by the seven-site logical support gives $\overline X_c\mapsto\overline X_c\overline X_t$, $\overline Z_t\mapsto\overline Z_c\overline Z_t$, $\overline Z_c\mapsto\overline Z_c$, and $\overline X_t\mapsto\overline X_t$. These are precisely logical CNOT.

6. Resolve the transversal phase convention

With $S=\operatorname{diag}(1,i)$ and $\overline Y=i\overline X\overline Z$, determine the action of $S^{\otimes7}$ on stabilizers, logical Paulis, and logical basis states. Explain why the resulting Clifford gates are not a universal transversal set.

Solution

Each weight-four X check becomes a weight-four Y string. Writing $Y=iXZ$, the phase is $i^4=1$, so $g_{i+3}\mapsto g_{i+3}g_i$; every Z check is fixed. Thus the code space is preserved. For the logical operator, $Y^{\otimes7}=i^7\overline X\overline Z=-\overline Y$, while $\overline Z$ is fixed. Equivalently, even-weight words in $|\overline0\rangle$ receive phase one and weight-three or weight-seven words in $|\overline1\rangle$ receive $-i$. Therefore physical bitwise S implements logical $S^\dagger$, and physical bitwise $S^\dagger$ implements logical S.

Together with H, CNOT, and Paulis these operations generate Clifford gates. Clifford circuits are not computationally universal, and Eastin–Knill precludes a universal entirely transversal set under its finite-dimensional code assumptions. A protected non-Clifford resource and its own fault analysis are still needed.

7. Diagnose two higher-weight aliases

Derive the frozen X- and Z-type weight-two aliases, identify each residual logical operator, and compare the number of promised error sectors with the quantum Hamming bound.

Solution

Since $h_1+h_2=h_3$, syndrome addition gives $s(X_1X_2)=s(X_3)=011\mid000$. The lookup applies $X_3$, leaving $X_1X_2X_3\sim\overline X$. Similarly, $s(Z_1Z_2)=s(Z_3)=000\mid011$, and applying $Z_3$ leaves $Z_1Z_2Z_3\sim\overline Z$. These are decoder failures outside the one-error promise, not measurement inconsistencies.

The nondegenerate radius-one spaces occupy $2[1+3\binom71]=44$ physical dimensions, whereas seven qubits have dimension $128$. Equivalently, the identity and twenty-one one-qubit errors use only twenty-two of sixty-four syndromes. The strict inequality proves that this quantum code is not perfect.

8. Audit the ideal depolarizing decoder

Count the weight-two errors that fail under the separated lookup and derive the leading small-$p$ logical-failure probability. As a finite computational extension, explain how to reproduce the full residual-class enumerator and exact polynomial without making a stochastic estimate.

Solution

The weight-two row contains $189=\binom723^2$ Paulis. The identity-logical column contains forty-two, so $147$ fail; equivalently, sum the other columns as $63+21+63$. Each particular weight-two Pauli has probability $(p/3)^2(1-p)^5$, hence

$$p_L=147\left(\frac p3\right)^2+O(p^3) =\frac{49}{3}p^2+O(p^3).$$

For the exact extension, iterate deterministically over the $4^7$ strings in $\{I,X,Y,Z\}^{\otimes7}$. XOR their single-site syndrome contributions, apply $R(a\mid b)$, and compare the zero-syndrome residual with the four cosets generated by $\mathcal S$, $\overline X$, $\overline Y$, and $\overline Z$. Bin by physical weight and logical class. The resulting integer ledger must match the displayed table, with every row, grand total, and logical-column sum checked. Weight its three nonidentity columns by $(p/3)^w(1-p)^{7-w}$, sum over $w$, and expand; this reproduces the displayed seventh-degree polynomial exactly, with no Monte Carlo error.

References

• Calderbank, A. R., and P. W. Shor. “Good Quantum Error-Correcting Codes Exist.” Physical Review A 54, 1098–1105 (1996). doi:10.1103/PhysRevA.54.1098.
• Eastin, B., and E. Knill. “Restrictions on Transversal Encoded Quantum Gate Sets.” Physical Review Letters 102, 110502 (2009). doi:10.1103/PhysRevLett.102.110502.
• Gottesman, D. Stabilizer Codes and Quantum Error Correction. Ph.D. thesis, California Institute of Technology (1997). doi:10.7907/rzr7-dt72; arXiv:quant-ph/9705052.
• Knill, E., and R. Laflamme. “Theory of Quantum Error-Correcting Codes.” Physical Review A 55, 900–911 (1997). doi:10.1103/PhysRevA.55.900.
• Preskill, J. Quantum Information, Chapter 7, “Quantum Error Correction.” Official working draft, updated March 2026. PDF.
• Steane, A. M. “Error Correcting Codes in Quantum Theory.” Physical Review Letters 77, 793–797 (1996). doi:10.1103/PhysRevLett.77.793.
• Steane, A. M. “Multiple-Particle Interference and Quantum Error Correction.” Proceedings of the Royal Society A 452, 2551–2577 (1996). doi:10.1098/rspa.1996.0136.
• Steane, A. M. “Active Stabilization, Quantum Computation, and Quantum State Synthesis.” Physical Review Letters 78, 2252–2255 (1997). doi:10.1103/PhysRevLett.78.2252.