Clifford gates

Clifford gates are unitaries that map Pauli operators to Pauli operators under conjugation: if $C$ is Clifford and $P$ is a Pauli, then $C P C^\dagger$ is also a Pauli (up to global phase). This closure property partitions quantum gates into two classes with profound consequences for simulation, error correction, and the boundary between classical and quantum advantage. Clifford-only circuits are efficiently simulatable classically; adding even one non-Clifford gate requires exponential resources.

• Pauli gates (I, X, Y, Z): self-inverse; map qubits between orthogonal bases
• Hadamard (H): basis rotation; swaps $X \leftrightarrow Z$: $HXH = Z$, $HZH = X$
• S gate (phase gate): $\pi/2$ rotation around z-axis; $S = R_Z(\pi/2)$; $S^4 = I$
• S† (inverse phase gate): applies $-\pi/2$ phase; $S^\dagger S = I$
• Other single-qubit Cliffords: $(H S)^3 = I$ and its powers generate up to 24 distinct single-qubit Cliffords

• CX (Controlled-NOT): controlled NOT; entangling gate; maps $X \otimes I \to X \otimes X$, $I \otimes Z \to I \otimes Z$
• CZ: controlled Z; maps $Z \otimes I \to Z \otimes Z$, $I \otimes X \to I \otimes X$
• SWAP: exchanges two qubits; $\mathrm{SWAP} = (\mathrm{CNOT})^3$ (up to circuit depth)
• iSWAP: sometimes non-Clifford depending on normalization

Key single-qubit Clifford matrices:

$$H = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} \quad S = \begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix}$$

CNOT in computational basis:

$$\mathrm{CNOT} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix}$$

The defining property of Cliffords is how they conjugate Pauli operators. Examples:

• $H X H = Z$, $H Z H = X$ (H swaps X and Z)
• $S X S^\dagger = Y$, $S Z S^\dagger = Z$ (S maps X to Y)
• $\mathrm{CNOT} \cdot (X \otimes I) \cdot \mathrm{CNOT} = X \otimes X$
• $\mathrm{CNOT} \cdot (I \otimes Z) \cdot \mathrm{CNOT} = I \otimes Z$

In general, if $P$ is Pauli and $C$ is Clifford, then $C P C^\dagger = e^{i\phi} P'$ where $P'$ is also Pauli and $\phi$ is a global phase.

Non-Clifford gates (like the T gate) do NOT preserve the Pauli group under conjugation:

$$T X T^\dagger = \frac{1}{\sqrt{2}}(X + Y), \quad T Z T^\dagger = Z$$

The result $\frac{1}{\sqrt{2}}(X + Y)$ is not Pauli, breaking the closure property. This small addition enables universal quantum computation but requires expensive resource overhead in fault-tolerant systems.

Clifford gates permute the basis directions on the Bloch sphere:

• H: swaps x and z axes (basis rotation by 90° around y)
• S: leaves z unchanged, rotates x → y (phase rotation)
• Paulis: 180° rotations around x, y, z axes
• CNOT: on the second qubit, applies different rotations depending on first qubit state

Clifford circuits thus act as Bloch sphere symmetries, never creating superpositions in Pauli bases.

The Clifford group $\mathcal{C}_n$ on $n$ qubits has size:

$$|\mathcal{C}_1| = 24 \quad (2^4 \cdot 3, \text{ single-qubit Cliffords})$$ $$|\mathcal{C}_2| = 11,520 \quad (\text{two-qubit Cliffords})$$ $$|\mathcal{C}_n| = 2^{n(n+1)} \prod_{k=1}^{n} (4^k - 1) / (4 - 1)$$

Generation: Any Clifford can be decomposed into H, S, and CNOT gates (generators). The group is finite but grows rapidly with qubit count.

• State preparation: Clifford circuits prepare stabilizer states from computational basis; deterministic outcome
• Quantum error correction: Syndrome measurements and logical operations in stabilizer codes (surface codes, toric codes)
• Stabilizer codes and error detection: Measure stabilizer eigenvalues without collapsing encoded information
• Circuit verification: Clifford-only circuits are efficiently verifiable classically (useful for debugging)
• Simulation: Classical simulators (stabilizer tableau method) run ~1000-qubit Clifford circuits in seconds
• Basis rotation: Prepare for measurement in different bases (e.g., H before Z measurement gives X basis measurement)

Quantum algorithms decompose into a Clifford base layer plus non-Clifford gates (usually T). The T-count (number of T gates) is the primary cost metric in fault-tolerant quantum computing because:

• Clifford gates: nearly “free” (polynomial overhead, tableau simulation)
• T gates: expensive (magic state distillation required, ~100-1000 physical qubits per logical T)

Quantum compilers minimize T-count through circuit optimization. A single T gate nested in a Clifford circuit costs orders of magnitude more than the Clifford layer.

• Superconducting qubits: Hadamard ~10-50 ns; S ~<1 ns (virtual); CNOT ~20-100 ns (longer than single-qubit gates)
• Trapped ions: Single-qubit Cliffords ~1-5 μs via laser; CNOT slower (~100 μs)
• Photonic: Clifford gates via beam splitters, polarization rotators; fidelity ~99%
• Fidelity: Clifford gate fidelity typically 99-99.9%; errors primarily limit circuit depth before T gates

• Pauli gates: special case of Cliffords; map Paulis to Paulis trivially
• Hadamard (H), Phase gates (S, S†): fundamental single-qubit Cliffords
• CX, CZ, SWAP: fundamental two-qubit Cliffords
• T gate: non-Clifford; enables universal computation but expensive in fault tolerance
• Rotation gates: S gate is $R_Z(\pi/2)$; most rotations are non-Clifford except at special angles
• Stabilizer formalism: theoretical framework built on Clifford conjugation property
• Single-qubit gates: Cliffords are subset of $\mathrm{SU}(2)$
• Error correction: stabilizer codes, surface codes, toric codes use Clifford stabilizer measurements