Steane code

The Steane code, denoted as the [[7,1,3]] quantum error-correcting code, encodes a single logical qubit into seven physical qubits and corrects any arbitrary single-qubit error, while detecting up to two errors, as introduced by Andrew M. Steane in 1996. It achieves the quantum Hamming bound for single-error correction, making it a perfect code in this category, and serves as a foundational example in quantum information theory. As a CSS (Calderbank-Shor-Steane) code, the Steane code is constructed using the classical binary [7,4,3] Hamming code, where the code subspace is defined by the +1 eigenspace of six commuting stabilizer operators—three measuring phase-flip (Z) errors and three measuring bit-flip (X) errors—derived from the parity-check matrix of the Hamming code. The logical basis states are superpositions over the even-weight subcode: |0_L\rangle = \frac{1}{\sqrt{8}} \sum_{c \in C^\perp} |c\rangle and |1_L\rangle = \frac{1}{\sqrt{8}} \sum_{c \in C^\perp} |c + 1111111\rangle, where C is the [7,4,3] Hamming code and C^\perp its dual.^[1] This self-dual structure allows separate correction of X and Z errors using the same classical decoder, enhancing efficiency.^[2] Encoding into the Steane code can be performed using nine CNOT gates and four Hadamard gates starting from a product state, while syndrome extraction for error correction employs ancilla qubits to measure the stabilizers without disturbing the logical information, enabling fault-tolerant implementations.^[1] The code's minimum distance of 3 ensures robustness against decoherence in quantum systems, and it has been experimentally demonstrated in fault-tolerant settings on trapped-ion platforms, achieving multiple rounds of error correction with logical error rates below physical rates. Its simplicity and optimality have made it a benchmark for studying quantum error correction thresholds and concatenation with other codes in scalable quantum computing architectures.

Overview

Definition and parameters

The Steane code is a quantum error-correcting code with parameters [[7,1,3]], meaning it encodes 1 logical qubit into 7 physical qubits and has a minimum distance of 3, allowing correction of any single-qubit error.^[3] Its key parameters are n=7 (number of physical qubits), k=1 (number of logical qubits), and d=3 (minimum distance), where the distance d enables detection of up to d-1=2 errors and correction of t=\lfloor (d-1)/2 \rfloor =1 error.^[3] The Steane code belongs to the class of CSS (Calderbank-Shor-Steane) codes and is constructed from the classical binary [7,4,3] Hamming code, which is a perfect linear code capable of correcting single errors.^[3] The code space consists of a 2-dimensional subspace within the 128-dimensional Hilbert space of 7 qubits, spanned by the logical basis states that are invariant under the code's stabilizers.^[3]

Relation to classical codes

The Steane code is a quantum error-correcting code derived from the classical binary [7,4,3] Hamming code via the Calderbank-Shor-Steane (CSS) construction, which maps classical linear codes to quantum stabilizer codes capable of correcting both bit-flip (X) and phase-flip (Z) errors.^[2] The construction leverages the [7,4,3] Hamming code C and its dual, the [7,3,4] simplex code C^⊥, which is the even-weight subcode of the Hamming code and serves to ensure the necessary orthogonality conditions for the quantum stabilizers.^[1] These classical codes define separate parity-check matrices that generate the X-type and Z-type stabilizers, allowing the quantum code to inherit the error-detection capabilities of the classical Hamming code while extending them to the non-commutative Pauli error model.^[4] In the CSS framework, the Steane code is defined using a pair of commuting classical linear codes C and C^⊥ with C^⊥ ⊆ C, though in this self-dual case, the symmetry arises from the self-orthogonality of the underlying structure. The Z stabilizers are generated by applying Z operators to the supports given by the rows of the parity-check matrix of C (the Hamming code), while the X stabilizers are generated by applying X operators to the rows of the parity-check matrix of C^⊥ (the simplex code). This separation enables independent correction of X and Z errors, with the commuting property guaranteed by the even parity of overlaps between the generator supports (i.e., the rows of the matrices have even-weight inner products modulo 2).^[5] The resulting quantum code encodes 1 logical qubit into 7 physical qubits and corrects any single-qubit Pauli error. The parity-check matrix H for the [7,4,3] Hamming code, which serves as the generator matrix for both sets of stabilizers in the Steane code, is given by

