Pauli Group and Stabilizers

When Daniel Gottesman wrote his 1997 PhD thesis at Caltech, he was looking at Shor's 9-qubit code, Steane's 7-qubit code, and the two 3-qubit codes that preceded them (bit-flip and phase-flip), and noticed something. Every one of these codes defines its "correct" states by demanding that certain Pauli operators leave them unchanged: the bit-flip code demands Z_0Z_1|\psi\rangle = |\psi\rangle and Z_0Z_2|\psi\rangle = |\psi\rangle. The syndrome measurement is the measurement of these Pauli operators. The error detection is reading off their eigenvalues. The recovery is a Pauli correction.

Gottesman's thesis made this observation into a framework. He called it the stabilizer formalism. Instead of writing down the code subspace as a span of specific basis states (which becomes unwieldy for large codes), you describe it by listing the Pauli operators that fix it. A list of k commuting Pauli operators on n qubits fixes a 2^{n-k}-dimensional subspace — one logical qubit worth of code space when k = n-1, more when k < n-1.

This turned out to be not just a notational convenience. The stabilizer formalism is the language in which almost every modern quantum error correcting code is written. The Steane code, the surface code, the colour code, LDPC codes, fracton codes, topological codes in general — all are stabilizer codes. The framework gives you a unified syndrome-measurement procedure, a unified distance calculation, a unified logical-operator analysis, and a classical-simulation algorithm (Gottesman-Knill) that handles circuits built from stabilizer gates in polynomial time.

This chapter builds the formalism from the bottom up. You will meet the Pauli group, the abelian-subgroup condition, the stabilized subspace, and then see the bit-flip code, the phase-flip code, and Shor's 9-qubit code rewritten as stabilizer codes. By the end, you will have a framework that covers essentially every quantum code you will ever need to think about.

The Pauli group on n qubits

Start with one qubit. The Pauli matrices are I, X, Y, Z. Recall the multiplication rules:

Why the factors of \pm i: these come from the commutation relations [X, Y] = 2iZ etc. Products of two Pauli matrices can pick up a phase of \pm i, so closure of "the group generated by \{X, Y, Z\}" requires including the phase factors \{\pm 1, \pm i\}.

The Pauli group on one qubit is the group generated by \{X, Y, Z\} under matrix multiplication, closed under the multiplication rules above. The elements are:

Sixteen elements total — four Pauli's times four phase factors \{+1, -1, +i, -i\}.

For n qubits, the Pauli group is the set of tensor products of one-qubit Pauli's, with phase factors:

The group has |\mathcal P_n| = 4 \cdot 4^n = 4^{n+1} elements. For n = 3 qubits (the bit-flip code), this is 4^4 = 256 elements.

Example two-qubit Pauli operators (with identity phase):

• I \otimes I, often written simply I or II.
• X \otimes I, written X_0 (acts as X on qubit 0, identity on qubit 1).
• X \otimes X, written X_0 X_1 or XX.
• Z_0 Z_1 = Z \otimes Z.
• Y_0 Z_1 = Y \otimes Z.

The weight of a Pauli operator is the number of non-identity factors. X_0 \otimes I has weight 1; X_0 X_1 Z_2 has weight 3; identity has weight 0.

Commutation — the defining structural fact

Here is the single most important fact about the Pauli group: any two Pauli operators either commute or anticommute — there is no middle ground.

To see why, take two Pauli operators P = P_1 \otimes \cdots \otimes P_n and Q = Q_1 \otimes \cdots \otimes Q_n. On each qubit i, the single-qubit Pauli's P_i and Q_i either commute ([P_i, Q_i] = 0, which happens when either is I or they are equal) or anticommute (\{P_i, Q_i\} = 0, which happens when they are different non-identity Pauli's, like X_i and Z_i).

For the tensor products, PQ = \prod_i P_i Q_i and QP = \prod_i Q_i P_i, so the ratio is

