Logical Operators in Stabilizer Codes

A stabilizer code reserves some of its Hilbert space for logical information. The operators that act on that protected qubit — the logical $\bar X$ and $\bar Z$ — are themselves Pauli strings, but special ones. This lesson shows how to find them directly from the stabilizer, using the same symplectic algebra we have been building.

Three nested groups

The structure rests on three subgroups of $\mathcal{P}_n$:

1. The stabilizer $S = \langle g_1, \dots, g_{n-k}\rangle$, the operators that act as identity on the codespace.
2. The normalizer $N(S)$ — the Paulis that commute with every element of $S$. (For Pauli subgroups the normalizer equals the centralizer, since two Paulis either commute or anticommute.)
3. Inside $N(S)$, the stabilizer $S$ itself.

An operator in $N(S)$ commutes with all stabilizers, so it maps the codespace to itself. If it also lies in $S$, it acts trivially (as $+1$). The interesting operators are therefore those in $N(S)$ but not in $S$.

Definition of logical operators

A logical operator is a Pauli $L \in N(S) \setminus S$: it commutes with every stabilizer generator (preserving the codespace) but is not itself a product of stabilizers (so it acts non-trivially on the logical qubits).

Counting dimensions: $S$ has $n-k$ independent generators, $N(S)$ has $n+k$, so the quotient $N(S)/S$ has $2k$ independent generators. These pair up into $k$ logical $\bar X$'s and $k$ logical $\bar Z$'s. They must satisfy the same Pauli algebra as bare qubits:

i.e. $\bar X_i$ anticommutes with its partner $\bar Z_i$ and commutes with all other logical operators and all stabilizers.

Finding them in practice

To construct logical operators from the check matrix:

1. Find Paulis whose binary vectors are symplectically orthogonal to every stabilizer row — these span $N(S)$.
2. Discard those already in the row space of the check matrix — these are in $S$.
3. From the remainder, choose representatives $\bar X_i, \bar Z_i$ obeying the canonical (anti)commutation relations. This is a linear-algebra problem over $\mathbb{F}_2$.

Logical operators are defined only up to multiplication by a stabilizer: $L$ and $Lg$ (for $g \in S$) act identically on the codespace, so we are free to pick the lowest-weight representative. The minimum weight over all logical operators is the code distance $d$.

Example: the bit-flip code

The three-qubit bit-flip code has $S = \langle Z_0 Z_1,\ Z_1 Z_2\rangle$, so $n=3$, $k=1$. Candidate logical operators:

• $\bar Z = Z_0$ (equivalently $Z_1$ or $Z_2$, since they differ by a stabilizer): all-$Z$, so it commutes with both $Z$-stabilizers; it is not a product of them, so it is a genuine logical.
• $\bar X = X_0 X_1 X_2$: it overlaps each weight-2 $Z$-stabilizer in two positions, so it commutes with both; it is not in $S$.

These two anticommute (they overlap only at qubit $0$, an $X$-meets-$Z$ position), realizing the logical qubit's $\bar X$, $\bar Z$ algebra. The distance is $d = 1$ here ($\bar Z = Z_0$ has weight 1) — this code corrects bit flips but not phase flips, as expected.

Try it

Using the symplectic inner product, verify that $\bar X = X_0 X_1 X_2$ and $\bar Z = Z_0$ are valid logical operators of the bit-flip code: both commute with the stabilizers $Z_0 Z_1$ and $Z_1 Z_2$, and they anticommute with each other.

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