H = \begin{pmatrix} 1 & 0 & 1 & 0 & 1 & 0 & 1 \\ 0 & 1 & 1 & 0 & 0 & 1 & 1 \\ 0 & 0 & 0 & 1 & 1 & 1 & 1 \end{pmatrix},

where the rows correspond to the three independent parity checks (with all rows having even weight to ensure orthogonality).^[1] The rows of H span the simplex code C^⊥, confirming its role in generating the stabilizer group.^[4] The logical Pauli operators for the Steane code are transversal due to the CSS structure: the logical X operator is \bar{X} = X^{\otimes 7}, applying X to all seven qubits, as the all-ones vector lies in the Hamming code C (satisfying H times all-ones equals zero modulo 2). Similarly, the logical Z operator is \bar{Z} = Z^{\otimes 7}, supported on the all-ones vector, which aligns with the dual code properties in the construction. These operators commute with all stabilizers and distinguish the logical states without introducing errors.^[5]

Background

Classical Hamming code

The binary Hamming code of length 7, denoted as the [7,4,3] code, is a linear error-correcting code over the binary field that encodes 4 information bits into a 7-bit codeword by appending 3 parity bits, enabling the correction of any single-bit error due to its minimum Hamming distance of 3.^[6] This code was introduced by Richard Hamming in 1950 as a systematic method to detect and correct errors in data transmission, particularly motivated by the needs of early computing machines.^[7] The code is defined by its generator matrix G, a $4 \times 7 matrix in systematic form, where the first 4 columns form the $4 \times 4 identity matrix I_4 and the remaining 3 columns specify the parity checks:

G = \begin{pmatrix} 1 & 0 & 0 & 0 & 1 & 1 & 0 \\ 0 & 1 & 0 & 0 & 1 & 0 & 1 \\ 0 & 0 & 1 & 0 & 0 & 1 & 1 \\ 0 & 0 & 0 & 1 & 1 & 1 & 1 \end{pmatrix}

^[8] A codeword is obtained by multiplying an information vector \mathbf{m} (a $1 \times 4 row vector) by G, yielding \mathbf{c} = \mathbf{m} G modulo 2. The parity-check matrix H, a $3 \times 7 matrix whose rows are orthogonal to the codewords (i.e., H \mathbf{c}^T = \mathbf{0} for any codeword \mathbf{c}), is given by:

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

^[9] The columns of H are the binary representations of the integers 1 through 7, facilitating error identification.^[10] Error correction in the classical Hamming code proceeds by computing the syndrome \mathbf{s} = H \mathbf{r}^T modulo 2, where \mathbf{r} is the received vector; if no error occurs, \mathbf{s} = \mathbf{0}, but otherwise, \mathbf{s} equals the column of H corresponding to the erroneous bit position, indicating which bit to flip to recover the codeword.^[10] This mechanism allows the code to correct all single-bit errors and detect (but not correct) double-bit errors, as a weight-2 error produces a nonzero syndrome not matching any single column.^[11] The [7,4,3] Hamming code is a perfect code, meaning it saturates the Hamming bound (or sphere-packing bound) for single-error correction: the 16 codewords each "cover" disjoint spheres of radius 1 (each containing 1 + 7 = 8 vectors), exactly partitioning the 128 possible 7-bit vectors without overlap or gap.^[12] This optimal packing property underscores its efficiency as a foundational error-correcting code.^[13]

Principles of quantum error correction

In quantum information processing, errors on qubits arise from interactions with the environment and are typically modeled as applications of Pauli operators: the bit-flip operator X, the phase-flip operator Z, or the combined bit-and-phase-flip operator Y = iXZ. These operators, along with the identity I, generate the Pauli group on n qubits, which consists of all tensor products of single-qubit Paulis multiplied by phases \pm 1, \pm i. Unlike classical bits, quantum states can exist in superpositions and entanglements, making error detection challenging because Pauli errors on different qubits are generally non-orthogonal; for instance, the inner product between states affected by different errors is nonzero, preventing direct discrimination without disturbing the encoded information. To protect quantum data, logical qubits must be encoded into a higher-dimensional code subspace of physical qubits, allowing errors to be identified and corrected while preserving the quantum coherence. A quantum error-correcting code is capable of correcting a set of errors \{E_a\} if it satisfies the Knill-Laflamme conditions: for any pair of logical basis states |i\rangle and |j\rangle in the code subspace,

