error correction intermediate · 22 min read · April 22, 2026

Noise and Decoherence: What Actually Goes Wrong on Real Qubits

Every tutorial up to here pretended qubits are perfect. They aren't. This tutorial covers the four main noise processes every quantum dev should know cold — relaxation, dephasing, depolarization, and readout error — with their Kraus operator forms, their T₁/T₂ signatures, and a runnable Qiskit experiment that measures them on a real device.

Prerequisites: Gates & Circuits track

Every previous tutorial has used a language that quietly assumed perfect qubits: unitary gates, exact measurements, clean Bell states. Real hardware isn’t like that. A qubit’s job is to hold a delicate superposition against a relentless environment of thermal photons, residual magnetic fields, crosstalk from neighbors, and the qubit’s own imperfect control hardware. This tutorial makes the noise concrete: four canonical noise processes, their signatures, and the numbers that describe them on real hardware in 2026.

You can’t do error correction (next tutorial) without knowing what you’re correcting. And you can’t interpret real-hardware results without knowing which noise dominated.

From closed to open systems

A unitary $U$ acting on a pure state $|\psi\rangle$ produces another pure state $U|\psi\rangle$. That’s a closed quantum system — no interaction with the environment.

Real qubits are open quantum systems. They entangle with stray environmental degrees of freedom, which act like a continuous “measurement” you didn’t ask for. The qubit’s state becomes mixed (classically random even when the initial state was pure). The tool for describing this is the density matrix $\rho$ instead of the state vector.

A pure state $|\psi\rangle$ corresponds to $\rho = |\psi\rangle\langle\psi|$ — a rank-1 projector. A mixed state is any positive-semi-definite matrix with trace 1 and rank $> 1$. Unitary gates act as $\rho \to U\rho U^\dagger$. Noise processes act as more general quantum channels.

Kraus operators

A quantum channel $\mathcal{E}$ can always be written in Kraus form:

$$\mathcal{E}(\rho) = \sum_k K_k\,\rho\,K_k^\dagger, \qquad \sum_k K_k^\dagger K_k = I.$$

The $K_k$ are matrices (not unitary in general) and their sum of adjoint-products is identity (trace-preservation condition).

Two intuitions:

1. Ensemble interpretation. Each $K_k$ corresponds to one possible “branch” of the noise process; the probability of branch $k$ is $\text{tr}(K_k \rho K_k^\dagger)$.
2. Stinespring dilation. Any channel $\mathcal{E}$ can be realized as a unitary on a larger system (qubit + environment) followed by discarding the environment.

Qiskit represents channels via Kraus objects:

import numpy as np
from qiskit.quantum_info import Kraus, Operator

# Identity (no noise)
identity_channel = Kraus([np.eye(2)])

# Bit flip with probability p = 0.1
p = 0.1
bit_flip = Kraus([
    np.sqrt(1 - p) * np.eye(2),        # nothing happens
    np.sqrt(p) * np.array([[0, 1], [1, 0]]),  # X flip
])

Verify trace preservation: $\sum K_k^\dagger K_k = (1-p)I + p\,X^\dagger X = (1-p)I + pI = I$. ✓

The four noise processes you should know

1. Amplitude damping (T₁ process)

Models spontaneous emission: the qubit in $|1\rangle$ decays to $|0\rangle$ over time. Kraus operators with decay probability $\gamma$:

$$K_0 = \begin{pmatrix}1 & 0\\ 0 & \sqrt{1-\gamma}\end{pmatrix},\qquad K_1 = \begin{pmatrix}0 & \sqrt{\gamma}\\ 0 & 0\end{pmatrix}.$$

$K_0$ preserves $|0\rangle$ and scales the $|1\rangle$ amplitude. $K_1$ transfers $|1\rangle \to |0\rangle$. Characteristic time: $T_1$. For a qubit prepared in $|1\rangle$ and waited for time $t$, the probability of still measuring $|1\rangle$ is $e^{-t/T_1}$.

Typical $T_1$ values in 2026:

• IBM Heron / Nighthawk (superconducting): ~200-500 µs
• Google Willow: ~100-300 µs
• IonQ / Quantinuum (trapped ion): ~10-60 seconds (orders of magnitude longer)
• Atom Computing / QuEra (neutral atom): ~20-60 seconds

Trapped-ion machines have brutally long $T_1$ because atomic energy levels are protected from the environment in a way superconducting circuits simply can’t be.

2. Phase damping / dephasing (T₂ process)

Models loss of phase coherence without energy loss. The qubit’s $|0\rangle$ and $|1\rangle$ populations stay the same, but the relative phase becomes randomized. Kraus operators with dephasing probability $\lambda$:

$$K_0 = \begin{pmatrix}1 & 0\\ 0 & \sqrt{1-\lambda}\end{pmatrix},\qquad K_1 = \begin{pmatrix}0 & 0\\ 0 & \sqrt{\lambda}\end{pmatrix}.$$

Think of the Bloch vector: $T_1$ shrinks the $z$-component back to equilibrium (qubit relaxing to $|0\rangle$); $T_2$ shrinks the $xy$-plane components back to zero (phase randomization). The two happen together, so what you measure on hardware is the combined decoherence time:

