Quantum Decoherence Explained: Why Qubits Lose Their Quantum Nature

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	400 µs	200 µs	200 ns	~1,000
IonQ Forte	seconds	seconds	300 µs	~5,000
QuEra Aquila	1-10 s	1-10 s	100 µ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:

1. 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).
2. The error correction cycle must run faster than the decoherence time.
3. 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-2). 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