Chapter 22: Why Quantum Error Correction Is Necessary: Decoherence, Gate Errors, and the Fragility of Quantum Information

Learning Objectives

By the end of this chapter, you will be able to:

• Classify the principal types of quantum errors: bit flip, phase flip, amplitude damping, and depolarizing noise, with detailed mathematical derivations of their Kraus operators.
• Explain decoherence in terms of $T_1$ (relaxation) and $T_2$ (dephasing) times and connect these to physical mechanisms including spontaneous emission, charge noise, and flux noise.
• Derive the Lindblad master equation and solve it for single-qubit dynamics, obtaining explicit time evolution of the density matrix elements.
• Quantify gate infidelity using the average gate fidelity metric and relate it to the diamond norm distance.
• Construct the Kraus operator representation of a quantum noise channel and simulate it in Qiskit, including composition of noise channels.
• Articulate why classical error correction strategies fail in the quantum domain (no-cloning, measurement collapse, continuous errors) with rigorous proofs.
• State the threshold theorem and interpret its implications for scalable quantum computing, including the overhead scaling for concatenated codes.
• Survey current hardware error rates across leading platforms and project the requirements for fault-tolerant quantum computation.
• Compute error budgets for quantum algorithms and determine the logical error rates achievable with given physical error rates and code distances.

22.1 The Fragility of Quantum Information

22.1.1 Classical vs. Quantum Robustness

A classical bit is robust. A transistor storing a 0 or 1 can tolerate thermal fluctuations, stray electromagnetic fields, and manufacturing variability without flipping. Digital electronics routinely achieves bit error rates below $10^{-15}$ — a single error in a petabit of data. This robustness comes from the discrete nature of classical information and the energy barrier between states.

A quantum bit — a qubit — enjoys no such luxury. The very properties that make qubits powerful — superposition, entanglement, and coherent phase — are exquisitely sensitive to environmental coupling. Consider a general pure state of a single qubit:

$$|\psi\rangle = \alpha|0\rangle + \beta|1\rangle, \quad |\alpha|^2 + |\beta|^2 = 1.$$

The state is specified by two continuous real parameters (e.g., the polar and azimuthal angles on the Bloch sphere). An error that shifts $\alpha$ by $\epsilon$ changes the state. Worse, the environment constantly "measures" the qubit through unwanted interactions, leaking information about $\alpha$ and $\beta$ into inaccessible degrees of freedom. This process — decoherence — destroys the quantum coherence essential for computation.

Recurring Theme: Noise Is the Enemy. This chapter establishes the fundamental challenge that quantum error correction (QEC) must overcome. Every subsequent chapter in this part builds on this understanding: without QEC, quantum algorithms of any practical depth would produce noise, not signal. The central miracle of QEC is that we can encode a logical qubit into multiple physical qubits and detect and correct errors without measuring the logical state.

22.1.2 The Exponential Sensitivity of Quantum Information

To appreciate the severity of quantum noise, consider a quantum circuit of depth $d$ operating on $n$ qubits. Suppose each gate has fidelity $F$ (i.e., error rate $\epsilon = 1 - F$ per gate). The probability of the circuit producing the correct output is approximately:

$$P_{\text{correct}} \approx (1 - \epsilon)^{d \cdot n_{\text{gates/layer}}} \approx e^{-\epsilon \cdot d \cdot n_{\text{gates/layer}}}$$

For Shor's algorithm factoring a 2048-bit RSA number, the circuit requires approximately $d \cdot n_{\text{gates}} \sim 10^{10}$ gates. At $\epsilon = 10^{-3}$ (current state-of-the-art two-qubit gate error):

$$P_{\text{correct}} \approx e^{-10^{-3} \times 10^{10}} \approx e^{-10^7} \approx 0$$

Without error correction, the probability of correct output is exponentially suppressed. This is not a minor inconvenience — it is a fundamental barrier that makes quantum computing impossible without error correction.

22.1.3 The Error Budget Perspective

A useful way to think about quantum error correction is in terms of error budgets. A quantum algorithm requires a total logical error rate below some threshold $\epsilon_L$. For Shor's algorithm, $\epsilon_L \sim 10^{-6}$ (one error per million logical operations). The error budget decomposes as:

$$\epsilon_L = \epsilon_{\text{gate}} + \epsilon_{\text{measurement}} + \epsilon_{\text{idle}} + \epsilon_{\text{leakage}}$$

Each component must be suppressed below $\epsilon_L / 4$ or so. This requires multiple layers of error correction, each adding overhead.

22.2 Types of Quantum Errors

Quantum errors are modeled as completely positive, trace-preserving (CPTP) maps acting on the density matrix $\rho$. We classify the elementary error channels and derive their properties in detail.

22.2.1 Bit Flip (Pauli $X$)

The bit flip error interchanges $|0\rangle \leftrightarrow |1\rangle$:

$$X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}.$$

A bit flip channel with probability $p$ acts as:

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

Worked Example 22.1: Bit Flip on a Superposition

Consider $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ with $\rho = |\psi\rangle\langle\psi|$. After a bit flip channel with probability $p$:

$$\mathcal{E}_X(\rho) = (1-p)\begin{pmatrix} |\alpha|^2 & \alpha\beta^* \\ \alpha^*\beta & |\beta|^2 \end{pmatrix} + p\begin{pmatrix} |\beta|^2 & \alpha\beta^* \\ \alpha^*\beta & |\alpha|^2 \end{pmatrix}$$

$$= \begin{pmatrix} (1-p)|\alpha|^2 + p|\beta|^2 & \alpha\beta^* \\ \alpha^*\beta & p|\alpha|^2 + (1-p)|\beta|^2 \end{pmatrix}$$

The off-diagonal elements (coherences) are preserved! The bit flip only affects the populations. This is because $X\rho X$ swaps the populations but preserves the off-diagonal terms (since $X|\psi\rangle = \beta|0\rangle + \alpha|1\rangle$).

22.2.2 Phase Flip (Pauli $Z$)

The phase flip applies a relative phase of $-1$ to $|1\rangle$:

$$Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}.$$

The phase flip channel is:

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

Worked Example 22.2: Phase Flip on a Superposition

For $|\psi\rangle = (|0\rangle + |1\rangle)/\sqrt{2} = |+\rangle$:

$$\mathcal{E}_Z(|+\rangle\langle+|) = (1-p)|+\rangle\langle+| + p|-\rangle\langle-|$$

The density matrix becomes a mixture of $|+\rangle$ and $|-\rangle$, reducing the off-diagonal coherence from 1 to $1-2p$. The purity decreases as $p$ increases, reaching $1/2$ (maximally mixed) at $p = 1/2$.

Phase flips have no classical analog. They arise from fluctuations in the qubit energy splitting (e.g., magnetic field noise for spin qubits, charge noise for superconducting qubits). Phase errors are often the dominant error mechanism because dephasing times ($T_2$) are typically much shorter than relaxation times ($T_1$).

Common Misconception: "Phase flips don't affect computational basis states, so they're not important." This is true for classical information, but for quantum information stored in superpositions, phase flips are devastating. A phase flip on $|+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}$ produces $|-\rangle = (|0\rangle - |1\rangle)/\sqrt{2}$ — a completely orthogonal state. Phase errors are the quantum analog of a bit flip for states encoded in the $X$-basis.

22.2.3 Combined Bit-Phase Flip (Pauli $Y$)

Since $Y = iXZ$, a $Y$ error simultaneously flips both bit and phase:

$$Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}.$$

The $Y$ channel:

$$\mathcal{E}_Y(\rho) = (1-p)\rho + p Y\rho Y.$$

Key insight: Since any single-qubit error can be decomposed as a linear combination of $I$, $X$, $Y$, and $Z$, correcting all three Pauli errors ($X$, $Y$, $Z$) is sufficient to correct arbitrary single-qubit errors. This is the foundation of quantum error correction — we need only correct a discrete set of errors, not a continuum.

22.2.4 Amplitude Damping

Amplitude damping models energy relaxation — the qubit spontaneously decays from the excited state $|1\rangle$ to the ground state $|0\rangle$ by emitting a photon (or phonon) into the environment. The Kraus operators are:

$$E_0 = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-\gamma} \end{pmatrix}, \quad E_1 = \begin{pmatrix} 0 & \sqrt{\gamma} \\ 0 & 0 \end{pmatrix},$$

where $\gamma = 1 - e^{-t/T_1}$ is the damping probability. The channel is:

$$\mathcal{E}_{\text{AD}}(\rho) = E_0 \rho E_0^\dagger + E_1 \rho E_1^\dagger.$$

Detailed derivation:

The amplitude damping channel arises from the interaction of a qubit with a zero-temperature thermal bath. The Hamiltonian is:

$$H_{\text{int}} = g(a^\dagger |0\rangle\langle 1| + a |1\rangle\langle 0|)$$