$$\frac{1}{T_2} = \frac{1}{2T_1} + \frac{1}{T_\phi},$$

where $T_\phi$ is the pure dephasing time. Note $T_2 \leq 2T_1$ always. For modern superconducting qubits, $T_2$ is usually ~50-80% of $2T_1$; any extra dephasing beyond the $T_1$-induced minimum is pure environmental noise.

3. Depolarizing noise

The “generic” single-qubit noise model. With probability $p$, replace the qubit’s state with a maximally mixed state:

$$\mathcal{E}(\rho) = (1 - p)\,\rho + p\,\tfrac{I}{2}.$$

Equivalent Kraus decomposition using Pauli operators:

$$K_0 = \sqrt{1 - 3p/4}\,I, \quad K_1 = \sqrt{p/4}\,X, \quad K_2 = \sqrt{p/4}\,Y, \quad K_3 = \sqrt{p/4}\,Z.$$

With probability $(1 - 3p/4)$ nothing happens; with probability $p/4$ each, an X, Y, or Z error is applied.

Depolarizing noise is a convenient abstraction — real physical noise is usually biased (some Pauli errors much more likely than others) but theoretical analyses and early error-correction demonstrations often assume uniform depolarizing to keep math tractable.

4. Readout (measurement) error

The last-mile error: when you try to read a qubit in state $|0\rangle$, you sometimes get “1” as the classical outcome, and vice versa. Characterized by a 2×2 confusion matrix:

$$M = \begin{pmatrix}p(0|0) & p(0|1)\\ p(1|0) & p(1|1)\end{pmatrix}.$$

Ideal $M = I$; real hardware has $p(0|0) \approx 0.98$-$0.99$, $p(1|1) \approx 0.95$-$0.98$. The asymmetry is physical: qubits usually relax during the measurement itself, so “1 measured as 0” is more common than the reverse.

Readout error is often the single biggest contributor to circuit error on real NISQ hardware — a 3% readout error per qubit means a 5-qubit measurement has $\sim 15\%$ error just from the readout step.

Realistic error numbers in 2026

Quantity	IBM Heron r2	Quantinuum H2	IonQ Forte	Google Willow
Single-qubit gate error	2×10⁻⁴	3×10⁻⁵	2×10⁻⁴	1×10⁻³
Two-qubit gate error	3×10⁻³	1×10⁻³	4×10⁻⁴	4×10⁻³
Readout error	1.5%	0.3%	0.5%	1%
T₁	300 µs	50 s	60 s	100 µs
T₂	200 µs	10 s	1 s	80 µs

Two-qubit gate error is usually the dominant cost, and everything else you do on the hardware must budget around that number. Quantinuum’s 10⁻³ two-qubit error is the current state of the art on commercial hardware; fault tolerance requires pushing this below ~10⁻³ with surface-code error correction absorbing the rest.

Measuring T₁ yourself (on a simulator)

Simulate a noisy qubit and extract its T₁ from a decay curve:

import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import CouplingMap
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, thermal_relaxation_error

# Build a synthetic noise model with known T1 and T2
T1 = 200e-6   # 200 µs
T2 = 100e-6   # 100 µs
gate_time = 50e-9

relax = thermal_relaxation_error(T1, T2, gate_time)
idle_relax = lambda t: thermal_relaxation_error(T1, T2, t)

noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(relax, ["id"])

# Measure T1: prepare |1⟩, wait t, measure. Fit exponential decay.
delays_us = np.linspace(0, 800, 30)
populations = []

for t_us in delays_us:
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    n_ids = max(1, int(t_us * 1e-6 / gate_time))
    for _ in range(n_ids):
        qc.id(0)
    qc.measure(0, 0)
    backend = AerSimulator(noise_model=noise_model)
    counts = backend.run(transpile(qc, backend), shots=2048).result().get_counts()
    p_one = counts.get("1", 0) / 2048
    populations.append(p_one)

populations = np.array(populations)
# Fit a + b·exp(-t/T1) to recover T1
from scipy.optimize import curve_fit
def model(t, T1, c):
    return np.exp(-t * 1e-6 / T1) + c
popt, _ = curve_fit(model, delays_us, populations, p0=[150e-6, 0.0])
print(f"Fitted T1 = {popt[0] * 1e6:.1f} µs  (injected T1 = {T1 * 1e6:.1f} µs)")
# Fitted T1 = 198.3 µs  (injected T1 = 200.0 µs)

The fit recovers the injected $T_1$ to a few percent. On real hardware, $T_1$ drifts from minute to minute by 10-20%, so experiments average over many runs to get stable estimates.

Error budgets

Before running any serious experiment, do an error budget:

1. Count one-qubit and two-qubit gates in the transpiled circuit.
2. Multiply by the per-gate error from the calibration data.
3. Add readout errors for each measured qubit.
4. Sum to get the expected total error rate.
5. If the total is > 50%, abandon — the signal-to-noise will be too poor for any result.

Example: a 50-CNOT circuit on a 10⁻³ error machine with 1% readout on 5 qubits:

• CNOT errors: $50 \times 0.003 = 0.15$
• Readout: $5 \times 0.01 = 0.05$
• Expected fidelity: $\sim 0.8$, or 80%. Workable.

Double the circuit to 100 CNOTs: fidelity drops to ~65%. Still workable. 200 CNOTs: ~45% — marginal. 500: ~20% — abandon unless you can exploit error mitigation.

Error mitigation vs error correction

Two different ideas you should not confuse:

Error mitigation is a collection of post-processing techniques that reduce the apparent error in measured expectation values without adding qubits. Examples:

• Zero-noise extrapolation (ZNE): run the circuit at different noise levels and extrapolate to zero noise.
• Probabilistic error cancellation (PEC): run a weighted combination of modified circuits that cancel some error types.
• Readout error mitigation: invert the confusion matrix to correct measurement bit strings.

ZNE and PEC incur an exponential cost in shots to cancel deeper errors, so they work for shallow NISQ circuits but don’t scale.

Error correction (next tutorial) encodes one logical qubit into many physical qubits and detects and fixes errors as they happen, with an exponentially decreasing logical error rate in the number of physical qubits. Scales to arbitrary fault-tolerant computation. Orders of magnitude more expensive in qubit count.

For today’s NISQ workloads, mitigation. For tomorrow’s fault-tolerant workloads, correction. VQE and QAOA use mitigation; Shor requires correction.

Exercises

1. Bloch-sphere evolution under T₁ only

Starting from $|+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}$, where does the Bloch vector end up after a long time under pure T₁ noise ($T_\phi = \infty$)?

Show answer

T₁ drives the qubit to $|0\rangle$ (north pole of the Bloch sphere, $(0, 0, 1)$). Starting from $|+\rangle = (1, 0, 0)$, the $z$-component grows exponentially toward 1 while $x$ and $y$ both decay. If $T_\phi = \infty$, $T_2 = 2T_1$, so the $xy$ component decays at rate $1/(2T_1)$ — specifically $x(t) = e^{-t/(2T_1)}/2$.

2. Kraus verification

Verify that the amplitude damping Kraus operators $K_0, K_1$ (defined above with $\gamma = 0.3$) satisfy $\sum K_k^\dagger K_k = I$. What state does the channel produce when applied to $|1\rangle\langle 1|$?

Show answer

$K_0^\dagger K_0 = \text{diag}(1, 1-\gamma)$; $K_1^\dagger K_1 = \text{diag}(0, \gamma)$. Sum = $\text{diag}(1, 1) = I$ ✓.

Applied to $|1\rangle\langle 1| = \text{diag}(0, 1)$: $K_0 \rho K_0^\dagger = \text{diag}(0, 1-\gamma)$; $K_1 \rho K_1^\dagger = \text{diag}(\gamma, 0)$. Sum: $\text{diag}(\gamma, 1-\gamma)$ — with probability $\gamma$ the qubit has relaxed to $|0\rangle$, else it’s still in $|1\rangle$.

3. Error budget a circuit

A 4-qubit circuit has 80 CNOTs and 200 single-qubit gates. On IBM Heron r2 (using the numbers above), what’s the expected total gate error? Does readout error dominate or is it a minor add-on?

Show answer

CNOTs: $80 \times 3 \times 10^{-3} = 0.24$. Single-qubit gates: $200 \times 2 \times 10^{-4} = 0.04$. Readout: $4 \times 0.015 = 0.06$. Total: $\sim 0.34$. Fidelity $\sim 66\%$. CNOTs dominate by far; readout is a meaningful add-on but not the biggest factor.

4. T₁ experiment design

You want to measure $T_1$ on a real qubit to within 10% precision. How many delay points should you sweep? How should you space them? What’s the minimum shot count per point?

Show answer

Space delays logarithmically from $\sim T_1/10$ to $\sim 3T_1$ to capture the decay shape well. Maybe 10-15 points. Each point needs enough shots that binomial noise on the $|1\rangle$ probability is small compared to the decay rate you’re trying to measure — 2048-4096 shots typically yields $\sim 1\%$ precision per point. Total: 15 × 4096 = ~60,000 shots, which runs in a few minutes on IBM’s free tier.

What you should take away

• Density matrices and Kraus operators are the general language of noisy quantum evolution.
• T₁ (energy relaxation) and T₂ (phase coherence) are the two primary decoherence timescales.
• Amplitude damping + phase damping + depolarization + readout cover the four main noise processes you’ll meet.
• 2026 hardware reality: trapped-ion > superconducting on T₁ / T₂ by 5-6 orders of magnitude; superconducting wins on gate speed.
• Error mitigation fights NISQ noise in post-processing; error correction is the scalable approach that requires exponential qubit overhead.

Next: the surface code and Willow — how to turn 1000 noisy physical qubits into one reliable logical qubit, and why Google’s December 2024 result changed the mood of the entire field.

---

Weekly dispatch

Quantum, for people who already code.

One serious tutorial per week, plus the industry moves that actually matter. No hype, no hand-waving.

Email Subscribe

Free. Unsubscribe anytime. We will never sell your email.