Why Real Qubits Are Noisy

Every algorithm developed so far in this track has assumed ideal qubits: gates that perform exactly their intended unitary operation, coherence that lasts forever, and measurements that return sharp results. Real hardware is nothing like that. Understanding why qubits are noisy — and how physicists characterise and model that noise — is the foundation of quantum error correction, error mitigation, and noise-aware compilation.

The qubit is never truly isolated

A quantum state carries information through the relative phase and amplitude of its superposition components. Both are fragile. Every physical realisation of a qubit (superconducting transmon, trapped ion, photon, spin in silicon, …) is embedded in a larger environment: substrate phonons, stray electromagnetic fields, control electronics, and neighbouring qubits. The Hamiltonian of the full universe couples the qubit to millions of environmental degrees of freedom it cannot control. The result is that the neat two-level system described by a state vector $|\psi\rangle$ evolves instead as part of a joint qubit-plus-environment state, and when we trace out the environment we are left with a mixed state — a statistical ensemble rather than a pure quantum superposition.

This process is called decoherence, and it is the central obstacle in quantum computing.

Two fundamental timescales

Hardware physicists characterise decoherence with two times:

$T_1$ (relaxation time) is how long the qubit takes to decay from the excited state $|1\rangle$ to the ground state $|0\rangle$ . The underlying mechanism is energy relaxation: the qubit spontaneously emits a photon (or phonon) into the environment, losing its excitation. If you prepare $|1\rangle$ and wait a time $t$ , the probability of still finding $|1\rangle$ falls as

$P_{|1\rangle}(t) = e^{-t/T_1}.$

For best-in-class superconducting qubits (2025), $T_1$ is on the order of hundreds of microseconds; for some trapped-ion systems it extends to seconds or even minutes.

$T_2$ (dephasing time, or coherence time) is how long a qubit on the equator of the Bloch sphere — a superposition like $|+\rangle = \tfrac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$ — retains its phase relationship. Fluctuations in the qubit's transition frequency (due to charge noise, flux noise, or magnetic field drift) cause the relative phase between $|0\rangle$ and $|1\rangle$ to wander. After time $t$ the off-diagonal element of the density matrix decays as

$\rho_{01}(t) = \rho_{01}(0)\,e^{-t/T_2}.$

Since dephasing includes both pure dephasing and relaxation,

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

where $T_\phi$ is the pure dephasing time. Consequently $T_2 \leq 2 T_1$ , with equality only when pure dephasing is absent.

Gate errors and their origins

Each gate applied to a qubit takes time; during that time decoherence continues. A two-qubit gate on a superconducting processor typically takes 20–100 ns, while $T_2$ might be 100 $\mu$ s, giving a per-gate error probability of roughly $t_{\text{gate}}/T_2 \sim 10^{-3}$ from decoherence alone. Other sources contribute further:

Control errors — imperfect pulse shapes, amplitude drift, or timing jitter mean the rotation angle applied by a gate deviates from its target. A gate intended to rotate by $\pi$ might actually rotate by $\pi + \delta$ for some small $\delta \neq 0$ .
Leakage — most physical qubits are actually multi-level systems (a transmon has many energy levels). A strong or misshapen drive pulse can excite the qubit out of the computational subspace $\{|0\rangle, |1\rangle\}$ into higher levels $|2\rangle, |3\rangle, \ldots$ The leaked population is invisible to standard readout and corrupts subsequent gates.
Crosstalk — applying a gate to one qubit can shift the frequency or state of neighbouring qubits through residual coupling. This is particularly troublesome in superconducting processors where many qubits share a bus or substrate.
Readout errors — distinguishing $|0\rangle$ from $|1\rangle$ in a measurement is itself imperfect. A photon dispersively coupled to a resonator yields a microwave signal that overlaps between the two states, giving a misclassification probability of a few percent per qubit.

Noise as quantum channels

The formal language for describing all these imperfections is a quantum channel: a completely positive, trace-preserving (CPTP) linear map on the density matrix. Three canonical noise channels appear repeatedly in the literature:

The bit-flip channel flips $|0\rangle \leftrightarrow |1\rangle$ with probability $p$ :

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

The phase-flip channel applies a $Z$ gate with probability $p$ , destroying phase coherence:

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

The depolarising channel replaces the qubit with the maximally mixed state $I/2$ with probability $p$ (or equivalently applies $X$ , $Y$ , or $Z$ each with probability $p/4$ ):

$\mathcal{E}(\rho) = \left(1 - p\right)\rho + \frac{p}{4}\left(X\rho X + Y\rho Y + Z\rho Z + \rho\right) = \left(1-p\right)\rho + \frac{p}{2} \cdot I.$

The depolarising channel is a convenient hardware-agnostic noise model and is the default in many simulators. It cannot distinguish between relaxation and dephasing, but it captures the essential effect: repeated application shrinks all amplitudes toward the centre of the Bloch sphere.

Characteristic noise rates in leading platforms

The table below gives approximate orders of magnitude reported in recent literature for two leading platforms. Exact values depend strongly on qubit design, fabrication, and operating point.

| Property | Superconducting (transmon) | Trapped ion | |---|---|---| | $T_1$ | 100 $\mu$ s – 1 ms | 1 s – minutes | | $T_2$ | 100 $\mu$ s – 500 $\mu$ s | 0.1 s – seconds | | Single-qubit gate error | $\sim 10^{-4}$ – $10^{-3}$ | $\sim 10^{-5}$ – $10^{-4}$ | | Two-qubit gate error | $\sim 10^{-3}$ – $10^{-2}$ | $\sim 10^{-3}$ – $10^{-2}$ | | Gate time (1Q) | 10 – 50 ns | 1 – 100 $\mu$ s | | Readout error | 1 % – 5 % | 0.1 % – 1 % |

Trapped ions have much longer coherence times but much slower gates; superconductors are fast but noisier. Both platforms have improved by roughly an order of magnitude per decade, and both are approaching but have not yet reached the fault-tolerance threshold for large-scale error correction.

Why noise matters for algorithms

Circuit depth is limited by coherence: a circuit with $d$ layers of gates accumulates error proportional to $d \cdot \epsilon_{\text{gate}}$ . For a depolarising error rate of $\epsilon = 10^{-3}$ per gate, a 1000-layer circuit has accumulated error $\sim 1$ , at which point the output is dominated by noise rather than computation. Today's devices — often called NISQ (Noisy Intermediate-Scale Quantum) processors — support at most a few hundred reliable gates before fidelity collapses. Algorithms designed for NISQ hardware (like VQE and QAOA) explicitly keep circuits shallow precisely for this reason.

The path beyond NISQ requires quantum error correction (QEC): encoding logical qubits in many physical qubits so that errors can be detected and corrected faster than they accumulate. The threshold theorem guarantees that arbitrarily long computation is possible provided the physical error rate is below a platform-specific threshold (typically $\sim 10^{-3}$ to $10^{-2}$ , depending on the code). The lessons ahead will show how density matrices capture noisy evolution and how simple error correction codes exploit redundancy to protect quantum information.