Logical Operations on Encoded Qubits

Error correction would be pointless if we had to decode a logical qubit every time we wanted to compute with it — decoding exposes it to noise. The goal is to manipulate the encoded qubit while it stays protected. The operators that do this are the logical gates, and they live in the same multi-qubit space as the codewords.

What makes an operator "logical"

A logical operator $\bar{P}$ must satisfy two conditions:

It maps the code space to itself — codewords go to codewords. Equivalently, it commutes with every stabilizer, so it never changes the syndrome.
It acts as the intended single-qubit gate on the logical labels: $\bar{X}|0_L\rangle = |1_L\rangle$ , $\bar{Z}|0_L\rangle = |0_L\rangle$ , $\bar{Z}|1_L\rangle = -|1_L\rangle$ .

A physical $X$ on one qubit fails condition 1: $X_0|000\rangle = |100\rangle$ is outside the code space (it has a nonzero syndrome). We need an operator built so the net effect lands back inside the code.

Logical X and Z for the bit-flip code

For $|0_L\rangle = |000\rangle$ , $|1_L\rangle = |111\rangle$ :

\bar{X} = X_0 X_1 X_2, \qquad \bar{Z} = Z_0 \;(\text{or } Z_1, \text{ or } Z_2).

Check $\bar X$ : $X^{\otimes 3}|000\rangle = |111\rangle$ and $X^{\otimes 3}|111\rangle = |000\rangle$ — it swaps the two codewords, the logical bit flip. It commutes with $Z_0Z_1$ and $Z_1Z_2$ (each $X$ anticommutes with two $Z$ 's, an even number), so the syndrome is untouched.

Check $\bar Z = Z_0$ : $Z_0|000\rangle = |000\rangle$ and $Z_0|111\rangle = -|111\rangle$ — it applies the logical phase. A single $Z$ suffices here because all three qubits carry the same logical bit; any one of them reads it out.

Logical operators are not unique

Because $\bar Z = Z_0$ and $\bar Z' = Z_0 (Z_0 Z_1) = Z_1$ differ only by a stabilizer, they act identically on the code space. In general a logical operator is defined only up to multiplication by stabilizers — any representative in the same coset is equally valid. We usually pick the lowest-weight one; its weight is the code distance, here 3 for $\bar X$ and 1 for $\bar Z$ (the bit-flip code is asymmetric: strong against $X$ , weak against $Z$ ).

Try it

Encode $|0_L\rangle$ , then apply the logical $X$ to flip it to $|1_L\rangle = |111\rangle$ . The grader checks the statevector: the only nonzero amplitude must sit at index 7 (111).

Run your code to see the quantum state.

After running, the statevector panel shows a single bar at 111 with amplitude 1 — the encoded qubit has been flipped from logical 0 to logical 1 without ever leaving the protected code space.