Quantum Channels and Noise

A pure state $|\psi ⟩$ encodes perfect knowledge: you know exactly which unit vector you hold. Two perfectly ordinary situations break that assumption, and neither can be written as a state vector.

First, classical uncertainty. Suppose a faulty machine prepares $|0⟩$ half the time and $|+⟩$ half the time, and does not tell you which. This is not the superposition $(|0⟩+|+⟩)/\mathcal{N}$ — that would be a definite pure state. It is a classical coin flip over two different pure states, a statistical mixture, and quantum mechanics has no vector for “one of these two, I forget which.”

Second, and deeper: entanglement. Take the Bell state $|{\Phi }^{+}⟩=(|00⟩+|11⟩)/\sqrt{2}$ from Chapter 3 and ask only about the first qubit. There is no pure state $|\psi ⟩$ of that qubit that reproduces its measurement statistics: it comes up 0 half the time and 1 half the time in every basis, as if maximally uncertain — even though the global two-qubit state is perfectly, purely known. The information is in the correlations, not in either qubit alone. The local view of an entangled state is intrinsically mixed.

Both failures share a cure. In each case what we can actually predict is a set of measurement probabilities, and those turn out to be captured by a single Hermitian matrix — the object we build next. It will describe the coin-flip mixture and the reduced Bell qubit with the very same formalism, and it will turn out that they are the same state: no experiment can tell a 50/50 classical mixture of the right two states from the local half of a Bell pair.

Here is the object — the same $\rho$ that Chapter 1's Holevo argument had to borrow ahead of schedule; this section is where it is properly earned. Given an ensemble — pure states $|{\psi }_i⟩$ occurring with classical probabilities $p_i$ — define the density matrix

Every probability we can compute comes from $\rho$ alone. The expectation value of any observable $A$ is the clean, basis-free trace formula

which specializes to the Born rule: the probability of an outcome with projector $P$ is $\mathrm{Tr}(\rho P)$. Because only $\rho$ enters, any two ensembles with the same density matrix are physically identical — which is exactly why the coin-flip mixture and the reduced Bell qubit of §4.1 cannot be told apart.

From its definition (4.1), $\rho$ has three properties that turn out to be not just necessary but sufficient — any matrix with all three is a legal state:

Hermiticity makes expectation values real; positivity (all eigenvalues $\ge 0$) makes probabilities non-negative; unit trace makes them sum to one. A single pure state $|\psi ⟩$ is the special case $\rho =|\psi ⟩⟨\psi |$, a rank-one projector.

How do we tell a genuinely mixed state from a pure one dressed up as a matrix? The purity — written $\mathcal{P}$ here, to keep $\gamma$ free for the damping rate of §4.5 —

does it in one number. For a pure state ${\rho }^2=\rho$, so $\mathcal{P}=1$. For anything mixed it is strictly less than 1, bottoming out at $1/d$ for the maximally mixed state $I/d$ — for a qubit that floor is exactly $\frac{1}{2}$, the density matrix $I/2$ of total ignorance.

Chapter 1 put every pure qubit on the surface of the Bloch sphere. Mixed states fill the inside. Any qubit density matrix can be written with the Pauli matrices $\mathbf{\sigma }=(X,Y,Z)$ as

where the Bloch vector $\mathbf{r}$ now has a length that reports the purity directly: $\mathcal{P}=\frac{1}{2}(1+|\mathbf{r}{|}^2)$. The surface $|\mathbf{r}|=1$ is the pure states; the centre $\mathbf{r}=0$ is $I/2$, maximal ignorance; everything between is a mixed state of intermediate purity. The sphere became a solid ball the moment we admitted we might not know the state.

This picture is what makes noise visual: a noise process is a rule that moves and shrinks the Bloch vector. Keep it in mind for §4.4, where every channel becomes a specific deformation of this ball.

What are the legal ways a density matrix can evolve? A closed system evolves unitarily, $\rho \to U\rho U^{†}$. But an open system — one talking to an environment — does more. The most general physical operation, a quantum channel $\mathcal{E}$, is any map that is completely positive and trace-preserving (CPTP): it must send density matrices to density matrices, even when applied to just part of a larger entangled system (that is the “complete” in complete positivity), and it must never lose probability.

The remarkable theorem — due to Kraus, building on Stinespring — is that every such map has a concrete finite form. There exist operators $E_k$ (the Kraus operators) with

Read it physically: with “probability” $\mathrm{Tr}(E_k\rho E_k^{†})$ the environment applies operation $E_k$ and we do not learn which — so we sum over the possibilities. The completeness relation ${\sum }_k{E}_k^{†}{E}_k=I$ is precisely what guarantees the trace is preserved, and hence total probability stays 1. A unitary is the one-operator case $E_0=U$.