where $a^\dagger$ and $a$ are the bath creation and annihilation operators. Under the Born-Markov approximation, the time evolution gives:

$$|0\rangle\langle 0| \to |0\rangle\langle 0| \quad \text{(ground state is stable)}$$

$$|1\rangle\langle 1| \to (1-\gamma)|1\rangle\langle 1| + \gamma|0\rangle\langle 0| \quad \text{(excited state decays)}$$

$$|0\rangle\langle 1| \to \sqrt{1-\gamma}|0\rangle\langle 1| \quad \text{(coherence decays)}$$

The Kraus operators capture this dynamics: $E_0$ preserves the state with probability $\sqrt{1-\gamma}$ on the excited component, while $E_1$ annihilates the excited state with probability $\sqrt{\gamma}$.

Properties of amplitude damping: - Non-unital: $\mathcal{E}_{\text{AD}}(I/2) \neq I/2$. The channel drives the state toward $|0\rangle\langle 0|$, shrinking the Bloch sphere asymmetrically. - Irreversible: Unlike depolarizing, the information leaked to the environment cannot be recovered without access to the bath. - Physically realistic: This is the dominant error for superconducting qubits and other systems where $T_1$ is finite.

Common Misconception: "Amplitude damping only affects the $|1\rangle$ state, so we can avoid it by encoding in the $|0\rangle$ state." While it's true that amplitude damping only causes population transfer $|1\rangle \to |0\rangle$, any superposition $\alpha|0\rangle + \beta|1\rangle$ has its coherence reduced: $\rho_{01} \to \sqrt{1-\gamma}\,\rho_{01}$. A state like $|+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}$ loses all its quantum advantage under amplitude damping — after time $t \gg T_1$, it becomes $|0\rangle$, a classical ground state with no phase information. You cannot "avoid" amplitude damping by choice of encoding because any useful quantum state must contain a superposition of $|0\rangle$ and $|1\rangle$.

22.2.5 Phase Damping (Pure Dephasing)

Phase damping describes the loss of phase coherence without energy relaxation. The Kraus operators are:

$$E_0 = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-\lambda} \end{pmatrix}, \quad E_1 = \begin{pmatrix} 0 & 0 \\ 0 & \sqrt{\lambda} \end{pmatrix},$$

with $\lambda = 1 - e^{-t/T_\phi}$ where $T_\phi$ is the pure dephasing time. The relationship between $T_1$, $T_2$, and $T_\phi$ is:

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

Derivation of the $T_1$-$T_2$ relationship:

For a qubit with both relaxation and dephasing, the Bloch vector components evolve as:

$$\langle X \rangle(t) = \langle X \rangle(0) e^{-t/T_2}$$ $$\langle Y \rangle(t) = \langle Y \rangle(0) e^{-t/T_2}$$ $$\langle Z \rangle(t) = \langle Z \rangle(0) e^{-t/T_1} + (1 - e^{-t/T_1})\langle Z \rangle_{\text{eq}}$$

where $\langle Z \rangle_{\text{eq}}$ is the equilibrium value (0 for zero temperature). The transverse components ($X, Y$) decay with rate $1/T_2$, while the longitudinal component ($Z$) decays with rate $1/T_1$.

The total dephasing rate $1/T_2$ has two contributions: (1) the longitudinal relaxation $1/(2T_1)$, which also causes dephasing because a qubit that flips from $|1\rangle$ to $|0\rangle$ also loses its phase, and (2) pure dephasing $1/T_\phi$, which destroys phase without flipping. This gives:

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

For superconducting qubits, $T_\phi$ is often limited by $1/f$ charge noise or flux noise, making $T_2 \ll 2T_1$.

22.2.6 Depolarizing Channel

The depolarizing channel is the "white noise" of quantum errors. With probability $p$, the qubit is replaced by the maximally mixed state $I/2$:

$$\mathcal{E}_{\text{dep}}(\rho) = (1-p)\rho + \frac{p}{3}(X\rho X + Y\rho Y + Z\rho Z).$$

Alternative formulation: The depolarizing channel can be written as:

$$\mathcal{E}_{\text{dep}}(\rho) = (1 - \frac{4p}{3})\rho + \frac{4p}{3} \cdot \frac{I}{2}$$

This shows that with probability $1 - 4p/3$, the state is unchanged, and with probability $4p/3$, it is replaced by the maximally mixed state. For $p = 3/4$, the output is always $I/2$ regardless of the input — all information is destroyed.

Properties of the depolarizing channel: - Unital: $\mathcal{E}_{\text{dep}}(I) = I$. The maximally mixed state is a fixed point. - Isotropic: All directions on the Bloch sphere are treated equally. The Bloch vector is uniformly shrunk by a factor of $(1 - 4p/3)$. - Pauli-twirled: Any single-qubit channel can be converted to a depolarizing channel by Pauli twirling, which averages over all possible Pauli frame changes.

The depolarizing channel is a useful simplified model because any single-qubit error can be expanded in the Pauli basis. It is the standard benchmark for gate fidelities.

Try It Yourself: Verify that the depolarizing channel with $p = 1/4$ sends any input state to $I/2$. Compute $\mathcal{E}_{\text{dep}}(\rho)$ for $\rho = |0\rangle\langle 0|$, $\rho = |+\rangle\langle+|$, and $\rho = I/2$, and confirm that all outputs are $I/2$.

Try it Yourself: Simulating Noise Channels. Write a Python function that takes a 2×2 density matrix $\rho$ and a noise channel specification (channel type and parameter), and returns the output density matrix. Implement the bit flip, phase flip, depolarizing, amplitude damping, and phase damping channels. Then, starting from the state $|+\rangle$, apply each channel with parameter $p = 0.2$ and compute: (a) the purity $\text{Tr}(\rho_{\text{out}}^2)$, (b) the fidelity $F = \langle+|\rho_{\text{out}}|+\rangle$, and (c) the Bloch vector $(\langle X\rangle, \langle Y\rangle, \langle Z\rangle)$. Which channel reduces purity the most? Which preserves coherence? Verify your answers using Qiskit's DensityMatrix.evolve() method with the built-in noise channel objects from qiskit_aer.noise.

22.3 Decoherence: $T_1$ and $T_2$

22.3.1 Relaxation Time $T_1$

$T_1$ is the characteristic timescale for a qubit in the excited state $|1\rangle$ to decay to the ground state $|0\rangle$. The population of $|1\rangle$ evolves as:

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

Physical mechanisms: - Superconducting qubits: Energy relaxation via spontaneous emission of microwave photons through the coupling capacitor. The quality factor $Q$ of the resonator and the Purcell effect determine $T_1$. - Trapped ions: Spontaneous emission of optical photons from the excited electronic state. $T_1$ can exceed seconds for metastable states. - Spin qubits: Electron spin relaxation via spin-orbit coupling and phonon emission. $T_1$ ranges from microseconds to milliseconds depending on the material.

Derivation of exponential decay from Fermi's Golden Rule:

The transition rate from $|1\rangle$ to $|0\rangle$ is given by Fermi's Golden Rule:

$$\Gamma_1 = \frac{1}{T_1} = \frac{2\pi}{\hbar} |g|^2 \rho(\omega_{01})$$

where $g$ is the coupling strength to the bath mode and $\rho(\omega_{01})$ is the density of states at the qubit frequency. This gives exponential decay:

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

22.3.2 Dephasing Time $T_2$

$T_2$ is the characteristic timescale over which a superposition $|+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}$ loses phase coherence. The off-diagonal elements of the density matrix decay as:

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

Physical mechanisms of pure dephasing ($T_\phi$): - Charge noise: Fluctuating electric fields shift the qubit frequency. For transmon qubits, the charge dispersion (dependence of frequency on charge) couples charge noise to dephasing. - Flux noise: Magnetic flux fluctuations shift the frequency of flux-tunable qubits. This is the dominant dephasing mechanism for flux qubits. - Critical current noise: Fluctuations in the Josephson energy cause frequency shifts. - $1/f$ noise: Low-frequency noise with spectral density $S(f) \propto 1/f$ is ubiquitous in solid-state qubits and causes dephasing that is not purely exponential (Gaussian decay at short times, exponential at long times).

22.3.3 The Bloch-Redfield Master Equation

The dynamics of a qubit coupled to a thermal bath are described by the Lindblad master equation:

$$\frac{d\rho}{dt} = -\frac{i}{\hbar}[H, \rho] + \sum_k \left(L_k \rho L_k^\dagger - \frac{1}{2}\{L_k^\dagger L_k, \rho\}\right),$$

where $L_k$ are Lindblad (jump) operators. For a single qubit with relaxation and dephasing:

$$L_1 = \sqrt{\frac{1}{T_1}} \begin{pmatrix} 0 & 1 \\ 0 & 0 \end{pmatrix}, \quad L_2 = \sqrt{\frac{1}{2T_\phi}} \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}.$$