\langle i | E_a^\dagger E_b | j \rangle = \delta_{ij} \lambda_{ab},

where \delta_{ij} is the Kronecker delta and \lambda_{ab} is independent of the logical states. This ensures that errors act uniformly on the code space (preserving distinguishability of logical states) and orthogonally across different error types (enabling syndrome-based identification). These conditions generalize classical error correction to the quantum setting, where errors cannot be simply read out due to the continuous nature of quantum states. Quantum codes are characterized by parameters [[n, k, d]], where n is the number of physical qubits, k the number of logical qubits, and d the minimum distance (the smallest weight of a nontrivial logical operator). The quantum Hamming bound limits the size of such codes for correcting up to t = \lfloor (d-1)/2 \rfloor errors, providing an upper bound on $2^k in terms of n and the number of correctable error operators; codes achieving equality are called perfect. The Steane code, a [[7,1,3]] code, saturates this bound for t=1, making it a perfect quantum code.^[14] The no-cloning theorem, which prohibits perfect copying of arbitrary unknown quantum states, implies that errors cannot be measured directly on the encoded qubits without collapsing the superposition. Instead, error syndromes are extracted using ancillary qubits through non-demolition measurements that couple the code to auxiliaries, revealing the error location via parity checks while leaving the logical information intact. This indirect approach, pioneered in early quantum error correction schemes, enables repeated error correction without destroying quantum coherence.

Construction

Code subspace definition

The code subspace of the Steane code is the simultaneous +1 eigenspace of all stabilizer operators, forming a 2-dimensional subspace within the 128-dimensional Hilbert space of 7 qubits, thereby encoding 1 logical qubit. A standard choice of basis states for this subspace consists of the logical states |\overline{0}\rangle_L and |\overline{1}\rangle_L. The state |\overline{0}\rangle_L is the uniform superposition over the 8 computational basis states corresponding to the codewords of the classical [7,3,4] simplex code (the dual of the [7,4,3] Hamming code), all of which have even weight and satisfy even parity under the checks defined by the Hamming parity-check matrix H:

|\overline{0}\rangle_L = \frac{1}{\sqrt{8}} \sum_{c \in C^\perp} |c\rangle,

where C^\perp denotes the simplex code. This includes the all-zero state |0000000\rangle as one term. The state |\overline{1}\rangle_L is similarly the uniform superposition over the coset C^\perp + \mathbf{1} (adding the all-ones vector \mathbf{1}), which consists of the 8 odd-weight basis states in the support of the code subspace. The projector onto the code subspace is given by

P = \frac{1}{2^6} \prod_{i=1}^6 (I + S_i),

where the product runs over the 6 independent stabilizer generators S_i, ensuring projection onto their common +1 eigenspace. To encode an arbitrary single-qubit state |\psi\rangle = \alpha |\overline{0}\rangle + \beta |\overline{1}\rangle into the code subspace, a unitary encoding circuit is applied to |\psi\rangle \otimes |0\rangle^{\otimes 6}, consisting of controlled-NOT gates (CNOTs) whose control and target positions are determined by the generator matrix of the underlying classical Hamming code, along with Hadamard gates on auxiliary qubits to prepare the necessary superpositions. This circuit uses 9 CNOTs and 4 Hadamards in total.^[15]

Logical operators