But suppose someone hands you a map and you want to check it is completely positive — positive not only on every state of the qubit, of which there are infinitely many, but on every entangled input of every larger system it could be part of. That sounds untestable. It is not, and the finite test is the one the lab runs. Write the unnormalized maximally entangled vector on two copies of the system, $|\Omega ⟩={\sum }_i|i⟩|i⟩$, let $\mathcal{E}$ act on the second copy alone, and call the result the Choi matrix of the map:

It is one $d^2\times d^2$ matrix — $4\times 4$ for a qubit — and it stores the map completely, because the $d^2$ matrices $|i⟩⟨j|$ are a basis and $\mathcal{E}$ is linear. The payoff is Choi's theorem:

An infinite family of positivity conditions collapses into the positivity of one finite matrix, settled by computing four eigenvalues. And the two directions are constructive: an eigendecomposition $J={\sum }_k{\lambda }_k|v_k⟩⟨v_k|$ with ${\lambda }_k\ge 0$ reshapes each $\sqrt{{\lambda }_k}|v_k⟩$ into a Kraus operator, so Choi's theorem and Kraus's are two faces of one statement. It also explains why $J$ deserves to be called the channel's fingerprint: the Kraus operators are not unique — Exercise 5 makes you find another set for the same channel — but $J$ is.

Four channels model almost everything that goes wrong with a real qubit. Each is written by its Kraus operators; each deforms the Bloch ball in its own signature way.

The bit-flip applies $X$ with probability $p$: $E_0=\sqrt{1-p}I,E_1=\sqrt{p}X$. It leaves $x$ alone and shrinks both $y$ and $z$ by $(1-2p)$, collapsing the ball onto the $x$-axis. The phase-flip (or dephasing) channel applies $Z$ instead: $E_0=\sqrt{1-p}I,E_1=\sqrt{p}Z$. It is the most insidious noise there is — it destroys the relative phase that superposition lives on while costing the qubit no energy, shrinking the whole equatorial $(x,y)$ disk toward the $z$-axis. The depolarizing channel is isotropic: with probability $p$ it replaces the qubit with total noise,

which shrinks the Bloch vector uniformly by $(1-p)$ — the whole ball contracts toward its centre. Finally, amplitude damping models energy loss (spontaneous emission, $T_1$ decay): it is not symmetric, because it drives the excited state $|1⟩$ down to the ground state $|0⟩$ with probability $\gamma$,

Unlike the others, amplitude damping moves the ball toward the north pole $|0⟩$, not toward the centre: its fixed point is a pure state, because a qubit that has lost all its energy is definitely in the ground state. Watch all four act on a live state — pick a channel and turn up the noise:

Notice the different geometries the slider reveals. Depolarizing pulls straight in toward maximal ignorance. Dephasing flattens the equator: it shrinks $x$ and $y$ together while leaving $z$ alone, and because the widget draws only the $x$–$z$ slice you see just the $x$ half of that collapse. Amplitude damping curves the state up toward $|0⟩$. These are not cosmetic differences: the error-correcting codes of Part III are each engineered against a specific noise shape, and getting the shape right is the whole game. All four of these closed forms are refereed in §4.7 against the Kraus sum itself, on the full three-dimensional ball rather than the drawn slice — the lab found that swapping $Z$ for $Y$ in the dephasing channel survives every other check in the file, so the check had to exist.

If noise degrades a state, we need a number for how much. The fidelity measures how close two states are, from 1 (identical) down toward 0 (perfectly distinguishable). For a general pair it is

which looks forbidding but collapses in the cases we care about. When the target is a pure state $\sigma =|\psi ⟩⟨\psi |$ — the usual situation, comparing a noisy output against the clean state we wanted — it becomes the simple overlap

the probability that the noisy $\rho$ passes a test for $|\psi ⟩$. Fidelity is 1 exactly when $\rho =\sigma$, and for a qubit it has the tidy closed form $F=\mathrm{Tr}(\rho \sigma )+2\sqrt{\det \rho \det \sigma }$, which the lab uses as an independent cross-check on the matrix-root formula (4.11). As noise strength climbs, fidelity falls — smoothly and, for these channels, monotonically, as the panel in §4.7 shows.