Worked Example 22.3: Solving the Lindblad Equation

For a qubit with $H = 0$ (no Hamiltonian evolution), the density matrix elements evolve as:

$$\frac{d\rho_{00}}{dt} = \frac{1}{T_1}\rho_{11} \quad \text{(population flows from |1⟩ to |0⟩)}$$

$$\frac{d\rho_{11}}{dt} = -\frac{1}{T_1}\rho_{11} \quad \text{(excited state decays)}$$

$$\frac{d\rho_{01}}{dt} = -\frac{1}{T_2}\rho_{01} \quad \text{(coherence decays)}$$

The solutions are:

$$\rho_{00}(t) = 1 - (1 - \rho_{00}(0))e^{-t/T_1}$$

$$\rho_{11}(t) = \rho_{11}(0) e^{-t/T_1}$$

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

For the initial state $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$:

$$\rho(t) = \begin{pmatrix} |\alpha|^2 + |\beta|^2(1 - e^{-t/T_1}) & \alpha\beta^* e^{-t/T_2} \\ \alpha^*\beta e^{-t/T_2} & |\beta|^2 e^{-t/T_1} \end{pmatrix}$$

At long times ($t \gg T_1, T_2$): $\rho \to |0\rangle\langle 0|$ — the qubit relaxes to the ground state.

22.3.4 Echo Techniques: Extending $T_2$

Hahn echo is a pulse sequence that refocuses low-frequency noise, extending the effective dephasing time:

Free induction decay:    |+⟩ ──(wait t)── Measure          T₂*

Hahn echo:               |+⟩ ──(wait t/2)── X ──(wait t/2)── Measure   T₂

Spin echo sequence:
    ┌─────────┐         ┌─────────┐
π/2: ─┤  R_y   ├──(wait)──┤  R_x   ├──(wait)── Measure
    └─────────┘         └─────────┘

The $X$ pulse flips the sign of accumulated phase, causing low-frequency noise to cancel. The Hahn echo measures $T_2$, which is typically much longer than $T_2^*$ (the free induction decay time).

Dynamical decoupling extends this idea by applying multiple refocusing pulses:

$$T_2^* < T_2^{\text{Hahn}} < T_2^{\text{CPMG}} < T_2^{\text{XY8}} < 2T_1$$

where CPMG (Carr-Purcell-Meiboom-Gill) and XY8 are multi-pulse sequences that further suppress dephasing.

22.4 Gate Infidelity

A quantum gate is a unitary operation $U_{\text{ideal}}$. In reality, the implemented channel $\mathcal{E}$ deviates from the ideal. The average gate fidelity quantifies this deviation:

$$F_{\text{avg}}(\mathcal{E}, U) = \int d\psi \langle\psi| U^\dagger \mathcal{E}(|\psi\rangle\langle\psi|) U |\psi\rangle,$$

where the integral is over the Haar measure on pure states. The infidelity is $1 - F_{\text{avg}}$.

22.4.1 Relationship Between Fidelity Measures

For a single-qubit gate, the fidelity relates to the entanglement fidelity $F_e$ via:

$$F_{\text{avg}} = \frac{d F_e + 1}{d + 1} = \frac{2 F_e + 1}{3}$$

where $d = 2$ for a single qubit. The entanglement fidelity $F_e = \langle \Phi^+ | (\mathcal{E} \otimes I)(|\Phi^+\rangle\langle\Phi^+|) | \Phi^+ \rangle$ measures how well the channel preserves a maximally entangled state.

For a depolarizing channel with error rate $p$:

$$F_{\text{avg}} = 1 - \frac{4p}{3} \cdot \frac{1}{2} = 1 - \frac{2p}{3}$$

Wait — let me be precise. The average gate fidelity for a depolarizing channel $\mathcal{E}_{\text{dep}}$ with parameter $p$ is:

$$F_{\text{avg}}(\mathcal{E}_{\text{dep}}, I) = 1 - p + p \cdot \frac{1}{2} = 1 - \frac{2p}{3}$$

Hmm, that's not right either. Let me compute directly.

For a single-qubit depolarizing channel $\mathcal{E}(\rho) = (1-p)\rho + \frac{p}{3}(X\rho X + Y\rho Y + Z\rho Z)$, the average gate fidelity with the identity is:

$$F_{\text{avg}} = 1 - \frac{2p}{3}$$

This follows from the general relation $F_{\text{avg}} = \frac{d F_e + 1}{d+1}$ where $F_e = 1 - \frac{4p}{3} \cdot \frac{1}{2} = 1 - \frac{2p}{3}$...

Actually, let me just use the standard result. For a depolarizing channel on $d$-dimensional system with $\mathcal{E}(\rho) = (1-p)\rho + p \frac{I}{d}$:

$$F_{\text{avg}} = 1 - \frac{d(d-1)}{d+1} \cdot \frac{p}{d^2} = 1 - \frac{d-1}{d(d+1)} p \cdot d^2$$

No, this is getting confused. The standard result is:

For a single-qubit depolarizing channel $\mathcal{E}(\rho) = (1-p)\rho + \frac{p}{3}(X\rho X + Y\rho Y + Z\rho Z)$:

$$F_{\text{avg}} = 1 - \frac{2p}{3}$$

Equivalently, the infidelity is $r = \frac{2p}{3}$.

22.4.2 Current State-of-the-Art Gate Fidelities (2024–2025)

These numbers are impressive, but a single logical operation in a deep algorithm may require thousands of physical gates. At 99.9% fidelity per gate, a circuit of 1,000 gates has a success probability of $(0.999)^{1000} \approx 0.37$ — already worse than a coin flip. For 10,000 gates, it drops below $5 \times 10^{-5}$. Error correction is mandatory.

22.4.3 Error Budgeting for Quantum Algorithms

Worked Example 22.4: Error Budget for a Simple Algorithm

Consider a 10-qubit circuit with 100 CNOT gates, 200 single-qubit gates, and 10 measurements. Using typical error rates:

• Single-qubit gate error: $\epsilon_{1q} = 10^{-4}$
• Two-qubit gate error: $\epsilon_{2q} = 5 \times 10^{-3}$
• Measurement error: $\epsilon_m = 10^{-2}$

Total circuit error (rough estimate):

$$\epsilon_{\text{total}} \approx 200 \times 10^{-4} + 100 \times 5 \times 10^{-3} + 10 \times 10^{-2} = 0.02 + 0.5 + 0.1 = 0.62$$

The circuit has a 62% error rate — far too high for any useful computation. Two-qubit gate errors dominate the budget, contributing 50 percentage points.

Implication: To make this circuit work, we need error correction that suppresses the two-qubit gate error by at least 3 orders of magnitude (from $5 \times 10^{-3}$ to $5 \times 10^{-6}$).

22.5 The Quantum Noise Channel Formalism

22.5.1 Kraus Operator Representation

Any physically admissible quantum operation (CPTP map) can be written in Kraus form:

$$\mathcal{E}(\rho) = \sum_{k=1}^K E_k \rho E_k^\dagger,$$

with the completeness condition:

$$\sum_{k=1}^K E_k^\dagger E_k = I.$$

Proof of trace preservation: If the completeness condition holds, then:

$$\text{Tr}[\mathcal{E}(\rho)] = \text{Tr}\left[\sum_k E_k \rho E_k^\dagger\right] = \sum_k \text{Tr}[E_k^\dagger E_k \rho] = \text{Tr}\left[\sum_k E_k^\dagger E_k \rho\right] = \text{Tr}[\rho] = 1$$

Proof of complete positivity: For any auxiliary system $A$ and positive semidefinite operator $\sigma_{SA}$, we need $\mathcal{E} \otimes I_A(\sigma_{SA}) \geq 0$. Since $\sum_k (E_k \otimes I_A) \sigma_{SA} (E_k^\dagger \otimes I_A)$ is a sum of positive semidefinite operators, it is positive semidefinite. $\square$

The Kraus operators $E_k$ are not unique — any unitary remixing $F_j = \sum_k U_{jk} E_k$ yields the same channel, where $U$ is a unitary matrix.

22.5.2 The Chi Matrix Representation

An alternative representation expands the channel in a fixed operator basis. Using the Pauli basis $\{I, X, Y, Z\}$ for a single qubit:

$$\mathcal{E}(\rho) = \sum_{i,j=0}^3 \chi_{ij} P_i \rho P_j,$$

where $P_0 = I$, $P_1 = X$, $P_2 = Y$, $P_3 = Z$, and $\chi$ is a $4 \times 4$ positive semidefinite matrix. The trace-preserving condition is $\sum_{i,j} \chi_{ij} P_j P_i = I$.

Worked Example 22.5: Chi Matrix of the Depolarizing Channel

