The Check Matrix

Stabilizer arithmetic is really linear algebra over the two-element field $\mathbb{F}_2$ . The bridge between Pauli operators and binary vectors is the check matrix, and once we cross it, questions about commutation, independence, and code dimension become routine matrix operations.

From Pauli strings to binary vectors

A phase-free Pauli string $P = P_1 \otimes \cdots \otimes P_n$ is encoded by two length- $n$ binary vectors $x = (x_1,\dots,x_n)$ and $z = (z_1,\dots,z_n)$ via the rule

I \mapsto (0,0), \quad X \mapsto (1,0), \quad Z \mapsto (0,1), \quad Y \mapsto (1,1),

read componentwise: $x_j$ flags an $X$ or $Y$ on qubit $j$ , and $z_j$ flags a $Z$ or $Y$ . The single string $P$ becomes the row vector $(x \mid z) \in \mathbb{F}_2^{2n}$ . Multiplying two Paulis (ignoring phase) corresponds to adding their binary vectors mod 2 — exactly what you would expect, since $X\cdot Y = iZ$ has $x,z$ bits $(1,0)+(1,1) = (0,1) \mapsto Z$ .

The check matrix

Stack the binary rows of $r$ stabilizer generators $g_1,\dots,g_r$ into an $r \times 2n$ matrix:

H = \big[\, H_X \;\big|\; H_Z \,\big],

where $H_X$ holds the $x$ -parts and $H_Z$ the $z$ -parts. This is the check matrix of the code. Each row is one generator; each of the $2n$ columns is one $\mathbb{F}_2$ coordinate.

For the three-qubit bit-flip code with $g_1 = Z_0 Z_1$ , $g_2 = Z_1 Z_2$ the check matrix is

H = \left[\begin{array}{ccc|ccc} 0 & 0 & 0 & 1 & 1 & 0 \\ 0 & 0 & 0 & 0 & 1 & 1 \end{array}\right].

The empty left block ( $H_X = 0$ ) tells you the code uses only $Z$ -type stabilizers.

Commutation via the symplectic form

The symplectic inner product of two rows becomes a matrix statement. Define the $2n \times 2n$ symplectic form

\Lambda = \begin{pmatrix} 0 & I_n \\ I_n & 0 \end{pmatrix}.

Then two generators $u = (x^u \mid z^u)$ and $v = (x^v \mid z^v)$ commute iff

u\,\Lambda\,v^{\mathsf T} = x^u\!\cdot z^v + z^u\!\cdot x^v \equiv 0 \pmod 2.

The whole stabilizer is abelian precisely when $H\,\Lambda\,H^{\mathsf T} = 0$ over $\mathbb{F}_2$ . This is a single matrix equation we can check mechanically.

Independence and code dimension

The generators are independent iff the rows of $H$ are linearly independent over $\mathbb{F}_2$ , i.e. $\operatorname{rank}_{\mathbb{F}_2}(H) = r$ . Row reduction (Gaussian elimination with XOR as the "add" operation) computes this rank. For a stabilizer code on $n$ qubits, the number of encoded logical qubits is

k = n - \operatorname{rank}_{\mathbb{F}_2}(H).

Each independent generator removes one degree of freedom, halving the codespace; whatever survives encodes the logical information.

Try it

Build the $4 \times 10$ check matrix of the famous five-qubit perfect code with cyclic generators $XZZXI,\, IXZZX,\, XIXZZ,\, ZXIXZ$ , compute its $\mathbb{F}_2$ rank, and report $k = n - \operatorname{rank}(H)$ . You should find $k = 1$ : the $[[5,1,3]]$ code.

Run your code to see the quantum state.