In the Steane code, the logical Pauli operators act on the encoded qubit while preserving the code subspace, defined as the simultaneous +1 eigenspace of all stabilizer generators. These operators commute with every stabilizer but anticommute with each other, thereby implementing the algebra of a single physical qubit on the logical information.^[2] The logical bit-flip operator \bar{X} is given by the transversal application of the Pauli X gate on all seven physical qubits, \bar{X} = X^{\otimes 7}. This operator flips the logical state |\bar{0}\rangle to |\bar{1}\rangle and vice versa, as the all-ones vector lies in the appropriate classical code underlying the CSS construction, ensuring commutation with the stabilizers. Similarly, the logical phase-flip operator \bar{Z} is \bar{Z} = Z^{\otimes 7}, which applies a phase shift to the logical superposition while also commuting with the stabilizers due to the structure of the code. These weight-7 operators can equivalently be represented by lower-weight equivalents through multiplication by stabilizers, such as weight-3 forms, but the transversal form highlights the code's fault-tolerant properties.^[16]^[2] The anticommutation relation \{ \bar{X}, \bar{Z} \} = 0 follows directly from the odd number of qubits, as each paired X_i Z_i contributes a minus sign, resulting in an overall phase of -1. To measure the logical value, projective measurements are performed using ancillary qubits that interact transversally with the logical operators; for instance, an ancilla prepared in |+\rangle coupled via controlled-X gates to all seven data qubits yields the logical X eigenvalue upon measurement.^[16]

Stabilizer Formalism

Stabilizer generators

The Steane code is a CSS (Calderbank-Shor-Steane) code, and its stabilizer group is generated by six independent Pauli operators: three of Z-type and three of X-type. These generators are derived from the rows of the parity-check matrix of the classical binary [7,4,3] Hamming code, with Z-type stabilizers corresponding to phase-flip checks and X-type stabilizers to bit-flip checks.^[17] The explicit Z-type stabilizer generators are

\begin{align*} S_1 &= Z_1 Z_3 Z_5 Z_7, \\ S_2 &= Z_2 Z_3 Z_6 Z_7, \\ S_3 &= Z_4 Z_5 Z_6 Z_7. \end{align*}

The X-type generators have identical support but with X operators:

\begin{align*} S_4 &= X_1 X_3 X_5 X_7, \\ S_5 &= X_2 X_3 X_6 X_7, \\ S_6 &= X_4 X_5 X_6 X_7. \end{align*}

Each stabilizer S_i is a Pauli operator satisfying S_i^2 = I (order 2) and commutes with all others ([S_i, S_j] = 0 for all i, j), ensuring they generate an abelian stabilizer group of order $2^6 = 64. The code subspace consists of the simultaneous +1-eigenspace of these generators, where every codeword |\psi\rangle obeys S_i |\psi\rangle = |\psi\rangle for i = 1, \dots, 6. These check operators enforce the error-correcting properties of the code by projecting onto the logical subspace.^[2]

Syndrome extraction

In the Steane code, syndrome extraction is performed non-destructively by measuring the stabilizer generators using ancillary qubits, ensuring the logical quantum information remains undisturbed. This process leverages ancillary systems to entangle with the data qubits, allowing the extraction of error syndromes through parity measurements. The stabilizers, which include three independent Z-type operators and three X-type operators each of weight four, are measured separately using dedicated ancilla blocks.^[18]^[19] For each stabilizer S_i of weight w = 4, an ancilla block consisting of w qubits is prepared in a cat state \frac{1}{\sqrt{2}} \sum_{k=0}^{1} |k\rangle^{\otimes w}, which facilitates fault-tolerant parity checks by distributing potential errors across the ancillas. The data qubits in the support of S_i are then entangled with this ancilla block via controlled operations corresponding to S_i, transferring syndrome information without collapsing the code subspace. Following entanglement, parity checks are computed within the ancilla chain using additional controlled-NOT (CNOT) gates to propagate bits to a single readout ancilla, yielding a single syndrome bit per stabilizer. This ancilla-based approach minimizes error propagation from the measurement process to the data.^[19]^[18] The circuit for measuring Z-type stabilizers, which detect X errors on the data qubits, involves preparing the ancilla cat state and applying CNOT gates with the relevant data qubits as controls and successive ancilla qubits as targets to form a chain. This computes the Z-parity of the support: an X error on an odd number of data qubits flips the final ancilla's state. The readout ancilla is then measured in the Z basis, producing outcome 0 (even parity, no detected error) or 1 (odd parity, error detected).^[19]^[18] For X-type stabilizers, which detect Z errors, the procedure is analogous but adapted to the X basis. The ancilla block is prepared in the Z-basis cat state, followed by Hadamard gates on the ancillas to create the X-basis cat state \frac{1}{\sqrt{2}} \sum_{k=0}^{1} |k\rangle^{\otimes w}_X, where |k>_X denotes X-eigenstates. CNOT gates are applied with ancillas as controls and data qubits as targets in the support, effectively implementing the controlled-S_i. After reversing the Hadamards on the ancillas, parity checks are performed via CNOTs in the chain, and the readout ancilla is measured in the X basis to extract the syndrome bit. This basis transformation ensures compatibility with the X-stabilizer's action.^[19]^[18] An alternative, more efficient method specific to the Steane code, known as Steane-style syndrome extraction, uses a single 7-qubit ancilla block encoded in the same code. For Z-syndromes (detecting X errors), the ancilla is prepared in |0_L\rangle, coupled to the data via transversal CNOT gates (ancilla as control, data as target), and then measured in the Z basis after decoding to obtain the full 3-bit syndrome. Similarly, for X-syndromes (detecting Z errors), the ancilla is prepared in |+_L\rangle, with data as control and ancilla as target. This extracts all three syndrome bits simultaneously using only 7 ancillas, leveraging the code's self-duality.^[20] The complete syndrome for the Steane code consists of 6 bits—one from each stabilizer measurement—providing 3 bits for X-error syndromes and 3 for Z-error syndromes. These bits directly correspond to the classical 6-bit syndrome of the underlying [7,4,3] Hamming code, enabling error identification via a lookup table that maps the syndrome to the most likely single-qubit error location.^[18]^[19]