Why this product is always \pm 1: each factor is either +1 (if P_i, Q_i commute) or -1 (if they anticommute). The product of \pm 1's is \pm 1.

So PQ = \pm QP. If the number of qubits where P and Q anticommute is even, the overall ratio is +1 (they commute). If odd, the ratio is -1 (they anticommute).

Example. X_0 X_1 and Z_0 Z_1: on qubit 0, X and Z anticommute. On qubit 1, same. Two anticommutations, product is +1 → the two operators commute. Check: (X_0 X_1)(Z_0 Z_1) = X Z \otimes X Z = (-iY)(-iY) = -Y \otimes Y = -Y_0 Y_1, and (Z_0 Z_1)(X_0 X_1) = Z X \otimes Z X = (iY)(iY) = -Y_0 Y_1 — same thing. They commute.

Example. X_0 and Z_0: on qubit 0, X and Z anticommute. On all other qubits, both are identity (commute). One anticommutation → overall anticommutation. X_0 Z_0 = -Z_0 X_0. Consistent.

This "commute-or-anticommute dichotomy" is what makes the Pauli group the right setting for error correction. Measurements of Pauli operators produce \pm 1 outcomes (the eigenvalues); the syndrome eigenvalues factor cleanly into "this stabiliser commuted with the error, eigenvalue +1" or "this stabiliser anticommuted with the error, eigenvalue -1". No intermediate eigenvalues to worry about; the error detection is binary.

Stabilizer — an abelian subgroup

The abelian condition is needed because the simultaneous eigenspaces of non-commuting operators are in general empty — you cannot be in a definite eigenstate of two Pauli's that anticommute. The -I exclusion is needed because -I has no +1 eigenvector (its eigenvalues are both -1), and a stabilizer's whole point is to define states fixed with eigenvalue +1.

What a stabilizer stabilizes

Given a stabilizer S with generators g_1, \ldots, g_k, the code subspace \mathcal C is the set of states fixed by every generator:

Equivalently, \mathcal C is the simultaneous +1-eigenspace of all the generators, which (because they commute and are each involutions with eigenvalues \pm 1) has dimension exactly 2^{n-k}:

Why the dimension is 2^{n-k}: each generator splits the 2^n-dimensional Hilbert space into two equal-dimensional eigenspaces (+1 and -1). The intersection of k such splits is 2^n / 2^k = 2^{n-k}. This assumes the generators are independent (no one generator is a product of the others), which is the natural case.

When k = n-1: code dimension is 2^1 = 2, which encodes exactly 1 logical qubit. This is the typical case for the small codes (bit-flip, phase-flip, Shor 9-qubit — n-k = 1 in all of them). When k = n-2: code dimension is 2^2 = 4, encoding 2 logical qubits. Larger codes, like the surface code with many logical qubits, use k < n.

The bit-flip code as a stabilizer code

Now rewrite the 3-qubit bit-flip code in the new language.

Setup. n = 3 physical qubits. Generators of the stabilizer:

Check the stabilizer conditions.

Abelian. Commutator g_1 g_2: on qubit 0, Z \cdot Z = I; on qubit 1, Z \cdot I = Z; on qubit 2, I \cdot Z = Z. So g_1 g_2 = I \otimes Z \otimes Z = Z_1 Z_2. And g_2 g_1: on qubit 0, Z \cdot Z = I; qubit 1, I \cdot Z = Z; qubit 2, Z \cdot I = Z. Same result. Commute. ✓

Does not contain -I. The generators and their products (g_1, g_2, g_1 g_2 = Z_1 Z_2, I) are all ordinary Pauli's with positive phase. No -I. ✓

The stabilizer S = \{I, Z_0Z_1, Z_0Z_2, Z_1Z_2\} has 4 = 2^2 elements.

Identify the code subspace. The code space has dimension 2^{n-k} = 2^{3-2} = 2, so it encodes one logical qubit.

