Building a quantum error-correcting code from scratch feels daunting: a single qubit can suffer a bit-flip (X), a phase-flip (Z), or both at once, and the errors form a continuum. So here is a beautiful shortcut. CSS codes — named for Calderbank, Shor and Steane — take two ordinary classical error-correcting codes off the shelf and weld them into a quantum code, letting decades of classical coding theory do the hard work. The trick handles bit-flips with one classical code and phase-flips with another, separately, so the frightening quantum problem splits into two problems we already know how to solve. The flagship result: the Steane code, seven physical qubits protecting one logical qubit, built entirely out of the humble [7,4] Hamming code.

A one-minute recap of classical linear codes

A classical binary linear code C of length n is a set of codewords (bit strings) closed under addition mod 2. It is pinned down by a parity-check matrix H: a bit string x is a valid codeword exactly when

If a codeword picks up an error e (a 1 in each flipped position), the received word is x + e, and multiplying by H gives the syndrome

The codeword vanishes; only the error survives. The syndrome depends on the error alone, and for a good code it names which error occurred. That single idea — a matrix whose product with the error reveals the error — is the whole engine we are about to bolt onto qubits.

The CSS construction

Take two classical linear codes C_1 and C_2 of the same length n, satisfying the nesting condition

Now build the stabilizer generators in two families, from two parity-check matrices:

• Z-type stabilizers — take each row of H(C_1) and turn its 1s into Z operators. Because Z anticommutes with X, these checks light up for bit-flip (X) errors, and their measured syndrome is exactly the classical C_1 syndrome.
• X-type stabilizers — take each row of H(C_2^{\perp}) and turn its 1s into X operators. Since X anticommutes with Z, these catch phase-flip (Z) errors.

Why the nesting? A stabilizer group must be commuting. An X-type generator from a vector u and a Z-type generator from a vector v commute precisely when they overlap in an even number of places, i.e. u \cdot v = 0 \pmod 2. Requiring every such pair to commute is exactly the statement C_2^{\perp} \subset C_1 — the nesting condition is the commutation condition. The code encodes k = \dim C_1 - \dim C_2 logical qubits in n physical ones.

Naming the two check families (mind the convention)

A tiny but perennial source of confusion. A stabilizer built from Z operators catches X errors — so some texts call it an "X-check" (named for the error it catches) while others call it a "Z-type stabilizer" (named for the Paulis it is made of). Both describe the same operator. The physics is unambiguous and worth memorising once:

Whenever you read "the X checks," pause and ask whether the author means made of X or catches X. On this page we always name a stabilizer by the Paulis it is built from.

Worked example 1: the Steane code [[7,1,3]]

The Steane code is CSS at its most elegant. Start with the classical [7,4,3] Hamming code, whose parity-check matrix has as its columns the binary numbers 1 through 7:

This code is special: it contains its own dual, C^{\perp} \subset C. So we may take C_1 = C and C_2 = C^{\perp}; the nesting condition holds automatically. Even better, the same matrix H serves for both families, so the six stabilizer generators are the three rows of H read once as X strings and once as Z strings:

Count the parameters. There are n = 7 physical qubits and 6 independent generators, leaving k = 7 - 6 = 1 logical qubit; the code distance is d = 3, enough to correct any single-qubit error. In the standard bracket notation that is [[7,1,3]] — the inner brackets flagging that it is a quantum code. (As a bonus the Steane code has transversal Clifford gates: a logical H, S or CNOT is just the physical gate applied qubit-by-qubit — a gift of the code's symmetry.)

The stabilizer tableau

Here are all six generators laid out over the seven qubits. Notice the two families share the identical pattern of columns — that is the Hamming matrix appearing twice, once in each Pauli flavour. Step through to reveal the X-type block, then the Z-type block.

Any two rows overlap in an even number of qubits (check S_1 and S_2: they share qubits 3 and 7), so every X-row commutes with every Z-row — the nesting condition, visible in the picture.

Worked example 2: the syndrome points straight at the error

Suppose a single bit-flip X_5 strikes qubit 5. Measure the three Z-type stabilizers. Each returns -1 (syndrome bit 1) exactly when it anticommutes with the error — that is, when its qubit set contains qubit 5:

• S_1^{Z} = Z_1 Z_3 Z_5 Z_7 touches qubit 5 → 1.
• S_2^{Z} = Z_2 Z_3 Z_6 Z_7 does not → 0.
• S_3^{Z} = Z_4 Z_5 Z_6 Z_7 touches qubit 5 → 1.

The syndrome is (s_1, s_2, s_3) = (1, 0, 1). Read as a binary number with s_1 the ones place, s_2 the twos and s_3 the fours:

The syndrome is the binary address of the flipped qubit — because it equals H e_5, the fifth column of H, which by construction is the binary numeral for 5. This is precisely the classical Hamming decoder, imported wholesale: apply X_5 again to undo the error and the qubit is repaired. Phase-flips are handled by the mirror-image computation on the X-type checks, and a Y = iXZ error simply lights up both families at once. Bit-flips and phase-flips, corrected on two independent channels.

The idea in one box