Decoherence, bit-flips, and phase-flips

Every algorithm in Module 7 assumed gates work perfectly. Actually existing quantum computers don’t. Gates fail. Qubits lose their state. Measurements return wrong answers. The process by which a quantum computer “forgets” its state is called decoherence, and it’s the single biggest engineering challenge in building practical quantum hardware.

This module is about the two-pronged response: (1) understand the nature of quantum noise, and (2) build codes that correct it.

How noise happens

Physically, a qubit is something like a single atom, a single photon, or a tiny superconducting loop. It’s held in a specific quantum state through enormous effort — cooling, shielding, careful laser or microwave control. Over time, the qubit inevitably interacts with its environment: a stray photon, a thermal fluctuation, a vibration, a microwave leak. Each such interaction entangles the qubit with its environment, and since the environment is enormous and we can’t track it, the qubit effectively becomes a mixed state — a statistical ensemble of possibilities rather than a pure superposition.

From our perspective, decoherence looks like: the qubit’s quantum state “leaks” into the environment and we lose information about it.

There are characteristic times for this process:

• $T_1$ — the relaxation time, i.e., how long before an excited qubit (in $|1\rangle$) decays to the ground state $|0\rangle$.
• $T_2$ — the coherence time, i.e., how long the phase relationship between $|0\rangle$ and $|1\rangle$ components of a superposition remains intact. Typically $T_2 \leq 2 T_1$.

For today’s best superconducting qubits, $T_1$ and $T_2$ are on the order of hundreds of microseconds. A gate takes about $10$–$100$ nanoseconds, so you can do roughly a few thousand gates before decoherence destroys everything.

The two basic error types

Quantum errors, rather than being an infinite zoo, can be decomposed into just two fundamental kinds — and crucially, into two discrete operators. This is one of the great structural facts of quantum error correction.

Bit-flip error: the $X$ gate applied without permission. $|0\rangle \leftrightarrow |1\rangle$. The quantum version of a classical bit flipping.

Phase-flip error: the $Z$ gate applied without permission. $|0\rangle \to |0\rangle$ but $|1\rangle \to -|1\rangle$. This has no classical analog — it’s the phase between components that gets disturbed. Phase errors don’t do anything visible to a computational-basis state, but they can totally scramble a superposition.

Any more complex noise is a linear combination of $I$ (no error), $X$, $Y$, and $Z$ errors — with $Y = iXZ$ being a combined bit-and-phase flip. So if you can correct $X$ errors and $Z$ errors independently, you can correct all single-qubit errors. This is the digitization of errors, and it’s the mathematical reason quantum error correction is even possible.

Why classical error correction doesn’t work directly

In classical computing, the simplest error-correcting code is repetition: store each bit three times, and recover the majority vote.

If one physical bit flips, the other two still hold the correct value, and the decoder outputs the majority.

The same plan for qubits fails for two reasons:

1. You can’t copy quantum states (no-cloning theorem from Lesson 5.2). You cannot just “make three copies” of an unknown qubit. So the classical notion of “repetition” doesn’t even start.
2. Measurement destroys superpositions. In the classical code, decoding is “look at all three bits, take the majority.” For qubits, looking at them destroys the state. You can’t just measure and repair.

Both obstacles can be worked around. The no-cloning problem is solved by a clever encoding scheme (not copying, but entangling) that produces a 3-qubit state whose logical content is still “one qubit worth” but which can resist bit-flip errors. The measurement problem is solved by syndrome measurements — carefully chosen measurements that reveal only which error occurred, without revealing the logical state.

These two tricks are the foundation of the next lesson.

What’s next

The next lesson shows how quantum error correction actually works, using the simplest possible code: the 3-qubit bit-flip repetition code. It only handles bit-flip errors (not phase-flips) but it’s the cleanest demonstration of the mechanism.