Decoherence is the process by which a qubit loses its quantum properties and behaves increasingly like a classical bit. It is not a bug in the hardware, it is a fundamental consequence of quantum mechanics. Understanding it explains why building useful quantum computers is so hard and what error correction must overcome.
What decoherence is
A qubit in superposition is described by a density matrix:
ρ = |ψ⟩⟨ψ| = |α|²|0⟩⟨0| + αβ*|0⟩⟨1| + α*β|1⟩⟨0| + |β|²|1⟩⟨1|
The off-diagonal terms αβ* and α*β are the coherences, they encode the quantum phase relationship between |0⟩ and |1⟩. This is what makes interference possible and what quantum algorithms exploit.
Decoherence is the decay of these off-diagonal terms. When they go to zero, the density matrix becomes diagonal:
ρ → |α|²|0⟩⟨0| + |β|²|1⟩⟨1|
This is a classical probability distribution: the qubit is in state |0⟩ with probability |α|² and |1⟩ with probability |β|², but with no quantum phase relationship between them. The qubit cannot interfere with itself anymore.
Why it happens: the environment
A qubit is never perfectly isolated. It is coupled to its environment: the electromagnetic field, neighbouring atoms, phonons in the substrate, control electronics. From the qubit’s perspective, this coupling causes the environment to “measure” it continuously in a random, uncontrolled way.
More precisely, when the qubit interacts with the environment, they become entangled. The total state becomes:
(α|0⟩ + β|1⟩)|env⟩ → α|0⟩|env₀⟩ + β|1⟩|env₁⟩
where |env₀⟩ and |env₁⟩ are slightly different states of the environment. Tracing out the environment (we cannot observe it) gives a mixed state for the qubit:
ρ_qubit = |α|²|0⟩⟨0| + |β|²|1⟩⟨1| + αβ* ⟨env₁|env₀⟩ |0⟩⟨1| + ...
The coherences are multiplied by the overlap ⟨env₁|env₀⟩. As the environment evolves, this overlap tends to zero because macroscopically distinguishable environment states become orthogonal. The coherences vanish.
T1: amplitude damping (energy relaxation)
T1 (pronounced “T-one”) is the time for a qubit to decay from |1⟩ to |0⟩ by losing energy to the environment. It characterises how long a qubit can store a population difference.
The T1 process is modelled by the amplitude damping channel:
ρ₀₀ → 1 − (1 − ρ₀₀)e^(−t/T1)
ρ₁₁ → ρ₁₁ e^(−t/T1)
ρ₀₁ → ρ₀₁ e^(−t/(2T1))
ρ₁₀ → ρ₁₀ e^(−t/(2T1))
At t=0, population is as initialised. As t→∞, ρ₁₁→0 and ρ₀₀→1: the qubit relaxes to |0⟩ regardless of initial state. On the Bloch sphere, T1 decay moves the vector toward the north pole while shrinking its length.
Typical T1 values (2026):
- Superconducting transmon (IBM Heron): 100–500 µs
- Trapped ion (IonQ, Quantinuum): seconds to minutes
- Neutral atom (QuEra): 1–10 seconds
T2: dephasing
T2 (pronounced “T-two”) characterises the decay of phase coherence, the randomisation of the relative phase between |0⟩ and |1⟩. It is always ≤ 2T1 and often much shorter.
T2 has two contributions:
1/T2 = 1/(2T1) + 1/T2*
where T2* (T-two-star) is the pure dephasing time due to low-frequency noise. On the Bloch sphere, T2 decay shrinks the equatorial plane without affecting the z-component directly.
The phase damping channel affects only the off-diagonal terms:
ρ₀₁ → ρ₀₁ e^(−t/T2)
ρ₁₀ → ρ₁₀ e^(−t/T2)
Population (ρ₀₀, ρ₁₁) is unaffected by pure dephasing. Only the phase information is lost.
Physical mechanisms of dephasing:
- Charge noise: Fluctuating charge in the substrate randomly shifts the qubit frequency, giving each qubit a slightly different phase accumulation rate.
- Magnetic flux noise: Ambient magnetic field fluctuations (especially relevant for flux qubits).
- Two-level system (TLS) defects: Microscopic tunnelling systems in the substrate and Josephson junction materials that couple to the qubit and absorb/emit energy unpredictably.
Simulating decoherence in Qiskit
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, thermal_relaxation_error
import numpy as np
# Decoherence parameters (realistic superconducting qubit)
T1 = 200e-6 # 200 microseconds
T2 = 100e-6 # 100 microseconds (T2 ≤ 2*T1)
gate_time = 50e-9 # 50 nanoseconds for a single-qubit gate
# Build thermal relaxation error
thermal_error = thermal_relaxation_error(T1, T2, gate_time)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(thermal_error, ['h', 'x', 'rz', 'ry'])
# Measure how coherence decays after idle time
def measure_z_expectation(idle_time_us: float, shots: int = 10_000) -> float:
"""Prepare |+⟩, wait, measure ⟨Z⟩. Should decay as e^(-t/T1)."""
qc = QuantumCircuit(1, 1)
qc.x(0) # Prepare |1⟩ (maximises T1 decay signal)
# Approximate idle time with a delay of 'n' identity gates
n_gates = max(1, int(idle_time_us * 1e-6 / gate_time))
for _ in range(n_gates):
qc.id(0)
qc.measure(0, 0)
backend = AerSimulator(noise_model=noise_model)
result = backend.run(qc, shots=shots).result()
counts = result.get_counts()
p1 = counts.get('1', 0) / shots
return 2 * p1 - 1 # Convert P(|1⟩) to ⟨Z⟩ ∈ [-1, +1]
# Show T1 decay
print("T1 relaxation (|1⟩ population decay):")
for t_us in [0, 50, 100, 200, 400]:
z = measure_z_expectation(t_us)
expected = -np.exp(-t_us * 1e-6 / T1)
print(f" t={t_us:>4} µs: ⟨Z⟩ = {z:.3f} (theory: {expected:.3f})")
Expected output:
T1 relaxation (|1⟩ population decay):
t= 0 µs: ⟨Z⟩ ≈ -1.000 (theory: -1.000)
t= 50 µs: ⟨Z⟩ ≈ -0.778 (theory: -0.779)
t= 100 µs: ⟨Z⟩ ≈ -0.607 (theory: -0.607)
t= 200 µs: ⟨Z⟩ ≈ -0.368 (theory: -0.368)
t= 400 µs: ⟨Z⟩ ≈ -0.135 (theory: -0.135)
The exponential decay e^(−t/T1) is the hallmark of T1 relaxation.
Why T2 < 2T1 in practice
On superconducting hardware, typical values are T1 ≈ 100–500 µs but T2 ≈ 50–200 µs, well below the 2T1 limit. The gap is filled by pure dephasing from charge noise and TLS defects. Improving T2 requires better fabrication (cleaner Josephson junctions, low-noise substrates) and dynamic decoupling techniques.
Dynamic decoupling (DD) applies a sequence of π-pulses to average out low-frequency noise:
# Hahn echo: X-delay-X sequence refocuses quasi-static dephasing
qc = QuantumCircuit(1)
qc.h(0) # Prepare |+⟩ (on equator)
qc.delay(500, unit='ns') # Free evolution → dephasing begins
qc.x(0) # π pulse refocuses quasi-static noise
qc.delay(500, unit='ns') # Second half
qc.h(0) # Measure in X basis
The T2 measured with Hahn echo (T2_echo) is longer than T2* because it refocuses slow frequency fluctuations. With CPMG sequences (multiple π-pulses), T2_CPMG can approach 2T1.
Decoherence and circuit depth
The practical impact: a qubit gate takes ~50–100 ns on superconducting hardware, but T2 ≈ 100 µs. This gives a coherence “budget” of roughly 1,000–2,000 gate operations before the qubit has fully decohered.
Two-qubit gates are 5–10× slower than single-qubit gates (~200–500 ns), so the budget for two-qubit gates is ~200–500 operations.
This is why NISQ algorithms must be shallow. A 100-qubit circuit with 1,000 two-qubit gates would take ~200 µs, comparable to T1. The algorithm output would be dominated by noise.
Current (2026) gate counts before decoherence dominates:
| Platform | T1 | T2 | 2Q gate time | Max useful 2Q gates |
|---|---|---|---|---|
| IBM Heron r2 | ~200 µs (median) | ~100 µs (median) | ~70 ns | ~1,000 |
| IonQ Forte | seconds | ~1 s | ~600 µs | ~1,000 |
| Neutral atom (gate-based) | 1-10 s | ~1 s | ~1 µs | ~10,000+ |
Error correction vs decoherence
Quantum error correction (QEC) does not prevent decoherence: it detects and corrects its effects fast enough that the logical qubit remains coherent. For this to work:
- The physical error rate (related to 1/T1 and 1/T2 per gate) must be below the fault-tolerance threshold (~0.1–1% per gate for surface codes).
- The error correction cycle must run faster than the decoherence time.
- Many physical qubits (typically hundreds to thousands) encode one logical qubit.
Current hardware (2026) has physical error rates of ~0.1–0.5%, which is at or just below threshold for the best systems (Google Willow, IBM Heron r2, Quantinuum H2). This is why the first demonstrations of below-threshold error correction are so significant, they are the first time the overhead of error correction is actually buying you something.
Related resources
- Surface Code Introduction
- Quantum Error Models Introduction
- Density Matrices and Mixed States
- Qiskit Noise Models
- Hardware Guide: T1/T2 values for current platforms