Explicitly: which two-dimensional subspace of the eight-dimensional 3-qubit Hilbert space is simultaneously fixed by Z_0Z_1 and Z_0Z_2?

Apply Z_0 Z_1 to a basis state |abc\rangle (with a, b, c \in \{0, 1\}): eigenvalue is (-1)^{a+b}. For eigenvalue +1, need a = b. Similarly Z_0 Z_2 gives eigenvalue (-1)^{a+c} and requires a = c. Both together: a = b = c. So |000\rangle and |111\rangle are the two computational-basis states in the code subspace.

Exactly the encoded logical basis of the bit-flip code. The stabilizer formalism recovers the same code.

Logical operators

Once you have a stabilizer code, you need operations that act on the logical qubits — things that take the encoded |0\rangle_L to |1\rangle_L and back. These are the logical operators.

A logical Pauli operator \bar P is a Pauli operator on the physical qubits that:

1. Commutes with every stabilizer generator (otherwise it would map the code subspace out of itself).
2. Is not itself in the stabilizer (otherwise it would act as the identity on the code subspace).

For the bit-flip code:

• Z_L = Z_0. Check commutation with g_1 = Z_0 Z_1: both start with Z_0, and Z_0 \cdot Z_0 = I, so Z_L g_1 = Z_1 = g_1 Z_L. Commute. Similarly for g_2. Not in S (which has only 4 elements, none equal to Z_0). Action on code: Z_0|000\rangle = |000\rangle, Z_0|111\rangle = -|111\rangle. So Z_L|0\rangle_L = |0\rangle_L, Z_L|1\rangle_L = -|1\rangle_L — the logical Z action. ✓

• X_L = X_0 X_1 X_2. Check commutation with g_1 = Z_0 Z_1: on qubits 0, 1, we have XZ vs ZX — anticommute on each. Two anticommutations = even = commute overall. ✓. Not in S. Action: X_0X_1X_2|000\rangle = |111\rangle and X_0X_1X_2|111\rangle = |000\rangle — logical bit flip. ✓

Logical operators are not unique. Z_L = Z_1 and Z_L = Z_2 would also work (check: they commute with g_1, g_2 and act as logical Z on the code). Two different physical Pauli's are "the same logical operator" if they differ by a stabilizer element — and indeed, Z_0 \cdot Z_0 Z_1 = Z_1, so Z_0 and Z_1 are equivalent up to the stabilizer Z_0 Z_1.

The weight of a logical operator (minimum over all equivalent choices) is connected to the code's distance. The bit-flip code's logical Z has minimum weight 1 (just Z_0), so the code has distance 1 in the Z direction — it can detect zero Z errors. The logical X has minimum weight 3 (X_0X_1X_2), so it can handle two X errors before the logical operator is triggered by accident. The distance of the code is the minimum of these two, which is 1 — consistent with the bit-flip code being blind to Z errors (hence why Shor concatenated it with a phase-flip code).

The phase-flip code as a stabilizer code

Run the same exercise for the phase-flip code.

Generators. g_1 = X_0 X_1, g_2 = X_0 X_2.

Check. Both are products of X's; they commute with each other because the number of qubits on which X appears in both is 1, but X commutes with X, so the count of anticommutations is zero (even). ✓. Not -I. ✓.

Code subspace. Simultaneous +1-eigenspace of X_0X_1 and X_0X_2. Recall X|+\rangle = |+\rangle, X|-\rangle = -|-\rangle. Eigenvalue of X_0X_1 on |s_0 s_1 s_2\rangle (where each s_i \in \{+, -\}) is (-1)^{[s_0 = -] + [s_1 = -]}. For eigenvalue +1, parity must be even: s_0 = s_1. Similarly s_0 = s_2. So s_0 = s_1 = s_2, and the code states are |{+}{+}{+}\rangle and |{-}{-}{-}\rangle.

Exact match with the phase-flip code's encoded basis.

