The Clifford Group

The Clifford group is the workhorse of fault-tolerant computing: a large, structured family of gates that most error-correcting codes can implement transversally (cheaply). Understanding it precisely tells us both what we get for free and — crucially — what we are still missing.

The Pauli group first

On $n$ qubits the Pauli group $\mathcal{P}_n$ consists of tensor products of $I, X, Y, Z$ together with overall phases $\{\pm 1, \pm i\}$ . For one qubit,

\mathcal{P}_1 = \{\, \pm 1, \pm i \,\} \times \{ I, X, Y, Z \}.

Paulis are the natural language of errors: a single-qubit error can be expanded in the Pauli basis, so correcting $X$ , $Y$ , and $Z$ on each qubit corrects any single-qubit error.

The Clifford group as a normalizer

The Clifford group $\mathcal{C}_n$ is defined as the normalizer of the Pauli group inside the unitary group: the set of unitaries $U$ that map Paulis to Paulis under conjugation,

U P U^\dagger \in \mathcal{P}_n \quad \text{for every } P \in \mathcal{P}_n .

In words: a Clifford unitary may shuffle and combine Pauli operators, but it never turns a Pauli into something outside the Pauli group. This is exactly the property that lets us track errors classically as they pass through a Clifford circuit (the Gottesman–Knill theorem, next lesson).

Generators

Remarkably, the entire (multi-qubit) Clifford group is generated by just three gates:

\boxed{\; H, \quad S, \quad \mathrm{CNOT} \;}

where $S = \mathrm{diag}(1, i)$ is the phase gate. Every Clifford operation is a product of these. Their conjugation action on Paulis is what makes them Clifford:

| Gate | $X \mapsto$ | $Z \mapsto$ | |------|-------------|-------------| | $H$ | $Z$ | $X$ | | $S$ | $Y$ | $Z$ | | CNOT | $X_c X_t \leftarrow X_c$ ; ... | $Z_t \leftarrow Z_t Z_c$ ; ... |

The single-qubit Cliffords are exactly the 24 rotations that permute the six Bloch-sphere axis points $\{\pm X, \pm Y, \pm Z\}$ — the symmetry group of the octahedron.

A worked conjugation

Because $H$ swaps the $X$ and $Z$ axes, conjugating $Z$ by $H$ gives $X$ :

H Z H = X .

This is not just an algebraic curiosity — it is the recipe for measuring in the $X$ basis using a $Z$ -basis measurement, and it shows how a Clifford word built from generators reproduces another Pauli. The exercise asks you to build $H Z H$ and confirm it equals $X$ .

Why we care

Transversality. For codes like the surface code and many CSS codes, Clifford gates (or their logical analogues) are implementable transversally or by other cheap fault-tolerant means.
Classical simulability. Clifford circuits on stabilizer inputs can be simulated efficiently on a classical computer — both a gift (error tracking) and a warning (no quantum speedup from Cliffords alone).
A foundation to extend. A single non-Clifford gate — the $T$ gate — added to this group yields universality, which is the subject of the next several lessons.

Try it

Construct the Clifford word $H Z H$ on one qubit. The grader checks the full unitary (up to global phase); it should equal the Pauli $X$ .

Run your code to see the quantum state.