Error Correction Procedure

Detecting errors

In the Steane code, error detection relies on measuring the 6-bit syndrome obtained from the stabilizer generators, consisting of 3 bits for the Z-syndrome (detecting X errors) and 3 bits for the X-syndrome (detecting Z errors). This syndrome directly maps to the location of a single-qubit error through its correspondence to the columns of the classical [7,4,3] Hamming code's parity-check matrix H, a 3×7 binary matrix whose columns are all distinct nonzero 3-bit vectors, uniquely labeling the 7 physical qubits.^[3] For a single Pauli X error on qubit i, denoted X_i, the Z-stabilizers produce a nonzero Z-syndrome equal to the i-th column of H, while the X-syndrome remains the zero vector \mathbf{0}, unambiguously identifying the error location as qubit i. Similarly, a single Pauli Z error Z_i yields a nonzero X-syndrome matching the i-th column of H and a zero Z-syndrome. In the case of a Pauli Y error Y_i = i X_i Z_i, both the X- and Z-syndromes equal the i-th column of H, allowing detection and location without ambiguity for single errors, as the identical nonzero syndromes confirm the Y-type error on qubit i.^[3] Errors of weight 2 or higher can produce syndromes that mimic those of single errors, potentially leading to incorrect identification if decoded as a single-qubit fault. However, the code's distance d=3 guarantees that any single-qubit error is correctly detectable and distinguishable from the no-error case, enabling reliable correction for up to t=1 error per the quantum error-correcting code parameters [[7,1,3]].^[3]

Correcting single-qubit errors

Once the syndrome has been extracted and the location and type of the single-qubit error have been identified, correction proceeds by applying the appropriate Pauli operator to the affected physical qubit. Specifically, if an X error is detected on qubit i, an X operator is applied to that qubit; similarly, a Z error on qubit i is corrected with a Z operator, and a Y error (which is equivalent to XZ up to phase) is corrected with a Y operator. Since all Pauli operators are self-inverse, this amounts to applying the inverse of the detected error operator. This procedure restores the encoded state to the code subspace, as the correction commutes with the stabilizers for single errors.^[2] The Steane code, being a CSS code, supports transversal error correction, meaning the recovery operations consist of single-qubit Pauli gates applied independently to individual physical qubits without requiring multi-qubit entangling operations across the block. This property ensures that the correction does not introduce new errors into the logical qubit or disrupt the code structure, preserving the distance of the code. Transversal corrections are a key advantage of CSS constructions, enabling fault-tolerant implementations with low overhead.^[3] The code successfully corrects all 21 possible single-qubit Pauli errors—namely, one of X, Y, or Z on each of the 7 physical qubits—provided no higher-weight errors occur simultaneously. Errors of weight 2 or higher may produce syndromes that mimic single errors, leading to incorrect corrections and logical failure, but the minimum distance of 3 guarantees that single errors are unambiguously identifiable and correctable.^[2] To verify the success of the correction, the stabilizer generators can be re-measured using the same syndrome extraction protocol. If the resulting syndrome is the trivial (zero) value, confirming that all stabilizers evaluate to +1, the correction is deemed successful, and the encoded state is preserved. This optional verification step provides confidence in the recovery without decoding the logical information.^[21]