Logical operators. X_L = X_0 (commutes with both generators because X_0^2 = I in each product; not in S). Z_L = Z_0 Z_1 Z_2 (commutes because three anticommutations with X_0X_1 = odd... wait, let me recount: Z_0 Z_1 Z_2 anticommutes with X_0 X_1 on qubits 0 and 1, which is two anticommutations, even → commute ✓). The roles of X and Z are swapped compared to the bit-flip code, as expected — phase-flip is the Hadamard-conjugate of bit-flip.

Shor's 9-qubit code as a stabilizer code

Now the main event. Shor's 9-qubit code has n = 9 physical qubits encoding k = 1 logical qubit, so n - k = 8 stabilizer generators.

From the analysis in shor-9-qubit-code, the generators are:

Six inner stabilizers (bit-flip-type, one pair per block of three):

Two outer stabilizers (phase-flip-type, spanning blocks):

Check abelian. The inner generators all commute among themselves (pairs of ZZ factors always commute with each other, since Z's commute with each other and with I). The outer generators commute with each other (both are products of X's; X's commute with X's).

The interesting check is inner-outer commutation. Take g_1 = Z_1 Z_2 and g_7 = X_1 X_2 X_3 X_4 X_5 X_6. On qubit 1, Z vs X — anticommute. On qubit 2, Z vs X — anticommute. On qubit 3, I vs X — commute. On qubits 4-9, I vs X — commute. Total anticommutations: 2, even. They commute. ✓

Every g_i (inner ZZ) vs every g_j (outer XXXXXX) has exactly 2 qubits on which both act non-trivially, and those 2 qubits give 2 anticommutations (even). So inner-outer pairs always commute.

The 8 generators are all mutually commuting — a valid stabilizer.

Code dimension. 2^{9-8} = 2, one logical qubit. ✓

Logical operators.

Both have minimum weight 3 (taking one choice out of the equivalent options). The distance of Shor's code is 3: it can detect up to 2 errors and correct 1 error in any Pauli direction. This matches the original analysis of Shor's code as a single-error-correcting code.

Worked examples

Common confusions

• "Stabilizer = CSS code." Not the same thing. CSS codes (Calderbank-Shor-Steane) are a special class of stabilizer codes in which every generator is either all-X or all-Z (no mixed X-Z generators). Bit-flip, phase-flip, Shor, and Steane are all CSS codes. But not every stabilizer code is CSS: the 5-qubit perfect code has generators like XZZXI that mix X and Z, making it a non-CSS stabilizer code. The stabilizer framework is strictly broader than CSS.

• "An abelian group means commutative multiplication between all Pauli operators." No. The stabilizer is a subgroup where internal multiplication is commutative. Outside the subgroup, Pauli operators may anticommute with stabilizer elements — and indeed they must, if they are to flag errors as syndromes. The point is: elements within S commute with each other; elements outside S may or may not.

• "The stabilizer determines the code, not the other way around." Both directions work. Given a stabilizer S, the code subspace is determined: it is the simultaneous +1-eigenspace. Given a code subspace \mathcal C, the stabilizer is determined: it is the group of Pauli's fixing every state in \mathcal C. The correspondence is one-to-one.

• "Stabilizer codes are exponentially powerful because they encode exponentially many states." No — the code space of an [[n, k, d]] stabilizer code has dimension 2^k, not 2^n. A stabilizer code compresses the Hilbert space: a [[9, 1, 3]] code (Shor) gives you only 2^1 = 2 logical states from 2^9 = 512 physical states. The "power" of stabilizer codes is in their error-correction capability and their efficient classical description (polylog space), not in state-space size.

• "Gottesman-Knill means quantum computing is not faster than classical." No, it means stabilizer circuits are classically simulable in polynomial time. Universal quantum computation requires going outside the stabilizer set — for example, by adding the T gate (a non-Clifford gate). Non-Clifford gates like T push you out of the stabilizer formalism and into the regime where classical simulation becomes hard. Shor's algorithm, Grover's algorithm, and quantum simulation all use non-Clifford gates somewhere; stabilizer circuits alone are not universal.