For the depolarizing channel $\mathcal{E}(\rho) = (1-p)\rho + \frac{p}{3}(X\rho X + Y\rho Y + Z\rho Z)$, the chi matrix is:

$$\chi = \begin{pmatrix} 1-p & 0 & 0 & 0 \\ 0 & p/3 & 0 & 0 \\ 0 & 0 & p/3 & 0 \\ 0 & 0 & 0 & p/3 \end{pmatrix}$$

This diagonal form reflects the fact that the depolarizing channel treats all three Pauli errors equally.

22.5.3 Composition of Noise Channels

Noise channels compose sequentially. If a circuit has gates $U_1, U_2, \ldots, U_n$, each followed by noise channel $\mathcal{E}_k$, the total channel is:

$$\mathcal{E}_{\text{total}} = \mathcal{E}_n \circ U_n \circ \cdots \circ \mathcal{E}_2 \circ U_2 \circ \mathcal{E}_1 \circ U_1$$

For small noise, the total error is approximately additive:

$$\epsilon_{\text{total}} \approx \sum_k \epsilon_k$$

For larger noise, interactions between channels matter. Two depolarizing channels with parameters $p_1$ and $p_2$ compose to give a depolarizing channel with parameter:

$$p_{\text{total}} = p_1 + p_2 - \frac{4}{3}p_1 p_2$$

For small $p_1, p_2$, this is approximately $p_1 + p_2$.

22.5.4 Simulating Noise Channels in Qiskit

The following code constructs and simulates the depolarizing channel and amplitude damping channel on a single qubit, visualizing the effect on the Bloch sphere.

import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.quantum_info import (
    Operator, Statevector, DensityMatrix,
    Kraus, average_gate_fidelity, process_fidelity
)
from qiskit_aer.noise import NoiseModel, depolarizing_error, amplitude_damping_error
import matplotlib.pyplot as plt

# ── Construct a depolarizing channel with p = 0.1 ──
p_dep = 0.1
depol_error = depolarizing_error(p_dep, 1)  # 1-qubit depolarizing error
print("Depolarizing channel Kraus operators:")
for i, kraus in enumerate(depol_error.to_quantumchannel().data):
    print(f"E_{i} =\n{np.round(kraus, 4)}")

# ── Construct an amplitude damping channel with gamma = 0.2 ──
gamma = 0.2
ad_error = amplitude_damping_error(gamma, 1)
print("\nAmplitude damping channel Kraus operators:")
for i, kraus in enumerate(ad_error.to_quantumchannel().data):
    print(f"E_{i} =\n{np.round(kraus, 4)}")

# ── Apply noise to a test state ──
test_state = Statevector.from_label('1')  # Start in |1>
print(f"\nInitial state |1>: {test_state.data}")

# Apply depolarizing channel
rho_init = DensityMatrix(test_state)
rho_depol = rho_init.evolve(depol_error)
print(f"After depolarizing (p={p_dep}):\n{np.round(rho_depol.data, 4)}")

# Apply amplitude damping channel
rho_ad = rho_init.evolve(ad_error)
print(f"After amplitude damping (gamma={gamma}):\n{np.round(rho_ad.data, 4)}")

# ── Build a noise model for circuit simulation ──
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(depol_error, ['x', 'sx', 'rz', 'cx'])
noise_model.add_all_qubit_quantum_error(ad_error, ['measure'])

# ── Simulate a simple circuit with noise ──
qc = QuantumCircuit(1, 1)
qc.h(0)           # Create superposition
qc.barrier()
qc.measure(0, 0)

simulator = AerSimulator()
result_noiseless = simulator.run(qc, shots=1024).result()
counts_noiseless = result_noiseless.get_counts()

result_noisy = simulator.run(qc, noise_model=noise_model, shots=1024).result()
counts_noisy = result_noisy.get_counts()

print(f"\nNoiseless counts: {counts_noiseless}")
print(f"Noisy counts: {counts_noisy}")

# ── Compute gate fidelity for a noisy X gate ──
ideal_x = Operator.from_label('X')
noisy_x_gate = ideal_x.compose(
    Kraus(depol_error.to_quantumchannel().data)
)
fid = average_gate_fidelity(noisy_x_gate, ideal_x)
print(f"\nAverage gate fidelity of noisy X gate: {fid:.6f}")
print(f"Infidelity: {1 - fid:.6e}")

Expected output insights: The depolarizing channel mixes the state toward $I/2$, reducing the purity $\text{Tr}(\rho^2)$. The amplitude damping channel asymmetrically drives population toward $|0\rangle$. The noisy circuit simulation shows measurement statistics deviating from the ideal 50/50 split.

22.6 Why Classical Error Correction Fails for Quantum

Classical error correction (Chapter 23) relies on three assumptions that quantum mechanics violates:

22.6.1 The No-Cloning Theorem

Classical repetition codes copy a bit: $0 \to 000$, $1 \to 111$. The no-cloning theorem (Wootters–Zurek, Dieks, 1982) proves that no unitary operation can copy an arbitrary unknown quantum state:

$$\not\exists U : U(|\psi\rangle \otimes |0\rangle) = |\psi\rangle \otimes |\psi\rangle \quad \forall |\psi\rangle.$$

Proof: Suppose $U$ clones $|\psi\rangle$ and $|\phi\rangle$. Then:

$$U(|\psi\rangle \otimes |0\rangle) = |\psi\rangle \otimes |\psi\rangle$$ $$U(|\phi\rangle \otimes |0\rangle) = |\phi\rangle \otimes |\phi\rangle$$

Taking the inner product:

$$\langle\psi|\phi\rangle = (\langle\psi|\phi\rangle)^2$$

This implies $\langle\psi|\phi\rangle \in \{0, 1\}$. Thus $U$ can only clone orthogonal states — not arbitrary superpositions. We cannot simply make redundant copies of a qubit. $\square$

Implication for QEC: We cannot encode quantum information by simply copying it. Instead, we must encode it into entangled states that provide redundancy without copying.

22.6.2 Measurement Destroys Superposition

Classical error correction measures the data to detect errors. In quantum mechanics, measuring a superposition $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ in the computational basis collapses it to $|0\rangle$ or $|1\rangle$, destroying the very information we wish to protect.

Resolution: QEC must detect errors without learning the logical state. This is achieved by measuring syndromes — parity checks that reveal information about which error occurred, without revealing anything about the encoded state.

Worked Example 22.6: Syndrome Measurement Without Disturbing the State

Consider the 3-qubit repetition code encoding $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ as $\alpha|000\rangle + \beta|111\rangle$. To detect a bit flip on the first qubit, we measure the parity $Z_1 Z_2$:

$$Z_1 Z_2 |000\rangle = +|000\rangle, \quad Z_1 Z_2 |111\rangle = +|111\rangle$$

$$Z_1 Z_2 |100\rangle = -|100\rangle, \quad Z_1 Z_2 |011\rangle = -|011\rangle$$

The eigenvalue $+1$ means "no error on qubits 1 and 2" (or a simultaneous flip on both). The eigenvalue $-1$ means "an error on qubit 1 or qubit 2." Crucially, measuring $Z_1 Z_2$ does not distinguish $|000\rangle$ from $|111\rangle$ — it reveals only the error, not the encoded state.

22.6.3 Errors Are Continuous

A classical bit flip is discrete: 0 becomes 1, or vice versa. A quantum error can be an infinitesimal rotation:

$$|\psi\rangle \to \cos(\epsilon)|\psi\rangle + \sin(\epsilon)|\psi_\perp\rangle.$$

For small $\epsilon$, this is a "small" error. How can we correct a continuum of possible errors with a finite set of correction operations?

Resolution — the digitization of quantum errors: This is one of the deepest insights in quantum information. Any single-qubit error can be expanded in the Pauli basis:

$$E = e_0 I + e_1 X + e_2 Y + e_3 Z$$

Therefore, correcting $X$, $Y$, and $Z$ errors automatically corrects any linear combination — including infinitesimal rotations. The error syndrome measurement projects the continuous error onto one of the discrete Pauli errors, digitizing it.

Worked Example 22.7: Digitization of a Small Rotation Error

Consider a small rotation error $E = R_X(\epsilon) \approx I - i\frac{\epsilon}{2}X$ applied to $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$:

$$E|\psi\rangle = \left(I - i\frac{\epsilon}{2}X\right)|\psi\rangle = |\psi\rangle - i\frac{\epsilon}{2}X|\psi\rangle$$

This is a superposition of "no error" (coefficient $\approx 1$) and "$X$ error" (coefficient $\approx \epsilon/2$). When we measure the error syndrome, the state collapses to either "no error" (with probability $\approx 1 - \epsilon^2/4$) or "$X$ error" (with probability $\approx \epsilon^2/4$). In either case, we know exactly what correction to apply: nothing or $X$.

This digitization is why we only need to correct a discrete set of Pauli errors — the measurement process takes care of the rest.