Properties and Performance

Error correction capability

The Steane code, denoted as a [[7,1,3]] quantum error-correcting code, can correct any arbitrary single-qubit error, including both bit-flip (X) and phase-flip (Z) errors, due to its minimum distance of d=3.^[3] This distance also enables the detection of up to two qubit errors without correction, as any two-error pattern produces a non-trivial syndrome that identifies the presence of errors but may not uniquely specify their locations.^[3] The code's design ensures that the logical qubit remains protected against isolated faults in the physical qubits, making it suitable for maintaining quantum information integrity in noisy environments.^[22] The Steane code meets the quantum Hamming bound for parameters [[7,1,3]], with $2^6 = 64 \geq 22, where 22 accounts for the no-error case plus 21 single-qubit Pauli errors. This provides efficient syndrome utilization for single-error correction.^[3] In this bound, the code distinguishes and corrects the 21 possible single-qubit Pauli errors (X, Y, Z on each of 7 positions).^[22] With an encoding rate of k/n = 1/7, where one logical qubit is encoded into seven physical qubits, the Steane code provides a compact overhead for small-scale quantum protection, balancing redundancy with resource constraints in early fault-tolerant implementations.^[3] However, its performance degrades in the presence of coherent errors, which can amplify logical failure rates beyond incoherent noise models, or adversarial multi-qubit errors that exceed the distance threshold. To enable scalable fault-tolerant quantum computing, the code's application relies on the quantum threshold theorem, which guarantees arbitrary long computations if physical error rates are below a constant threshold, typically achieved through concatenated or concatenated-like schemes incorporating Steane-style corrections.

Comparison with other quantum codes

The Steane code, a [[7,1,3]] quantum error-correcting code, offers improved efficiency over the Shor code, which is a [[9,1,3]] code capable of correcting any single-qubit error but requires nine physical qubits to encode one logical qubit.^[22] In contrast, the Steane code achieves the same error-correction distance of 3 using only seven qubits, making it a more resource-efficient option for small-scale implementations. As a Calderbank-Shor-Steane (CSS) code constructed from the classical [7,4,3] Hamming code, the Steane code enables transversal implementation of certain gates, such as the Hadamard and controlled-NOT operations, which simplifies fault-tolerant computation compared to the non-CSS Shor code. When compared to surface codes, which are a family of topological stabilizer codes defined on a two-dimensional lattice, the Steane code is better suited for early experimental demonstrations due to its compact size and lower qubit overhead for achieving distance 3. Surface codes, however, excel in scalability, allowing arbitrary distances d with a number of physical qubits scaling approximately as O(d^2), which supports large-scale fault-tolerant quantum computing with manageable overhead as system size grows. The Steane code's fixed small size limits its direct applicability to high-distance regimes, where surface codes provide superior performance thresholds under realistic noise models. A key advantage of the Steane code is that it meets the quantum Hamming bound for single-error correction with exactly seven qubits, which minimizes resource use for its parameters.^[22] It supports simple transversal implementations for the full Clifford group, facilitating fault-tolerant universal quantum computation in Steane's original scheme without additional encoding modifications for these operations. This has made it a foundational building block in early fault-tolerant architectures. Despite these strengths, the Steane code's fixed dimension of seven qubits restricts its use in concatenated or hierarchical error correction without adaptations, unlike more flexible codes such as surface codes that readily support larger distances. Its small scale also poses challenges for integrating into architectures requiring high logical fidelity over extended computations, where scalable codes offer better long-term prospects.