stabiliser code

In plain terms

Writing down a quantum code by listing its encoded states gets hopeless quickly, as the states live in a space whose size doubles with every qubit. Stabiliser codes describe the code the other way round, by the questions that don't disturb it.

Pick a set of measurements, each one a pattern of bit flips and phase flips across the qubits, chosen so that any two of them can be performed in either order without affecting each other. The code is then everything those measurements always answer yes to. Nothing about the encoded information is revealed by asking, as the answer is known in advance, which is the property that makes the checks safe to repeat as often as you like.

Damage shows up as a change of answer. An error that anticommutes with one of the checks, meaning the two operations disagree about their order, flips that check's answer, and the pattern of flipped answers names the error. So the whole business of diagnosis reduces to solving a small system of equations over the numbers zero and one, and the same arithmetic tells you how many qubits the code protects: each independent check halves the space, so the encoded capacity is what's left.

In CSD

The corpus builds the stabiliser layer over its own Pauli algebra and indexes a family by binary labels directly, with a sign function subject to one coherence law. That law is exactly the condition that the signed operators form a genuine group with the identity's negative left out, and commutativity then follows rather than being assumed, which is a small saving that pays for itself in every downstream instance.

Four results carry the layer. The group average over the family is a projector, every member fixes it, its trace counts the encoded dimension, and a state the whole group fixes exists. The dimension count is upgraded from a trace to a rank, so a full set of checks pins the state uniquely up to a scalar. The measurement rules come next: a check already in the group has a deterministic answer, a check that anticommutes with a group element gives each answer with probability one half, and the state after the measurement is stabilised by the check itself together with everything commuting with it. The Steane code is the first genuine instance, and the Shor code and the Gottesman-Knill simulation both live on this layer.

Mathematically

A stabiliser family is a pair of linear label maps A and B from the m-dimensional binary vector space to the n-dimensional one, with a sign function sigma satisfying sigma(x + y) = sigma(x) + sigma(y) + B(x) dot A(y). That coherence law is the phase of the Pauli product rule, so the signed operators chi(sigma x) X^(A x) Z^(B x) close into a group without -1; coherence at (x, y) and at (y, x) forces the symplectic form of any two members to vanish (stab_symp_zero).

The group average P = 2^(-m) sum over x of chi(sigma x) X^(A x) Z^(B x) absorbs every member (one reindex y to x + y), is idempotent, and has trace 2^n / 2^m for independent labels. stabProjector_rank identifies P with a linear projection onto its range, so Mathlib's rank-equals-trace for projections gives dimension 2^(n - m) for the code space, and uniqueness up to scalar when m = n (stabState_unique). The measurement section proves that the outcome is fixed (meas_deterministic), vanishing expectation and probability one half against an anticommuting element (meas_expectation_zero, meas_prob_half), and the update rules (pauliOp_measProj, meas_update_fixes). No measurement dynamics is claimed; the Born weights here are bookkeeping on the coordinate operators.

The name

Daniel Gottesman introduced the stabiliser formalism in his 1997 Caltech thesis, where it appeared as a way to handle codes whose descriptions had become unmanageable, and it has been the standard language of quantum error correction since. The word stabiliser is borrowed from group theory, where the stabiliser of a point is the set of group elements that fix it.

Robert Calderbank, Peter Shor and Andrew Steane had already built the subfamily now called CSS codes, which take a classical code and use it twice, and Gottesman's formalism explained what those constructions had in common with everything else.

Related entries

• Steane codeSeven qubits protect one, as the Steane code was the first to correct any single- qubit error by using the same classical Hamming code twice, once for bit flips and once for phase flips.
• Shor codeShor's nine-qubit code was the first proof that quantum information can be protected against any error on any single qubit without ever being read, and the corpus verifies that protection as explicit constructed operations, including the subtle case where two different errors share one repair.
• Gottesman-Knill theoremThe Gottesman-Knill theorem marks the boundary of quantum advantage, as circuits built from the Clifford gates can be simulated classically, because in the right picture they're nothing more than linear algebra on bits.
• Pauli matricesThree small matrices carry the entire two-level world, and their refusal to commute is the uncertainty principle in its smallest packaging.
• Knill-Laflamme conditionsQuantum error correction has an exact test, as a set of errors is correctable if and only if the code can't tell those errors apart, and that condition is a piece of algebra you can check before building any repair.