Going deeper

The symplectic vector space structure

Pauli operators on n qubits have a beautiful binary-vector representation. Encode each single-qubit Pauli as a pair of bits:

A multi-qubit Pauli is a 2n-bit vector: the first n bits encode "does qubit i have an X-part?" and the next n encode "Z-part?". Example: X_0 Z_1 = X \otimes Z on 2 qubits becomes (1, 0 \,|\, 0, 1) \in \mathbb F_2^4.

Multiplication of Pauli's corresponds to addition mod 2 of their binary vectors. Commutation of two Pauli's P, Q with binary vectors (a, b) and (c, d) is given by the symplectic inner product:

If \omega = 0, they commute; if \omega = 1, they anticommute.

The stabilizer's condition "every pair of generators commutes" becomes "every pair of binary vectors has symplectic inner product 0", which is a linear condition in binary linear algebra. This turns the whole stabilizer-code theory into binary-code theory — the same algebra you might have encountered for classical error-correcting codes, specifically self-orthogonal codes over \mathbb F_2 with respect to the symplectic form.

The Gottesman-Knill theorem (below) is a direct consequence: stabilizer operations correspond to linear algebra over \mathbb F_2, which is solvable in polynomial time on a classical computer.

The Gottesman-Knill theorem — classical simulation of stabilizer circuits

Theorem. A quantum circuit composed of:

• Initialisation of qubits in computational basis states,
• Gates from the Clifford group (generated by Hadamard H, phase gate S, and CNOT),
• Measurement in the computational basis,

can be simulated on a classical computer in polynomial time in the number of qubits.

The proof uses the symplectic representation. The Clifford group is exactly the group of unitaries that map Pauli's to Pauli's under conjugation: U P U^\dagger is another Pauli operator (possibly with a sign) for every Pauli P and every Clifford U. Starting from a stabilizer state (a +1-eigenstate of some stabilizer), applying a Clifford, and measuring a Pauli — all three steps can be tracked by updating the binary-vector representation of the stabilizer.

Cost of simulation. Updating the stabilizer for a single Clifford gate is O(n) (modify O(n) generator vectors with O(n) binary operations each). A measurement is O(n^2) (solve a linear system). A full circuit with T Clifford gates and M measurements costs O(Tn + Mn^2) classically — polynomial, fast.

Going beyond stabilizer — T gates, magic states, and universality

The Clifford group is not universal for quantum computation. You can compute everything within the Clifford set classically. The set becomes universal only when you add a non-Clifford gate — the most common choice being the T gate (the \pi/8 gate):

T does not map Pauli's to Pauli's; it takes X \to e^{i\pi/4}(I + X)/2 \cdot \text{something}, which is not in the stabilizer formalism. Adding T gates to Clifford gates gives you universal quantum computation — with the cost that simulation becomes exponentially hard (in the number of T gates).

For fault-tolerant quantum computing, the leading technique is magic-state distillation: prepare high-fidelity copies of the T-gate "magic state" |T\rangle = (|0\rangle + e^{i\pi/4}|1\rangle)/\sqrt 2 using only Clifford operations (which the stabilizer codes can do transversally), then "inject" the magic state to execute a logical T gate. This keeps the computation fault-tolerant because every step except the magic-state preparation (which is done separately and heavily protected) stays within the Clifford-plus-stabilizer framework.

Quotient group and the physical meaning of \mathcal P_n / \text{center}

The center of the Pauli group is \{\pm I, \pm iI\} — the phase factors themselves. These multiply every Pauli by a global phase and do not affect its action on states. Modding out by the center gives the quotient group \mathcal P_n / Z(\mathcal P_n), which has 4^n elements — one per "physically distinct" multi-qubit Pauli operator.

