Measuring Stabilizers

A stabilizer code protects information without ever directly measuring the data. Instead we measure the stabilizer generators. Each measurement returns a $\pm 1$ eigenvalue, and the pattern of results — the syndrome — tells us which error occurred, while leaving the encoded state intact.

Why measure stabilizers and not the data

Measuring a data qubit in the computational basis would collapse the superposition we are trying to protect. The trick of quantum error correction is to measure operators that commute with the encoded information and whose eigenvalues reveal only the error. The stabilizer generators are exactly such operators: they act as $+1$ on the codespace, so on an error-free state they return $+1$ and disturb nothing. An error $E$ shifts the eigenvalue of any generator it anticommutes with to $-1$, flagging the error without exposing the logical state.

The syndrome

For a code with generators $g_1, \dots, g_r$ and an error $E$ acting on a codeword $|\psi\rangle$,

with the sign equal to $+1$ if $g_i$ and $E$ commute and $-1$ if they anticommute. The syndrome is the bit string

It is a function of the error alone, not of $|\psi\rangle$. Different correctable errors produce different syndromes, and a decoder maps the syndrome back to a recovery operation.

Measuring a stabilizer with an ancilla

We extract one syndrome bit per generator using an ancilla qubit. The standard circuit for a $Z$-type parity $Z_a Z_b$ is:

1. Prepare an ancilla in $|0\rangle$.
2. Apply $\mathrm{CNOT}$ from data qubit $a$ to the ancilla, then from $b$ to the ancilla.
3. Measure the ancilla in the computational basis.

Each CNOT XORs a data bit into the ancilla, so after both the ancilla holds the parity $q_a \oplus q_b$ — outcome $0$ means eigenvalue $+1$, outcome $1$ means $-1$. Crucially, because the ancilla is controlled by the data, it learns only the parity, never the individual bit values, so the encoded superposition survives. ($X$-type stabilizers are measured the same way after conjugating the ancilla with Hadamards, or equivalently using the ancilla as the control.)

A worked example: the bit-flip code

The three-qubit bit-flip code has stabilizers $g_1 = Z_0 Z_1$ and $g_2 = Z_1 Z_2$. The four single-qubit bit-flip errors give the syndromes:

| Error | Anticommutes with | Syndrome $(s_1, s_2)$ | | --- | --- | --- | | none | — | $(0,0)$ | | $X_0$ | $g_1$ | $(1,0)$ | | $X_1$ | $g_1, g_2$ | $(1,1)$ | | $X_2$ | $g_2$ | $(0,1)$ |

Every distinct correctable error has a distinct syndrome, so the decoder simply inverts the table: syndrome $(1,1)$ means "flip qubit 1." This is the discrete, classical core of error correction.

Try it

Encode $|0_L\rangle = |000\rangle$, inject a bit-flip $X$ on data qubit $1$, then measure both stabilizers $Z_0 Z_1$ and $Z_1 Z_2$ onto two ancillas. Read out the syndrome — it should be $11$.

Sign in on the full site to ask questions and join the discussion.