Every quantum hardware spec sheet lists T1 and T2 next to each other, both in microseconds or milliseconds, both described loosely as "how long the qubit lasts." That framing hides a real distinction. T1 and T2 measure different physical processes, decay toward different things, and mixing them up leads to a specific, common misunderstanding about what T2 describes.
T1: energy leaking out
A qubit in the excited state |1⟩ sits at higher energy than the ground state |0⟩. Nothing holds it there forever. Given enough time, it releases that energy, usually as a stray photon into its environment, and relaxes to |0⟩. T1 is the exponential time constant of that decay: the excited-state population falls off as e^(-t/T1). After one T1, roughly 37% of an ensemble prepared in |1⟩ remains there. This is energy relaxation, a qubit losing information to its surroundings the same way an excited atom eventually emits a photon and drops to its ground state.
T1 is intuitive because it maps onto something familiar: a system loses energy and settles into equilibrium. The population of |1⟩ decays, |0⟩ population grows, and the process only runs one direction.
T2: not a flip, a loss of phase
T2 covers a different kind of information: not which state a qubit is in, but the phase relationship it holds while in a superposition. Take a qubit prepared as
√p₀ |0⟩ + e^(iφ) √p₁ |1⟩
The phase φ carries real information. It's what makes interference-based algorithms work, and it's what a Hadamard-then-Hadamard round trip depends on to cancel correctly. T2 is the timescale over which that phase becomes unrecoverable: the state doesn't stop being a superposition all at once, it gradually loses the definite relationship between its |0⟩ and |1⟩ components until φ is effectively random.
In the language of density matrices, this shows up as the off-diagonal element of ρ, the coherence term, decaying: ρ₀₁(t) = ρ₀₁(0) · e^(-t/T2). The diagonal elements, the populations p₀ and p₁, are what T1 governs. The off-diagonal element is what T2 governs. They're tracking different entries in the same matrix.
The misconception worth clearing up
It's tempting to picture T2 as the time it takes a qubit prepared in |+⟩ = (|0⟩ + |1⟩)/√2 to flip into |−⟩ = (|0⟩ − |1⟩)/√2, the orthogonal superposition state. That's not what happens, and the distinction matters.
A flip from |+⟩ to |−⟩ would be a coherent, deterministic process, a rotation, the kind of thing a gate does on purpose. Dephasing isn't that. What happens instead is that the qubit's phase, averaged over repeated runs of the same preparation, becomes uncorrelated with the phase it started with. Run the experiment many times, prepare |+⟩ each time, and wait one T2: you no longer reliably measure |+⟩, but you also don't reliably measure |−⟩. Instead, the outcomes look like a 50/50 classical mixture with no memory of which state you started in. T2 is an autocorrelation time, the point at which the final state stops being correlated with the initial one, not a countdown to a predictable opposite state.
That distinction is why error correction is hard in the first place. If dephasing flipped |+⟩ to |−⟩ on a fixed clock, waiting out the right interval would correct for it, no error correction needed. Random loss of correlation doesn't offer that shortcut.
Why T2 is capped by T1
Hardware specs consistently show T2 ≤ 2·T1, and that inequality isn't a coincidence. It's a consequence of what T1 relaxation does to phase along the way. Energy relaxation, the T1 process, also destroys phase information as a side effect: once a qubit has decayed from |1⟩ to |0⟩, any phase it was carrying relative to |1⟩ is gone too. So T2 has two contributions: relaxation-driven dephasing (bounded by 2T1) and everything else that scrambles phase without any energy loss at all, often written as pure dephasing, T_φ. The combined rate adds: 1/T2 = 1/(2T1) + 1/T_φ. T2 never exceeds what T1 alone would allow, and in practice it's usually shorter, because pure dephasing sources, magnetic field noise, control electronics jitter, nearby two-level defects, are rarely zero.
Why the distinction matters for running circuits
Both numbers cap how long a circuit runs before noise dominates the result, but they cap different kinds of computation. A circuit that only cares about final populations (a bit-flip-heavy algorithm, or a simple readout) is mostly bounded by T1. A circuit that depends on interference between branches of a superposition surviving intact, most genuinely quantum algorithms, is bounded by the shorter of the two, and T2 is usually the shorter one. Superconducting qubits typically run 50 to 500 microseconds of usable coherence. Trapped ions reach seconds to minutes, at the cost of slower gates. Either way, circuit depth is a race against whichever of T1 or T2 runs out first, and it's T2, the phase, not T1, the energy, that usually loses that race.
Understanding this split also clarifies what quantum error correction is fighting. A logical qubit built from many physical ones isn't trying to stop T1 and T2 decay from happening. It's trying to detect and undo the damage faster than decoherence accumulates, which is why the physical qubits underneath a fault-tolerant machine still need T1 and T2 long enough, relative to gate speed, for that detection loop to keep up. Our piece on logical qubits and fault tolerance covers what that overhead costs.