Decoherence and noise

Every gate you have built so far assumed a perfectly isolated qubit. Real qubits are not isolated. They sit in a noisy world of stray fields and vibrating atoms, and they leak. This lesson is about that leak - why a superposition quietly rots into an ordinary classical bit, and the two clocks that measure how fast.

Decoherence is accidental entanglement

We can build the whole idea out of two things you already have. From entanglement: when two systems interact, they can become correlated so that neither has a state of its own anymore. From measurement: reading a qubit collapses its superposition and destroys the phase.

Now put them together. The environment - the wiring, the substrate, a passing photon - is really just a huge collection of other quantum systems. When your qubit interacts with even one of them, it entangles with it, exactly as a CNOT would. The catch is that you cannot see the environment and you never record what it did. An entanglement whose other half you cannot read is, for every purpose that matters to you, a measurement performed by the universe and then thrown away. The result is the same as a measurement you did not want: the superposition collapses, the phase is gone.^[1]

Picture a coin spinning on a table: while it spins it is genuinely "between" heads and tails, the way a superposition is between |0> and |1>. Now let it graze a rough patch. The tiny scrape does not knock the coin to heads or tails on purpose, but it disturbs the spin, and after enough scrapes the coin is just lying there showing one face. It did not get flipped by an enemy. It got read by the table, one scrape at a time, until nothing was left to spin.

Play with the two clocks

Below, a single qubit sits on the Bloch sphere and time runs to the right. Advance the clock and watch the state vector do two things at once: shrink toward the center, and drift up toward the |0> pole. Start it at |+> to watch the phase die, or at |1> to watch it relax. Turn up the noise and both happen sooner.

Two separate decays are running, and they are worth naming. The first strips away the part of the vector lying on the equator - the relative phase, which you already know is the entire computational resource. The second pulls the vector toward |0>, the qubit settling into its lazy default. Each has its own clock.

T2 and T1: the two timescales

Hardware people quote two numbers for every qubit. We can define them purely by what they do to the Bloch vector, no physics required. Let the vector have equatorial part (its phase information) and a vertical part (its lean toward |0> or |1>).

T2 is the dephasing time: how long the equatorial part - the phase - lasts. T1 is the relaxation time: how long the vector keeps its lean before sliding back to |0>.^[2] We model each decay as a simple shrink that halves on its own schedule (this exponential form is stated, taken from how the noise actually behaves, not derived here):

The equatorial term is the one that carries phase, and it decays on the T2 clock. Because losing phase requires only a graze while fully relaxing requires actually dumping the excitation, the phase almost always goes first: in real hardware $T_2\le 2T_1$, and often $T_2$ is much shorter. That inequality is the whole engineering headache in one line - the resource you compute with is the most fragile thing you have.

Coherence time sets the gate budget

This is where decoherence becomes a hard engineering number. If a single gate takes some time to run, and the qubit stays coherent for T2, then you get roughly T2 divided by the gate time useful operations before the phase is gone. That ratio - not the raw clock speed - is what limits how deep a circuit you can run before the answer dissolves into noise.

Check yourself