Recurring Theme: Quantum Is Linear Algebra, Not Magic. The digitization of continuous errors into discrete Pauli errors is a consequence of the linearity of quantum mechanics. The error $E$ is a linear combination of Pauli operators, and the syndrome measurement projects onto one of them. This is a mathematical fact, not a quantum mystery.

22.7 The Threshold Theorem: Intuition

The quantum threshold theorem (Aharonov–Ben-Or, Knill–Laflamme–Zurek, Kitaev, 1996–1997) states:

If the physical error rate per gate is below a critical threshold $p_{\text{th}}$, then an arbitrarily long quantum computation can be performed with arbitrarily small logical error rate, at the cost of a polylogarithmic overhead in qubits and gates.

22.7.1 Intuitive Derivation

The intuition is recursive: encode logical qubits in a code that corrects one error. Then encode those logical qubits in another layer of the same code (concatenation). Each layer suppresses the logical error rate from $p$ to $O(p^2)$.

Level 0: Physical qubits with error rate $p$.

Level 1: Encode each logical qubit in a code correcting 1 error (e.g., 7-qubit Steane code). The logical error rate is approximately:

$$p^{(1)} = c \cdot p^2$$

where $c$ is a constant that depends on the code (roughly the number of ways 2 errors can occur).

Level 2: Encode each Level-1 logical qubit in another copy of the code. The logical error rate becomes:

$$p^{(2)} = c \cdot (p^{(1)})^2 = c^3 p^4$$

Level $L$: After $L$ levels of concatenation:

$$p^{(L)} = \frac{(cp)^{2^L}}{c}$$

If $cp < 1$ (i.e., $p < 1/c$), then $p^{(L)} \to 0$ doubly exponentially fast. This is the threshold: $p_{\text{th}} \approx 1/c$.

Worked Example 22.8: Threshold Calculation for the Steane Code

The [[7, 1, 3]] Steane code uses 7 physical qubits to encode 1 logical qubit, correcting any single-qubit error. The constant $c$ is approximately $\binom{7}{2} \approx 21$ (the number of ways 2 errors can occur on 7 qubits, up to leading order).

The threshold is approximately:

$$p_{\text{th}} \approx \frac{1}{c} \approx \frac{1}{21} \approx 4.8\%$$

More precise calculations accounting for fault-tolerant gate constructions give a threshold of about $10^{-4}$ to $10^{-3}$ for the Steane code. The surface code (Chapter 25) achieves a higher threshold of about $1\%$.

22.7.2 Overhead Scaling

To achieve a logical error rate of $\epsilon_L$ starting from a physical error rate $p$, the number of physical qubits per logical qubit scales as:

$$n_{\text{physical}} / n_{\text{logical}} = O\left(\left(\frac{\log(1/\epsilon_L)}{\log(1/p)}\right)^2\right)$$

for the surface code with code distance $d$.

Concrete numbers: For $p = 10^{-3}$ (current two-qubit gate error) and target $\epsilon_L = 10^{-6}$:

• Code distance $d \approx 2 \times \frac{\log(1/\epsilon_L)}{\log(1/p)} \approx 2 \times \frac{6}{3} = 4$... This is too rough. More precisely, for the surface code:

$$\epsilon_L \approx 0.1 \left(\frac{p}{p_{\text{th}}}\right)^{(d+1)/2}$$

With $p = 10^{-3}$ and $p_{\text{th}} = 10^{-2}$:

$$10^{-6} = 0.1 \times (0.1)^{(d+1)/2}$$

$$(d+1)/2 = \frac{\log(10^{-5})}{\log(0.1)} = 5$$

$$d = 9$$

A surface code with distance $d = 9$ requires approximately $2d^2 = 162$ physical qubits per logical qubit. For a factoring algorithm requiring 1000 logical qubits, this means $\sim 162,000$ physical qubits — plus additional qubits for magic state distillation and other overhead.

Recurring Theme: We're at the Beginning. Current quantum computers have $O(100)$ noisy qubits. Fault-tolerant quantum computing requires $O(10^5)$–$O(10^8)$ high-quality qubits. The gap is enormous, but the threshold theorem guarantees that the path is well-defined — we need better hardware, not new theory.

22.7.3 The Threshold Theorem: Formal Statement

Theorem (Threshold Theorem): For a quantum error-correcting code with code distance $d$, if the physical error rate per location (gate, measurement, or idle) satisfies $p < p_{\text{th}}$, then a logical circuit of size $S$ can be simulated with logical error rate at most $\epsilon$ using:

$$O\left(S \cdot \text{polylog}(S/\epsilon)\right)$$

physical operations, provided $d = O(\log(S/\epsilon))$.

The key assumptions are: 1. Independent errors: Errors on different qubits are independent (not correlated across many qubits). 2. Bounded error rate: The physical error rate is below the threshold $p_{\text{th}}$. 3. Parallelizable operations: Error correction can be performed in parallel with computation.

Common Misconception: "The threshold theorem guarantees that quantum computers will work once we reach the threshold error rate." The threshold theorem is an existence proof, not an efficiency guarantee. It says that arbitrarily reliable computation is possible below the threshold, but the overhead can be enormous. At current two-qubit gate error rates of $\sim 10^{-3}$, the surface code requires $d \approx 17$ (roughly 1,000 physical qubits per logical qubit). For a useful algorithm requiring 1,000 logical qubits and $10^{10}$ logical gates, this means $\sim 10^{6}$ physical qubits running for $\sim 10^{15}$ physical gate operations. The threshold is necessary but not sufficient — we also need dramatic improvements in qubit count, gate speed, and qubit quality.

22.8 Current Hardware Error Rates

The following table summarizes approximate error rates for leading quantum computing platforms as of 2024–2025:

Key observations:

1. Two-qubit gate errors dominate: At $10^{-3}$–$10^{-2}$, they are 10–100× worse than single-qubit gate errors. This is the primary bottleneck for error correction.

2. Measurement errors are significant: At $10^{-2}$, readout errors are comparable to two-qubit gate errors. Error correction protocols must account for faulty measurements.

3. $T_1$ and $T_2$ vary widely: Superconducting qubits have $T_1 \sim 100$–$300\,\mu$s and $T_2 \sim 70$–$200\,\mu$s. Trapped ions have effectively infinite $T_1$ and $T_2$ (seconds to hours), but much slower gate times ($\sim 100\,\mu$s vs. $\sim 20$–$50$ ns for superconducting).

4. The threshold is within reach: Two-qubit gate errors of $10^{-3}$ are below the surface code threshold of $\sim 1\%$. The challenge is the overhead — millions of physical qubits per logical qubit for practical applications.

22.8.1 Error Rate Trends

Historical data shows steady improvement in gate fidelities:

• 2015: Two-qubit gate errors ~1% (best)
• 2019: Two-qubit gate errors ~0.5% (Google Sycamore)
• 2023: Two-qubit gate errors ~0.1% (IBM Heron, Google Sycamore improvements)
• 2024: Two-qubit gate errors ~0.05% (best demonstrations)

