Quantum Decoherence
Quantum decoherence is the gradual loss of a qubit's quantum information to its environment, and on real hardware it's measured by two numbers stamped on every chip's datasheet: T1, the energy relaxation time, and T2, the dephasing time. T1 clocks how long a qubit prepared in |1⟩ takes to decay back down to |0⟩, the same way an excited atom eventually emits a photon and drops to its ground state — it's a one-way energy leak into the qubit's surroundings. T2 clocks something subtler: how long the phase relationship between |0⟩ and |1⟩ in a superposition survives before random fluctuations scramble it, even if the qubit's energy level hasn't changed at all. T2 is always less than or equal to 2×T1, because any process that randomizes energy also randomizes phase, but phase can be lost through purely dephasing noise that never touches the energy level — which is why both numbers get reported separately rather than one standing in for the other.
On today's best superconducting transmons, T1 and T2 both land in the tens-to-low-hundreds of microseconds — Google's and IBM's leading chips report T1 times around 100-300 microseconds, with T2 typically somewhat shorter. That sounds brief, but a single two-qubit gate takes on the order of tens to a few hundred nanoseconds, so a qubit actually survives for hundreds of gate operations before decohering — the real constraint is that algorithms needing thousands of chained gates run out of coherence long before they finish, which is the central argument for quantum error correction schemes like the surface code that Google's and IBM's roadmaps both lean on. The physical culprits are concrete, not abstract: stray magnetic flux noise, photons leaking through imperfectly shielded cables, and above all two-level-system (TLS) defects — microscopic atomic rearrangements trapped in the amorphous oxide layers of the chip's dielectrics and junction barriers — that couple to the qubit and steal its energy or scramble its phase at essentially random times.
The dominant engineering response to decoherence is the dilution refrigerator: superconducting qubits run at roughly 10-20 millikelvin, colder than deep space, inside multi-stage units from Bluefors or Oxford Instruments, because thermal photons at any warmer temperature would constantly kick the qubit out of its ground state and shorten T1. Shielding, filtering, and increasingly careful materials science — tantalum films instead of aluminum, better surface treatments to reduce TLS defect density — have pushed T1 up roughly tenfold over the past decade, but no amount of cooling fully eliminates decoherence, which is why the field's long-term answer isn't better qubits alone but quantum error correction: spreading one logical qubit's information redundantly across many physical qubits (Google's 2023 below-threshold surface-code result and IBM's error-correction roadmap both target this) so that the logical qubit survives far longer than any single physical qubit's T1 or T2 would allow.
Read T1 and T2 the way a chip engineer reads any noise spec: not as abstract quantum weirdness but as the hard ceiling on circuit depth — every gate a quantum processor executes spends down a fixed coherence budget measured in microseconds, and the entire architecture of dilution refrigeration, materials engineering, and error correction exists because that budget, not qubit count, is what currently separates today's noisy hardware from a fault-tolerant quantum computer.