Error Propagation

Errors move when gates act

A Pauli error sitting on a qubit does not stay put once a gate is applied. Because Pauli operators do not generally commute with Clifford gates, pushing an error through a gate transforms it. The central worry for fault tolerance is the two-qubit gate: a single error on one qubit can become an error on two qubits after a CNOT. Understanding exactly how errors propagate is what lets us design gadgets that keep the spread under control.

The CNOT conjugation rules

Let qubit $c$ be the control and $t$ the target of a CNOT, written $U = \mathrm{CNOT}_{c\to t}$ . The CNOT is a Clifford gate, so it maps Paulis to Paulis under conjugation. The four generating rules are

U\,(X_c \otimes I_t)\,U^\dagger = X_c \otimes X_t, \qquad U\,(I_c \otimes X_t)\,U^\dagger = I_c \otimes X_t,

U\,(Z_c \otimes I_t)\,U^\dagger = Z_c \otimes I_t, \qquad U\,(I_c \otimes Z_t)\,U^\dagger = Z_c \otimes Z_t.

Read them as physics: an $X$ (bit-flip) on the control copies forward onto the target, while an $X$ on the target stays put. A $Z$ (phase) error does the opposite — it stays on the control but copies backward from target to control. This control/target asymmetry, with bit-flips flowing one way and phases the other, is the rule every fault-tolerant construction is built around.

Why this is the central danger

The first rule, $X_c \to X_c X_t$ , is the threatening one. A single physical $X$ fault before a CNOT becomes a weight-two error afterward. Chain several CNOTs that share a qubit and one fault can fan out across an entire code block, producing an error the code cannot correct. This is precisely why transversal implementations matter: if logical gates couple the $i$ -th qubit of one block only to the $i$ -th qubit of another, a single fault can land at most one error per block, and the code still cleans it up.

Verifying the rule on a state

The conjugation identity $U (X_c \otimes I_t) = (X_c \otimes X_t)\,U$ has a direct, checkable consequence. Start in $|00\rangle$ (a $+1$ eigenstate of both $Z$ 's), inject an $X$ error on the control, then apply the CNOT. The $X$ on the control turns $|00\rangle$ into $|10\rangle$ ; the CNOT then flips the target because the control is $1$ , giving $|11\rangle$ . So the single-qubit $X$ error has visibly become a $X\otimes X$ error: both qubits are flipped. The final state is exactly $|11\rangle$ , amplitude $1$ on basis index $3$ .

Try it

Build the propagation circuit on two qubits (control $=0$ , target $=1$ ): inject the $X$ error on the control, then apply cx(0, 1). Return the circuit. The grader checks the full statevector, which must be $|11\rangle$ — the fingerprint of the error having copied forward onto the target.

Run your code to see the quantum state.