The improvement is approximately a factor of 2 every 2 years (similar to the original Moore's law for classical transistors, though the quantum analog is less predictable). If this trend continues, fault-tolerant quantum computing with practical applications becomes feasible in the 2030s.

22.8.2 Quantum Noise in Practice: A Survey of Real Hardware Error Rates

To ground the abstract error models in reality, we now survey the noise characteristics of four leading quantum computing platforms in detail. Understanding the specific error profiles of each technology is essential for designing error correction strategies that target the dominant failure modes.

IBM Superconducting Processors

IBM's Heron-class processors (2024–2025) use fixed-frequency transmon qubits coupled via tunable couplers. The key noise sources are:

• Relaxation ($T_1$): Transmon qubits relax via spontaneous emission through the readout resonator (Purcell effect) and dielectric loss in the Josephson junction. Typical $T_1 = 200$–$400\,\mu$s. The relaxation-limited gate fidelity for a gate of duration $\tau$ is $F_{\text{relax}} \approx e^{-\tau/T_1}$.

• Dephasing ($T_2$): Dominated by $1/f$ flux noise and charge noise. Typical $T_2^{\text{Hahn}} = 100$–$300\,\mu$s. The dephasing contribution to gate infidelity is $F_{\text{dephase}} \approx e^{-\tau/T_2}$.

• Crosstalk: Fixed-frequency transmons have relatively low spectral crosstalk, but residual $ZZ$ coupling between neighboring qubits causes phase errors. The tunable coupler architecture in Heron processors reduces this significantly compared to the earlier Eagle architecture.

• Leakage: Transmon qubits have anharmonicities $\alpha/2\pi \approx -300$ MHz. Two-qubit gates can excite the $|2\rangle$ state with probability $\sim 10^{-3}$–$10^{-2}$, creating leakage errors (discussed in detail in Section 22.11).

Google Superconducting Processors

Google's Willow processor (2024) uses flux-tunable transmon qubits. Key differences from IBM:

• Shorter coherence times but faster gates: $T_1 \approx 100\,\mu$s, $T_2 \approx 70\,\mu$s, but single-qubit gate times $\sim 25$ ns and two-qubit gate times $\sim 40$–$60$ ns. The ratio $T_1/\tau_{\text{gate}}$ determines the coherence-limited fidelity, and Google's fast gates partially compensate for shorter $T_1$.

• Lower two-qubit gate error: Google achieved two-qubit gate errors of $4 \times 10^{-3}$ on Willow, using careful calibration of the cross-resonance and echoed gates.

• Crosstalk: Flux-tunable qubits are susceptible to flux crosstalk, which can cause correlated dephasing on neighboring qubits.

IonQ and Quantinuum Trapped-Ion Processors

Trapped-ion qubits use the electronic states of individual ions (e.g., ${}^{171}$Yb$^+$ for IonQ, ${}^{171}$Yb$^+$ / ${}^{138}$Ba$^+$ for Quantinuum) confined in electromagnetic traps.

• Virtually infinite $T_1$: The excited electronic state has a radiative lifetime of seconds to years (depending on the transition), so relaxation is negligible.

• Long $T_2$: Coherence times of seconds to minutes are routine, limited by magnetic field fluctuations and laser phase noise. Hahn echo $T_2$ can exceed 10 seconds.

• Gate errors: Single-qubit gate errors $\sim 10^{-5}$–$10^{-4}$ are achieved through careful pulse shaping. Two-qubit gate errors ($\sim 10^{-3}$–$10^{-2}$) are dominated by motional mode heating and laser intensity fluctuations. The Mølmer–Sørensen gate entangles ions via their shared motional modes, and residual motional excitation causes gate infidelity.

• All-to-all connectivity: Ions in the same trap can be directly entangled regardless of their physical position, eliminating the need for SWAP networks. This dramatically reduces circuit depth for many algorithms.

• Slow gate times: Two-qubit gates take $\sim 100$–$500\,\mu$s, compared to $\sim 50$ ns for superconducting qubits. This means that despite longer coherence times, the ratio $T_2/\tau_{\text{2q}}$ is not dramatically better.

Detailed Comparison Table

Common Misconception: "Trapped-ion qubits are strictly better than superconducting qubits because they have longer coherence times." Coherence time alone does not determine computational power. The relevant figure of merit is the ratio $T_2 / \tau_{\text{gate}}$ — how many gate operations fit within a coherence window. For superconducting qubits, $T_2/\tau_{2q} \approx 100\,\mu\text{s} / 50\,\text{ns} = 2000$. For trapped ions, $T_2/\tau_{2q} \approx 10\,\text{s} / 200\,\mu\text{s} = 50{,}000$. While ions have a clear advantage in this metric, the slower gate speed means fewer operations per unit time, which affects algorithm runtime. The optimal platform depends on the specific application and the overhead of error correction.

Common Misconception: "The hardware with the lowest two-qubit gate error is the best for error correction." Gate error is necessary but not sufficient. Error correction also requires fast syndrome extraction, high measurement fidelity, low crosstalk, and scalable qubit count. A processor with $10^{-3}$ two-qubit gate error and fast, parallel syndrome measurement may outperform a processor with $10^{-4}$ two-qubit gate error but slow, serial measurement for practical fault-tolerant computation.

22.9 Simulating a Full Noise Model

The following Qiskit code constructs a realistic noise model incorporating $T_1$, $T_2$, gate errors, and readout errors, then simulates a Bell state preparation circuit.

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.noise import (
    NoiseModel,
    thermal_relaxation_error,
    depolarizing_error,
    ReadoutError
)
import numpy as np

# ── Physical parameters ──
T1 = 100e3    # 100 µs in ns
T2 = 70e3     # 70 µs in ns
gate_time_1q = 35   # 35 ns for single-qubit gate
gate_time_2q = 200  # 200 ns for two-qubit gate
p_1q = 1e-4         # single-qubit depolarizing probability
p_2q = 5e-3         # two-qubit depolarizing probability
p_readout = 0.02    # readout error probability

# ── Build noise model ──
noise_model = NoiseModel()

# Thermal relaxation for idle and gate operations
for qubit in range(2):
    # Idle error (applied during delays)
    idle_error = thermal_relaxation_error(
        t1=T1, t2=T2, time=gate_time_1q
    )
    noise_model.add_quantum_error(idle_error, 'id', [qubit])

    # Single-qubit gate error: combine thermal relaxation + depolarizing
    thermal_error = thermal_relaxation_error(
        t1=T1, t2=T2, time=gate_time_1q
    )
    depol_1q = depolarizing_error(p_1q, 1)
    combined_1q = thermal_error.compose(depol_1q)
    noise_model.add_all_qubit_quantum_error(
        combined_1q, ['x', 'sx', 'rz', 'h']
    )

# Two-qubit gate error
thermal_error_2q = thermal_relaxation_error(
    t1=T1, t2=T2, time=gate_time_2q
).expand(thermal_relaxation_error(
    t1=T1, t2=T2, time=gate_time_2q
))
depol_2q = depolarizing_error(p_2q, 2)
combined_2q = thermal_error_2q.compose(depol_2q)
noise_model.add_all_qubit_quantum_error(combined_2q, ['cx'])

# Readout error
for qubit in range(2):
    readout_error = ReadoutError([
        [1 - p_readout, p_readout],
        [p_readout, 1 - p_readout]
    ])
    noise_model.add_readout_error(readout_error, [qubit])

# ── Bell state circuit ──
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# ── Simulate ──
simulator = AerSimulator()
result_noiseless = simulator.run(qc, shots=8192).result()
result_noisy = simulator.run(qc, noise_model=noise_model, shots=8192).result()

counts_ideal = result_noiseless.get_counts()
counts_noisy = result_noisy.get_counts()

print("Ideal Bell state counts:")
print(counts_ideal)
print("\nNoisy Bell state counts:")
print(counts_noisy)

# ── Compute state fidelity ──
from qiskit.quantum_info import state_fidelity, Statevector

ideal_state = Statevector.from_label('00').evolve(
    QuantumCircuit(2).h(0).cx(0, 1)
)
# For noisy, we'd need tomography; here we just compare measurement statistics
p_ideal_00 = counts_ideal.get('00', 0) / 8192
p_noisy_00 = counts_noisy.get('00', 0) / 8192
print(f"\nP(00) ideal: {p_ideal_00:.4f}, noisy: {p_noisy_00:.4f}")

22.9.1 Analyzing the Noise Impact

Bell state fidelity under noise: The ideal Bell state $|\Phi^+\rangle = (|00\rangle + |11\rangle)/\sqrt{2}$ should give measurement outcomes 00 and 11 with equal probability 0.5. Under the noise model above:

• Depolarizing noise on the CNOT gate spreads probability to 01 and 10 outcomes.
• Amplitude damping preferentially drives $|1\rangle \to |0\rangle$, biasing toward the 00 outcome.
• Readout errors further scramble the measurement results.

The combined effect typically reduces the Bell state fidelity from 1.0 to 0.85–0.95, depending on the specific noise parameters. For deeper circuits, the fidelity drops dramatically.

22.10 Error Propagation and Correlated Errors

22.10.1 Error Propagation Through Gates

Quantum errors do not stay local — they propagate through entangling gates. A single error on one qubit can spread to multiple qubits through CNOT gates. This error propagation is one of the central challenges in quantum error correction: a circuit with $n$ CNOT gates can propagate a single-qubit error into an error affecting $O(n)$ qubits, potentially overwhelming the correction capability of the code.

Key propagation rules:

• Bit flip ($X$) through CNOT: $X$ on the control propagates to both control and target. $X$ on the target stays on the target.
• $\text{CNOT} \cdot (X \otimes I) = (X \otimes X) \cdot \text{CNOT}$

• $\text{CNOT} \cdot (I \otimes X) = (I \otimes X) \cdot \text{CNOT}$

• Phase flip ($Z$) through CNOT: $Z$ on the control stays on the control. $Z$ on the target propagates to both control and target.

• $\text{CNOT} \cdot (Z \otimes I) = (Z \otimes I) \cdot \text{CNOT}$
• $\text{CNOT} \cdot (I \otimes Z) = (Z \otimes Z) \cdot \text{CNOT}$

Derivation of propagation rules. The CNOT gate has the matrix representation (control on qubit 0, target on qubit 1):

$$\text{CNOT} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix}$$

We verify the propagation rule for $X$ on the control by direct computation:

$$\text{CNOT} \cdot (X \otimes I) = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} \begin{pmatrix} 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \\ 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \end{pmatrix} = \begin{pmatrix} 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 1 & 0 & 0 \\ 1 & 0 & 0 & 0 \end{pmatrix}$$

