Logical Operators as Loops

The toric code encodes $k=2$ logical qubits. This lesson identifies the operators that act on them: the logical Pauli operators are string operators wrapped around the noncontractible loops of the torus. A contractible loop is a product of stabilizers and acts trivially; only loops that wind the torus give genuine logical action. The algebra of these logical operators is fixed entirely by how the loops intersect.

Contractible loops are stabilizers

Consider a closed $Z$ -string $W^Z_C = \prod_{e \in C} Z_e$ around a loop $C$ . If $C$ is contractible — the boundary of some region $R$ of faces — then it is exactly the product of the plaquette operators inside $R$ :

W^Z_{\partial R} = \prod_{p \in R} B_p \;\in\; \mathcal{S}.

So a contractible $Z$ -loop is a stabilizer: it acts as $+1$ on the code space and changes nothing. The same holds for contractible $X$ -loops on the dual lattice, which are products of star operators. Only loops that cannot be filled in can act nontrivially.

Noncontractible loops and homology

On a torus there are two independent noncontractible cycles — one winding the "horizontal" direction, one the "vertical". Two loops that differ by a contractible deformation belong to the same homology class; the classes form the first homology group

H_1(T^2;\mathbb{Z}_2) = \mathbb{Z}_2 \times \mathbb{Z}_2 .

Define logical $Z$ operators $\bar Z_1, \bar Z_2$ as $Z$ -strings running along the two noncontractible cycles of the lattice, and logical $X$ operators $\bar X_1, \bar X_2$ as $X$ -strings running along the two noncontractible cycles of the dual lattice. Each:

commutes with every stabilizer (a winding loop crosses each star/plaquette an even number of times),
is not itself a stabilizer (it is not the boundary of any region),

which is exactly the definition of a logical operator. Deforming a logical string by multiplying with stabilizers keeps it in the same homology class — its class, not its shape, is what matters.

The logical algebra from intersections

The commutation of two string operators is governed (as always) by the parity of their crossings. A logical $\bar X_i$ string on the dual lattice and a logical $\bar Z_j$ string on the direct lattice cross on shared edges where $X$ and $Z$ anticommute:

\bar X_i \bar Z_j = (-1)^{\,I(i,j)}\, \bar Z_j \bar X_i ,

where $I(i,j)$ is the number of intersections mod 2. Choosing the cycles so that $\bar X_i$ and $\bar Z_j$ cross exactly once when $i=j$ and not at all when $i \ne j$ gives

\{\bar X_i, \bar Z_i\} = 0, \qquad [\bar X_i, \bar Z_j] = 0 \ (i \ne j),

the canonical Pauli algebra of two qubits. The two independent winding directions $\Rightarrow$ two anticommuting $(\bar X, \bar Z)$ pairs $\Rightarrow$ exactly $k=2$ logical qubits, confirming the count from the stabilizer bookkeeping.

Why this is fault-tolerant

A logical operator is supported on a loop that wraps the entire torus, so its weight is at least $L$ (one edge per lattice row it crosses). Any local error is a short, contractible string — detectable and correctable. To enact an unintended logical operation, noise must build an undetected string spanning a noncontractible cycle, requiring at least $L$ coordinated single-qubit errors. That minimum weight is the code distance, the subject of the next lessons.