One honest caveat, because the lab measures it. Evaluating (4.11) means taking a square root of a matrix whose smallest eigenvalue is of order ${\lambda }_{\min }(\rho {)}^2$, and $\mathrm{d}\sqrt{x}/\mathrm{d}x=1/(2\sqrt{x})$ blows up at the origin. So the unavoidable $\sim \epsilon$ rounding of the matrix entries comes out amplified to $\sim \epsilon /{\lambda }_{\min }$ in $F$: the fidelity of a nearly-pure state to itself is 1 to about thirteen digits in the interior of the ball and only to about eight digits on its surface. This is a property of the functional, not of our code — an eigendecomposition in any dimension does the same thing — and the qubit closed form, which contains no matrix root, does not suffer from it. The lab therefore splits the claim in two and reports both numbers, rather than quietly drawing its test states away from the boundary.

Everything above becomes a compact Rust kit. A density matrix is a $2\times 2$ complex matrix; a channel is a list of Kraus operators; applying it is one sum. Here is the core:

1type Mat2 = [[C; 2]; 2];
2
3// …
4
5/// Apply a channel {E_k} to ANY 2x2 matrix: sum_k E_k M E_k^dagger. (Works on
6/// non-Hermitian M too, which the Choi construction needs.)
7fn apply(kraus: &[Mat2], m: &Mat2) -> Mat2 {
8    let mut out = zero();
9    for e in kraus {
10        out = add(&out, &mul(&mul(e, m), &dagger(e)));
11    }
12    out
13}
14
15fn bit_flip(p: f64) -> Vec<Mat2> {
16    vec![scale(&id2(), c((1.0 - p).sqrt(), 0.0)), scale(&pauli_x(), c(p.sqrt(), 0.0))]
17}
18fn phase_flip(p: f64) -> Vec<Mat2> {
19    // dephasing: E0 = sqrt(1-p) I, E1 = sqrt(p) Z
20    vec![scale(&id2(), c((1.0 - p).sqrt(), 0.0)), scale(&pauli_z(), c(p.sqrt(), 0.0))]
21}
22fn depolarizing(p: f64) -> Vec<Mat2> {
23    // rho -> (1-p) rho + p I/2, written with four Pauli Kraus operators.
24    vec![
25        scale(&id2(), c((1.0 - 0.75 * p).sqrt(), 0.0)),
26        scale(&pauli_x(), c((p / 4.0).sqrt(), 0.0)),
27        scale(&pauli_y(), c((p / 4.0).sqrt(), 0.0)),
28        scale(&pauli_z(), c((p / 4.0).sqrt(), 0.0)),
29    ]
30}
31fn amplitude_damping(gamma: f64) -> Vec<Mat2> {
32    // E0 = diag(1, sqrt(1-gamma)),  E1 = sqrt(gamma) |0><1|
33    vec![
34        [[c(1.0, 0.0), c(0.0, 0.0)], [c(0.0, 0.0), c((1.0 - gamma).sqrt(), 0.0)]],
35        [[c(0.0, 0.0), c(gamma.sqrt(), 0.0)], [c(0.0, 0.0), c(0.0, 0.0)]],
36    ]
37}

Fidelity is built from a closed-form square root of a $2\times 2$ positive matrix, then the Uhlmann formula (4.11) — alongside the qubit closed form it is graded against. Both lean on one shared primitive, herm_det, which recovers $\det \rho ={\rho }_{00}{\rho }_{11}-|{\rho }_{01}{|}^2$ to full relative accuracy with fused multiply-add. Written naively that difference of two nearly equal numbers has no correct digits at all once $\rho$ is close to pure, and the closed form inherits the damage:

1// … herm_det(m): m00·m11 − |m01|², recovered to full RELATIVE accuracy
2// … with fused multiply-add, so det is right even as rho → a pure state …
3
4/// Principal square root of a 2x2 PSD Hermitian matrix, in closed form:
5/// sqrt(M) = (M + sqrt(det) I) / sqrt(tr + 2 sqrt(det)).
6fn sqrt_psd(m: &Mat2) -> Mat2 {
7    let det = herm_det(m).max(0.0);
8    let s = det.sqrt();
9    let tr = (m[0][0] + m[1][1]).re;
10    let denom = (tr + 2.0 * s).max(0.0).sqrt();
11    if denom < 1e-300 {
12        return zero();
13    }
14    scale(&add(m, &scale(&id2(), c(s, 0.0))), c(1.0 / denom, 0.0))
15}
16/// Uhlmann (Jozsa) fidelity F(rho,sigma) = (Tr sqrt( sqrt(rho) sigma sqrt(rho) ))^2.
17/// For a pure target |psi>, F = <psi|rho|psi>. F(rho,rho) = 1.
18fn fidelity(rho: &Mat2, sigma: &Mat2) -> f64 {
19    let r = sqrt_psd(rho);
20    let inner = mul(&mul(&r, sigma), &r);
21    let t = trace(&sqrt_psd(&inner)).re;
22    t * t
23}
24/// Qubit closed form: F = Tr(rho sigma) + 2 sqrt(det rho * det sigma). An
25/// independent route to fidelity above — no matrix square root anywhere in it,
26/// only a product trace and two determinants. (It shares the herm_det
27/// primitive, but nothing of the algorithm.)
28fn fidelity_closed(rho: &Mat2, sigma: &Mat2) -> f64 {
29    let overlap = trace(&mul(rho, sigma)).re;
30    let dr = herm_det(rho).max(0.0);
31    let ds = herm_det(sigma).max(0.0);
32    overlap + 2.0 * (dr * ds).sqrt()
33}