$$= (X \otimes X) \cdot \text{CNOT} = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} \cdot \text{CNOT}$$

This confirms that an $X$ error on the control qubit, when propagated through the CNOT, becomes $X \otimes X$ — a correlated error on both qubits. This is sometimes described as "the bit flip on the control infects the target."

Complete propagation table for CNOT:

Worked Example 22.9: Error Propagation in a Bell State Circuit

The Bell state circuit is $|00\rangle \xrightarrow{H \otimes I} \xrightarrow{\text{CNOT}} |\Phi^+\rangle$. If an $X$ error occurs on qubit 0 before the CNOT:

$$\text{CNOT} \cdot (X \otimes I) \cdot (H \otimes I) |00\rangle = \text{CNOT} \cdot (X \otimes I) \frac{1}{\sqrt{2}}(|00\rangle + |10\rangle)$$

$$= \text{CNOT} \frac{1}{\sqrt{2}}(|10\rangle + |00\rangle) = \frac{1}{\sqrt{2}}(|11\rangle + |01\rangle) = |\Psi^+\rangle$$

A single $X$ error on qubit 0 before CNOT becomes an $X \otimes X$ error after CNOT, flipping both qubits. This is why fault-tolerant gate constructions (Chapter 24) must carefully control error propagation.

Worked Example 22.10: Cascading Error Propagation Through Multiple CNOTs

Consider a 3-qubit fanout circuit used to create a GHZ state:

$$|000\rangle \xrightarrow{H \otimes I \otimes I} \xrightarrow{\text{CNOT}_{01}} \xrightarrow{\text{CNOT}_{02}} \frac{1}{\sqrt{2}}(|000\rangle + |111\rangle)$$

Now suppose a $Z$ error occurs on qubit 1 between the two CNOT gates. We trace the error forward:

1. Before the second CNOT: the state has error $I \otimes Z \otimes I$ on qubits (0, 1, 2).
2. After $\text{CNOT}_{02}$: by the propagation rule, $Z$ on the target (qubit 2) propagates to both control and target: $(I \otimes Z \otimes I) \to (I \otimes Z \otimes Z) \cdot \text{CNOT}_{02}$.

Wait — qubit 0 is the control and qubit 2 is the target. The error is on qubit 1, which is not involved in $\text{CNOT}_{02}$. So the error on qubit 1 simply passes through: $(I \otimes Z \otimes I)$.

But now suppose the $Z$ error is on qubit 0 (the control) between the two CNOTs:

1. Before the second CNOT: error $Z \otimes I \otimes I$ on qubit 0.
2. By the propagation rule, $Z$ on the control stays on the control: after $\text{CNOT}_{02}$, we get $(Z \otimes I \otimes I)$.

So a $Z$ error on the control qubit does not propagate through the CNOT in this configuration. However, if the $Z$ error occurs on the target qubit 2:

1. Before $\text{CNOT}_{02}$: error $I \otimes I \otimes Z$ on qubit 2.
2. After $\text{CNOT}_{02}$: $Z$ on the target propagates to both control and target: $(Z \otimes I \otimes Z)$.

A single $Z$ error on qubit 2 has become a two-qubit error! This illustrates how error propagation can create correlated errors from single-qubit errors, which are harder to correct.

Worked Example 22.11: Error Propagation in a Quantum Adder

Consider the CNOT-based quantum full adder circuit. The carry propagation uses a chain of Toffoli and CNOT gates. A single $X$ error on the input qubit $a$ will propagate through each CNOT where $a$ is the control, creating $X \otimes X$ errors on each target qubit. After $k$ CNOT gates with qubit $a$ as control, the original single-qubit $X$ error has become a $(k+1)$-qubit error.

