The Pauli Group

The stabilizer formalism is the language in which most of quantum error correction is written. Before we can describe codes, states, and logical operators with it, we need its alphabet: the Pauli group. Everything in this module is built from this one finite group.

The single-qubit Pauli matrices

Recall the four single-qubit Pauli operators,

I = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix}, \quad X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}, \quad Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}, \quad Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}.

These four matrices are almost closed under multiplication, but not quite. For example $XY = iZ$ , $YX = -iZ$ , and $X^2 = I$ . Products keep generating the phases $\pm 1$ and $\pm i$ . To obtain a genuine group we must adjoin those phases.

The one-qubit Pauli group

Define

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

This set has $4 \times 4 = 16$ elements and is closed under matrix multiplication, so it is a group under the usual operator product. The key structural relations are

X^2 = Y^2 = Z^2 = I, \qquad XY = iZ,\quad YZ = iX,\quad ZX = iY,

with the reversed products picking up the opposite sign, e.g. $YX = -iZ$ . Two single-qubit Paulis therefore either commute or anticommute: $X$ and $Z$ anticommute ( $XZ = -ZX$ ), while any Pauli commutes with itself and with $I$ .

The n-qubit Pauli group

The $n$ -qubit Pauli group $\mathcal{P}_n$ consists of all tensor products of single-qubit Paulis, together with an overall phase:

\mathcal{P}_n = \{\, \alpha\, P_1 \otimes P_2 \otimes \cdots \otimes P_n : \alpha \in \{\pm 1, \pm i\},\ P_j \in \{I, X, Y, Z\} \,\}.

Counting elements: there are $4^n$ choices of the tensor-product string and $4$ choices of phase, so

|\mathcal{P}_n| = 4 \cdot 4^n = 2^{2n+2}.

We routinely abbreviate a tensor product by listing only the non-identity factors with their positions; for instance on three qubits $X_1 Z_3$ means $X \otimes I \otimes Z$ .

Weight, Hermiticity, and order

A few properties recur throughout the module:

Weight. The weight of a Pauli operator is the number of qubits on which it acts non-trivially (i.e. with $X$ , $Y$ , or $Z$ rather than $I$ ). Weight measures how many physical qubits an error touches, so it controls a code's distance.
Hermiticity. With phase $\alpha = +1$ , a Pauli string of the form $P_1 \otimes \cdots \otimes P_n$ is Hermitian and squares to the identity, hence has eigenvalues $\pm 1$ . A phase of $\pm i$ makes the operator anti-Hermitian instead.
Order. Every element of $\mathcal{P}_n$ has order $1$ , $2$ , or $4$ . This finiteness is exactly what makes the formalism computationally efficient later.

Commutation is the whole story

Two Pauli strings $P = P_1 \otimes \cdots \otimes P_n$ and $Q = Q_1 \otimes \cdots \otimes Q_n$ either commute or anticommute. They anticommute precisely when the number of positions $j$ at which $P_j$ and $Q_j$ are different non-identity Paulis (and therefore anticommute locally) is odd:

PQ = (-1)^{c}\, QP, \qquad c = \#\{\, j : P_j Q_j = -Q_j P_j \,\}.

This single $\pm$ relationship is the engine of everything that follows. In the next lessons we will pick commuting subgroups of $\mathcal{P}_n$ — the stabilizer groups — and use them to define quantum states and quantum codes. Because commutation reduces to counting positions mod 2, the entire theory can be carried out with binary linear algebra over $\mathbb{F}_2$ , which is why stabilizer circuits are classically tractable.

The takeaway

The Pauli group $\mathcal{P}_n$ is a finite group of $2^{2n+2}$ operators, generated by tensor products of $I, X, Y, Z$ plus phases $\{\pm 1, \pm i\}$ . Its elements square (up to phase) to the identity, have eigenvalues $\pm 1$ , and pairwise commute or anticommute according to a simple parity rule. This rigid, finite structure is the foundation on which stabilizer states and codes are built.