The referees are where the physics is verified rather than asserted. One of the sharpest is below: it locates amplitude damping's fixed point — it iterates the channel from two hundred random states scattered through the ball and asks where they all end up, which is a different question from the $(1-\gamma {)}^n$ population curve the previous referee grades, and one that a channel damping the wrong way would fail. Below it sits an honest counter-example: the lab computes the Choi matrix (4.7) of each channel and asserts its $4\times 4$ spectrum has no negative eigenvalue — but it refuses to score that as a referee, because a Choi matrix built from any Kraus sum is positive semidefinite whether the physics is right or wrong (Choi's theorem (4.8) cuts both ways). Like the Hermiticity check, it guards the linear algebra, not the channels — and a referee that cannot fail is not a referee:

1// --- Referee 9: the amplitude-damping FIXED POINT is |0><0| ------------
2    // Deliberately NOT referee 8 with different words. That one starts at |1>
3    // and grades a population against (1-gamma)^n. This one starts from random
4    // states all over the ball, iterates the channel until it stops moving, and
5    // asks WHERE it stopped — plus that |0><0| is exactly fixed, E(|0><0|) =
6    // |0><0|. Damping the wrong way (E1 = sqrt(g)|1><0|) or contracting to I/2
7    // instead fails here.
8    let g_fix = 0.35_f64;
9    let n_fix = 200;
10    let kraus_fix = amplitude_damping(g_fix);
11    let ground = rho_from_bloch(0.0, 0.0, 1.0); // |0><0|
12    let mut worst_fixed: f64 = dist(&apply(&kraus_fix, &ground), &ground);
13    for _ in 0..200 {
14        let len = rng.gen::<f64>();
15        let (x, y, z) = rand_bloch(&mut rng, len);
16        let mut r = rho_from_bloch(x, y, z);
17        for _ in 0..n_fix {
18            r = apply(&kraus_fix, &r);
19        }
20        worst_fixed = worst_fixed.max(dist(&r, &ground));
21    }
22    assert!(worst_fixed.is_finite());
23    referees.push(Referee {
24        name: "Amp. damping fixed point  max |Eⁿ(ρ) − |0⟩⟨0||".into(),
25        value: worst_fixed,
26        tol: 1e-15,
27        pass: worst_fixed < 1e-15,
28    });
29
30    // --- Choi PSD: computed and asserted, but NOT scored as a referee ------
31    // J built from a Kraus sum is PSD for ANY Kraus matrices — wrong physics
32    // included — so this can only catch bugs in the 8x8 Choi embedding itself.
33    // Same class as the Hermiticity assert above; see the header.
34    let mut worst_choi: f64 = f64::INFINITY; // most negative Choi eigenvalue seen
35    for (_, build) in &registry {
36        for &p in &ps {
37            let lo = choi_min_eig(&build(p));
38            worst_choi = worst_choi.min(lo);
39        }
40    }
41    assert!(worst_choi.is_finite());
42    assert!(worst_choi >= -1e-15, "Choi embedding broken: {worst_choi:e}");

The lab writes every referee to JSON and the panel below reads them live — the count, the values, the tolerances, and the numbers quoted in the two chart captions are all pulled from the file, so nothing here can go stale behind a re-run. Each channel is CPTP; outputs stay Hermitian, unit-trace, and positive; all four Bloch deformations match their closed forms; amplitude damping reproduces $T_1$ decay and lands on $|0⟩⟨0|$ from anywhere; every Choi matrix is positive; and fidelity is 1 to itself and never turns back up as noise grows.

Run it yourself with cargo run --release in Rust-QML/ch04-channels. This kit is the noise model the rest of the book fights: Part III's codes exist precisely to undo these channels, and to prove they work we will subject encoded qubits to exactly the maps built here.