This quotient is an abelian group (actually \mathbb F_2^{2n}, the binary symplectic space of the previous section). The stabilizer is a subspace of this quotient, and its commutation condition becomes the symplectic self-orthogonality we wrote above.

The quotient structure is why stabilizer codes have such clean algebraic properties. All of Gottesman's results, including the Gottesman-Knill theorem, flow from the fact that the symplectic space is a finite-dimensional vector space over \mathbb F_2 — a setting where linear algebra does the work.

Stabilizer codes in Indian quantum research

The National Quantum Mission (2023, ₹6000 crore) has fault-tolerant quantum computing as one of four major thrust areas. Indian research on stabilizer codes and their applications:

• TIFR Mumbai — theoretical and NMR-experimental work on stabilizer codes, including implementations of the 5-qubit and 7-qubit codes on NMR processors dating back to the 2000s.
• IIT Madras — quantum information group with work on CSS codes, stabilizer codes, and LDPC codes.
• IISc Bangalore — ongoing work on fault-tolerant protocols, including magic-state distillation and surface-code resource estimation.
• IIT Delhi, IIT Bombay — contributing to NQM's error-correction working group on stabilizer-formalism codes.

The stabilizer formalism is the common language; almost every quantum computing research group globally and in India speaks it. Understanding the material in this chapter is enough to read the current fault-tolerance literature, including the proposals for logical-qubit benchmarks that several Indian groups are pursuing in collaboration with international partners.

Beyond stabilizer — subsystem codes, bosonic codes, fracton codes

The stabilizer formalism covers the vast majority of quantum codes, but there are generalisations:

• Subsystem codes (Kribs-Poulin-LaFlamme, 2005): introduce "gauge" qubits that are neither data nor syndrome; the stabilizer becomes a non-abelian group. Useful for simpler syndrome circuits (as in the Bacon-Shor code).
• Bosonic codes (cat codes, GKP codes): encode logical qubits in continuous-variable systems (harmonic oscillators), using a different algebra than finite-dimensional Pauli's. These are increasingly important for superconducting-qubit and photonic platforms.
• Fracton codes: exotic topological codes with restricted mobility of excitations, used in condensed-matter physics and quantum memory research. The stabilizer formalism extends but requires 3D or higher-dimensional lattices.

These are all stabilizer codes in a suitable generalised sense, and all of them inherit the commute-or-anticommute algebra that is the foundation of this chapter.

Where this leads next

• Pauli X, Y, Z — the single-qubit Pauli's that generate the Pauli group.
• Shor 9-qubit code — the 8-generator stabilizer code worked out above in algebraic form.
• Bit-flip code and Phase-flip code — the two simplest stabilizer codes.
• Stabilizer codes generally — the next chapter, developing [[n, k, d]] notation and the general theory.
• Five-qubit perfect code — the smallest non-CSS stabilizer code, with all X-Z mixed generators.
• CSS codes — the special stabilizer codes whose generators split cleanly into all-X and all-Z sets.

References

1. Daniel Gottesman, Stabilizer codes and quantum error correction (PhD thesis, 1997) — arXiv:quant-ph/9705052. The thesis that introduced the stabilizer formalism and the Gottesman-Knill theorem. The primary reference for this chapter.
2. Nielsen and Chuang, Quantum Computation and Quantum Information (2010), §10.5 (stabilizer codes) — Cambridge University Press. Standard textbook presentation.
3. John Preskill, Lecture Notes on Quantum Computation, Chapter 7 — theory.caltech.edu/~preskill/ph229. Pedagogical derivation of the stabilizer formalism and its use in QEC.
4. Wikipedia, Stabilizer code — accessible overview with the binary symplectic representation and examples.
5. Wikipedia, Pauli group — formal definition of the Pauli group on n qubits and its structure.
6. Wikipedia, Gottesman–Knill theorem — classical simulation of stabilizer circuits in polynomial time.