This exponential spreading of errors through circuits is the fundamental reason why fault-tolerant quantum computing requires careful circuit design. Transversal gates (where each logical qubit's physical qubits interact with only one physical qubit from each other logical qubit) limit error propagation to at most one error per physical qubit per gate.

22.10.2 Simulating Error Propagation in Qiskit

The following code demonstrates how errors propagate through CNOT gates by injecting specific Pauli errors and tracing their effect through a circuit:

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector, Operator, Pauli

def propagate_error_through_cnot(error_qubit, error_type):
    """Trace a single-qubit error through a CNOT gate.

    Args:
        error_qubit: 0 (control) or 1 (target)
        error_type: 'X', 'Y', or 'Z'

    Returns:
        Tuple of (output_error_on_control, output_error_on_target)
        where each is a Pauli string 'I', 'X', 'Y', or 'Z'
    """
    cnot = Operator(np.array([[1,0,0,0],
                                [0,1,0,0],
                                [0,0,0,1],
                                [0,0,1,0]]))

    pauli_matrices = {
        'I': np.eye(2),
        'X': np.array([[0,1],[1,0]]),
        'Y': np.array([[0,-1j],[1j,0]]),
        'Z': np.array([[1,0],[0,-1]])
    }

    if error_qubit == 0:
        input_error = Operator(np.kron(pauli_matrices[error_type], pauli_matrices['I']))
    else:
        input_error = Operator(np.kron(pauli_matrices['I'], pauli_matrices[error_type]))

    output_error = cnot.compose(input_error).compose(cnot.adjoint())

    output_error_dense = output_error.data
    for p0_name, p0 in pauli_matrices.items():
        for p1_name, p1 in pauli_matrices.items():
            candidate = np.kron(p0, p1)
            if np.allclose(output_error_dense, candidate * 
                          output_error_dense[0,0] / candidate[0,0] 
                          if abs(candidate[0,0]) > 1e-10 else 0,
                          atol=1e-8):
                if abs(candidate[0,0]) > 1e-10:
                    return (p0_name, p1_name)

    result = cnot.compose(input_error).compose(cnot.adjoint())
    result_matrix = result.data / result.data[0, 0] if abs(result.data[0, 0]) > 1e-10 else result.data

    for p0_name, p0 in pauli_matrices.items():
        for p1_name, p1 in pauli_matrices.items():
            if np.allclose(result_matrix, np.kron(p0, p1), atol=1e-8):
                return (p0_name, p1_name)

    return ("complex", "error")

# Verify all propagation rules
print("Error propagation through CNOT gate:")
print("=" * 50)
for error_qubit in [0, 1]:
    for error_type in ['X', 'Y', 'Z']:
        result = propagate_error_through_cnot(error_qubit, error_type)
        qubit_label = "control" if error_qubit == 0 else "target"
        print(f"{error_type} on {qubit_label}: -> {result[0]} on control, "
              f"{result[1]} on target")

# Demonstrate cascading propagation through a 3-qubit circuit
print("\nCascading propagation through GHZ circuit:")
print("=" * 50)

# Build the ideal GHZ circuit
qc_ghz = QuantumCircuit(3)
qc_ghz.h(0)
qc_ghz.cx(0, 1)
qc_ghz.cx(0, 2)

ideal_state = Statevector.from_label('000').evolve(qc_ghz)
print(f"Ideal GHZ state: {np.round(ideal_state.data, 4)}")

# Inject X error on qubit 0 before first CNOT
for error_pos in ['before_1st_cnot', 'between_cnots', 'after_all_cnots']:
    qc_noisy = QuantumCircuit(3)
    qc_noisy.h(0)
    if error_pos == 'before_1st_cnot':
        qc_noisy.x(0)  # X error before first CNOT
    qc_noisy.cx(0, 1)
    if error_pos == 'between_cnots':
        qc_noisy.x(0)  # X error between CNOTs
    qc_noisy.cx(0, 2)
    if error_pos == 'after_all_cnots':
        qc_noisy.x(0)  # X error after all CNOTs

    noisy_state = Statevector.from_label('000').evolve(qc_noisy)

    overlap = abs(ideal_state.inner(noisy_state))**2
    print(f"X on q0 {error_pos}: fidelity = {overlap:.6f}, "
          f"state = {np.round(noisy_state.data, 4)}")

# Demonstrate Z error propagation
print("\nZ error propagation (phase errors):")
for error_pos in ['before_1st_cnot', 'between_cnots', 'after_all_cnots']:
    qc_noisy = QuantumCircuit(3)
    qc_noisy.h(0)
    if error_pos == 'before_1st_cnot':
        qc_noisy.z(0)
    qc_noisy.cx(0, 1)
    if error_pos == 'between_cnots':
        qc_noisy.z(1)
    qc_noisy.cx(0, 2)
    if error_pos == 'after_all_cnots':
        qc_noisy.z(2)

    noisy_state = Statevector.from_label('000').evolve(qc_noisy)
    overlap = abs(ideal_state.inner(noisy_state))**2
    print(f"Z error {error_pos}: fidelity = {overlap:.6f}")

22.10.3 Correlated Errors

The threshold theorem assumes independent errors. In practice, errors can be correlated:

• Crosstalk: A gate on qubits $(i, j)$ can cause errors on neighboring qubits $(k, l)$.
• Coherent errors: Systematic miscalibrations cause over-rotations that are deterministic, not random.
• Leakage: Qubits can leak out of the computational subspace (e.g., to $|2\rangle$ in a transmon).
• Measurement crosstalk: Reading qubit $i$ can affect the measurement of qubit $j$.

Correlated errors are harder to correct because they violate the independence assumption. However, if correlations are local (affecting only nearby qubits), spatially separated qubits in a surface code can still be effectively independent.

22.11 Leakage Errors

Leakage errors are a qualitatively different type of error from the Pauli errors we have considered so far. In Pauli error models, the qubit remains in the two-dimensional computational subspace $\{|0\rangle, |1\rangle\}$, and the error permutes states within this subspace. Leakage errors, by contrast, take the qubit out of the computational subspace entirely.

22.11.1 What Are Leakage Errors?

A physical qubit is never a true two-level system. The transmon qubit, for example, is a weakly anharmonic oscillator with energy levels at frequencies $\omega_{01}$, $\omega_{12} \approx \omega_{01} - \alpha$ (where $\alpha/2\pi \approx -300$ MHz is the anharmonicity), and higher levels. The computational basis states $\{|0\rangle, |1\rangle\}$ are the lowest two levels, and the $|2\rangle$ state (and beyond) constitutes the leakage subspace.

A leakage error occurs when a qubit transitions from the computational subspace to the leakage subspace:

$$|1\rangle \to |2\rangle \quad \text{(population leakage)}$$

The primary sources of leakage are:

1. Spectator leakage during two-qubit gates: The cross-resonance gate or CZ gate can drive transitions to $|2\rangle$ with probability $\sim 10^{-3}$–$10^{-2}$ per gate, depending on calibration. This is because the gate pulse is optimized for the $|01\rangle \leftrightarrow ||11\rangle$ transition but has off-resonant coupling to $|02\rangle \leftrightarrow |12\rangle$.

2. Spontaneous emission to higher levels: While relaxation ($|1\rangle \to |0\rangle$) is the dominant spontaneous process, thermal excitation ($|0\rangle \to |1\rangle$) and higher-level transitions ($|2\rangle \to |1\rangle$) also occur.

3. Single-qubit gate over-rotation: A pulse intended to implement $R_X(\pi)$ might produce $R_X(\pi + \epsilon)$, leaving a small amplitude in $|2\rangle$ if the pulse has spectral content near the $|1\rangle \to |2\rangle$ transition frequency.

22.11.2 Why Leakage Is Different from Pauli Errors

The key difference between leakage and Pauli errors is that leakage errors cannot be decomposed into Pauli operators on the computational subspace. A Pauli error $P \in \{X, Y, Z\}$ maps the computational subspace to itself:

$$P |0\rangle \in \text{span}\{|0\rangle, |1\rangle\}, \quad P |1\rangle \in \text{span}\{|0\rangle, |1\rangle\}$$

But a leakage error maps computational states out of the subspace:

$$|1\rangle \to |2\rangle \notin \text{span}\{|0\rangle, |1\rangle\}$$

This has devastating consequences for quantum error correction:

Consequence 1: Syndrome measurement failure. A stabilizer measurement like $Z_1 Z_2$ is defined to have eigenvalues $\pm 1$ on the computational subspace. If qubit 1 has leaked to $|2\rangle$, the measurement outcome may be ambiguous — $Z |2\rangle = 2|2\rangle$, which is no longer an eigenvalue $\pm 1$. In practice, the measurement apparatus typically projects onto $\{|0\rangle, |1\rangle\}$, and a leaked qubit is measured as either 0 or 1 with some probability, producing a random syndrome that does not reflect the actual error.

Consequence 2: Error propagation through CNOT. A leaked qubit participating in a CNOT gate can cause errors on both qubits that are not correctable by standard Pauli-frame methods. If the control qubit is in $|2\rangle$ during a CNOT, the target qubit may or may not flip depending on the implementation, and the control qubit may not return to the computational subspace after the gate.

Consequence 3: Accumulation. Unlike Pauli errors, which the error correction cycle can detect and correct, leaked population persists across multiple correction cycles. A leaked qubit is "stuck" in the leakage subspace until it relaxes back (typically via $|2\rangle \to |1\rangle$, which takes time $\sim T_1$) or is actively reset. During this time, the qubit is effectively dead for computation and can spread errors to neighboring qubits through subsequent gates.

22.11.3 Modeling Leakage Errors

The full dynamics of a transmon qubit including the $|2\rangle$ state require a three-level system (qutrit) model. The Kraus operators for the combined relaxation-leakage channel on a qutrit are:

$$E_0 = |0\rangle\langle 0| + \sqrt{1-\gamma_1}|1\rangle\langle 1| + \sqrt{1-\gamma_1 - \gamma_2}|2\rangle\langle 2|$$

$$E_1 = \sqrt{\gamma_1}|0\rangle\langle 1| + \sqrt{2\gamma_2}|1\rangle\langle 2|$$

$$E_2 = \sqrt{\gamma_2}|0\rangle\langle 2|$$

where $\gamma_1$ is the $|1\rangle \to |0\rangle$ relaxation probability and $\gamma_2$ is the $|2\rangle \to |0\rangle$ relaxation probability (note the factor of 2 from the enhanced matrix element). The $|2\rangle \to |1\rangle$ relaxation is captured by an additional operator.

For error correction purposes, the relevant quantity is the leakage probability per gate $L$, which for current superconducting hardware is approximately:

22.11.4 Mitigating Leakage Errors

Several strategies have been developed to handle leakage in quantum error correction:

1. Leakage reduction units (LRUs): Special gate sequences that return leaked population to the computational subspace. The simplest LRU is a resonant $\pi$-pulse on the $|1\rangle \leftrightarrow |2\rangle$ transition, which swaps the leaked population back to $|1\rangle$.

2. Leakage-aware error correction: Modifying the stabilizer measurement to detect leakage. For example, using a three-outcome measurement ($0$, $1$, or "leaked") allows the decoder to flag leaked qubits and treat them differently.

3. Resonator reset: Fast reset protocols that pump population from $|2\rangle \to |1\rangle \to |0\rangle$ using resonator-assisted sideband transitions.

4. Dynamical decoupling against leakage: Pulse shaping techniques such as DRAG (Derivative Removal by Adiabatic Gate) reduce leakage during single-qubit gates by suppressing off-resonant excitation to $|2\rangle$.

Common Misconception: "Leakage errors are rare, so they can be ignored in error correction analysis." This is dangerously wrong. While leakage probabilities per gate are small ($\sim 10^{-3}$), leaked qubits persist across multiple error correction cycles and can spread errors to neighboring qubits. Simulations show that leakage can increase the logical error rate by a factor of 2–10 compared to Pauli-only error models, depending on the code and circuit structure. For the surface code, leakage has been shown to reduce the threshold by approximately a factor of 2.

22.11.5 Leakage and the Threshold Theorem

The threshold theorem assumes that errors are correctable — i.e., they map the code space to a detectable error subspace. Leakage errors violate this assumption because they take the state outside the code space entirely. The modified threshold theorem for leakage states:

Theorem (Leakage-aware threshold): If the physical error rate per gate $p < p_{\text{th}}$ and the leakage probability per gate $L < p$, then fault-tolerant quantum computation is possible with overhead that is polynomial in $\log(1/\epsilon)$, provided that leakage reduction units are applied every $O(1/d)$ rounds (where $d$ is the code distance).

The key insight is that leakage must be actively removed — it cannot be corrected passively by the error correcting code. This adds a constant-factor overhead to the error correction cycle but does not change the fundamental scaling of the threshold theorem.

22.12 The Big Picture: From Errors to Error Correction

Quantum error correction is not an optional add-on — it is the central engineering challenge of quantum computing. The physical error rates of current hardware are tantalizingly close to the fault-tolerance threshold, but the overhead required means that useful fault-tolerant quantum computing will require thousands to millions of physical qubits.

Error Rates and Overhead (Surface Code):

Physical error rate:     10^-3    →  Code distance d ≈ 17    →  ~1000 physical qubits/logical qubit
Physical error rate:     10^-4    →  Code distance d ≈ 11    →  ~500 physical qubits/logical qubit
Physical error rate:     10^-5    →  Code distance d ≈ 7     →  ~200 physical qubits/logical qubit

Target for Shor's algorithm (2048-bit RSA):
~20 million physical qubits at current error rates
~2 million physical qubits at 10^-4 error rates
~200,000 physical qubits at 10^-5 error rates

The remaining chapters in this part develop the theory and practice of QEC, from classical foundations (Chapter 23) to the surface code architectures that dominate current hardware roadmaps (Chapter 25).