The Mathematical Machinery

Look back at what Chapter 2 forced on us. An atom's condition was two complex numbers $(c_{+},c_{-})$. We added such pairs when amplitudes combined, scaled them, and took a strange kind of product — multiply matching components, conjugate one side, sum — to get the amplitude connecting two states. Adding, scaling, projecting: we have been doing vector geometry. The set of all possible states of a system is a vector space over the complex numbers, with an inner product. That's a Hilbert space; for a qubit it is just ${\mathbb{C}}^2$, nothing fancier than arrows you can add.

The one picture to burn in before any formulas: a state is an arrow, and the numbers we write down are its shadows on a chosen set of axes. Choose different axes — ask a different question — and the shadows change while the arrow stays put:

Every “representation” in quantum mechanics — spin along z versus spin along x now, position versus momentum in Part II — is this widget with more dimensions. The physics lives in the arrow; the basis is our choice of interrogation.

Dirac invented a notation so good it does half the algebra by itself. A state (column) vector is a ket $|\psi ⟩$. Its conjugate-transpose (row) partner is a bra $⟨\psi |$. Put a bra against a ket and you get a bra(c)ket — the inner product, a complex number:

Three properties, each of which is a physical statement, not bookkeeping:

• $⟨\psi |\psi ⟩=1$ — probabilities total one (normalization);
• $⟨\phi |\psi ⟩=⟨\psi |\phi {⟩}^{\ast }$ — reversing a question conjugates its amplitude, so the two directions agree on the probability;
• $⟨\phi |\psi ⟩=0$ — perfect distinguishability: one filter certifies, the other annihilates. Orthogonality is “reliably different.”

A basis is a set of orthonormal states $\{|e_i⟩\}$ — mutually exclusive answers to one complete question. Every state expands as $|\psi ⟩={\sum }_i{c}_i|e_i⟩$ with $c_i=⟨e_i|\psi ⟩$, and the expansion machine itself can be written as an equation:

Slide that identity into any bracket and it splits an amplitude into a sum over intermediate possibilities: $⟨\phi |\psi ⟩={\sum }_i⟨\phi |e_i⟩⟨e_i|\psi ⟩$. Read it physically and you will recognize it — it is Chapter 1's Rule 2, amplitudes add over indistinguishable intermediate paths, now a one-line consequence of the notation. When the paths are distinguished (a filter blocks one), you drop terms from the sum before squaring — Rule 3. The whole double-slit is hiding inside equation (3.2).

We have states. Now we need the mathematical object that represents a measurable quantity — something like “spin along z, in units of ħ/2.” Here is the construction, built bare-handed. A quantity is specified by (a) the special states in which it has a definite value, and (b) those values. For z-spin: definite states $|\pm z⟩$, values $\pm 1$. Package both into a linear machine that eats a state and multiplies each definite-state component by its value:

The definite states are the machine's eigenvectors; the possible answers are its eigenvalues. For the qubit, the three directions of space give three famous machines — the Pauli matrices:

and the analyzer tilted along the unit vector $\hat{n}$ is simply ${\sigma }_{\hat{n}}=\hat{n}\cdot \vec{\sigma }$ — check that ${\sigma }_z$ has eigenvectors $|\pm z⟩$ with eigenvalues ±1 by inspection. Two bonuses fall out of the packaging. First, the average of many measurements collapses to one clean expression. Put (3.3) between two copies of $|\psi ⟩={\sum }_j{c}_j|e_j⟩$ and orthonormality kills every cross term $c_j^{\ast }{c}_k$ with $j\ne k$, leaving one probability-weighted term per eigenvalue:

Second, a constraint: measurement results are real numbers, and distinct results belong to distinguishable (orthogonal) states. A machine of form (3.3) with real ${\lambda }_i$ and orthogonal $|e_i⟩$ is exactly a Hermitian matrix — one equal to its own conjugate-transpose, $\hat{A}={\hat{A}}^{†}$. And the converse — the spectral theorem, named because a machine's set of eigenvalues is called its spectrum — says every Hermitian matrix unpacks into a real spectrum and an orthonormal eigenbasis. Observables are Hermitian machines; Hermitian machines are observables. Don't believe a theorem you haven't poked — build matrices and watch it work:

Build any Hermitian matrix and the explorer always hands back real eigenvalues on perpendicular axes — the spectral theorem, live and never failing. That is the license to invent measurements: name any question whose answers are real numbers and whose states of certainty are reliably distinguishable, and there is a legal observable waiting to represent it. Energy, momentum, spin along any axis, the parity of a molecule — every measurable in the rest of this book is just the right Hermitian machine chosen for the job.

Chapter 2's deepest fact was that the x-question erases the z-answer. Where is that in the machinery? Try to build a state that answers both questions with certainty: it would have to be an eigenvector of ${\sigma }_z$ and of ${\sigma }_x$. But ${\sigma }_z$'s eigenvectors are $(1,0)$ and $(0,1)$, and neither is an eigenvector of ${\sigma }_x$ (it swaps them). No shared eigenvectors, no doubly-certain state — as a matter of linear algebra. The clean diagnostic is whether the two machines care about order:

If $[\hat{A},\hat{B}]=0$ the machines share an eigenbasis and both questions can be answered at once; if not, certainty in one forces spread in the other — and the commutator's size sets the exchange rate. That is the content of the Robertson uncertainty relation,

which we will prove in Chapter 4 and which the lab below already tests numerically on random states (spoiler: it never loses). Chapter 1's $\Delta x\Delta p\ge \hslash /2$ is the special case $[\hat{x},\hat{p}]=i\hslash$ — the microscope hand-wave will become two lines of algebra. Incidentally, non-commuting operations are not exotic: turn a book 90° about x then 90° about z, then do it in the other order — you get different orientations. Rotations don't commute, spins are about rotation, and equation (3.6) is that fact wearing matrix clothes.

One last tool and the kit is complete. Two qubits: the joint question “what will each analyzer say?” has four exclusive answers, $++,+-,-+,--$. Four answers means four basis states means four amplitudes — the state space of a pair is the tensor product, with dimension $2\times 2=4$:

Dimensions multiply: ten qubits inhabit a 1,024-dimensional space, three hundred qubits outrun the atom count of the visible universe. And a warning shot for Part IV: only special states of form (3.8) factor into “qubit 1 in some state” times “qubit 2 in some state.” Try it on $(|+-⟩-|-+⟩)/\sqrt{2}$ — you can't. States that refuse to factor are entangled: the pair has a definite state while neither partner does. Susskind calls this the essential fact of quantum mechanics; it will take Chapter 18 to do it justice.

The lab Rust-QP/ch03-qkit builds this whole chapter from scratch — kets, bras, inner products, Hermitian conjugates, commutators, expectation values — with no linear-algebra crate, in about two hundred lines. The inner product is four lines, and the conjugate on the bra side is not decoration; delete the .conj() and watch norms go complex:

1#[derive(Clone, Copy, Debug)]
2struct Ket([C; 2]);
3
4#[derive(Clone, Copy, Debug)]
5struct Mat([[C; 2]; 2]);
6
7impl Ket {
8    /// <self|other> — inner product; conjugate the bra side.
9    fn dot(&self, other: &Ket) -> C {
10        self.0[0].conj() * other.0[0] + self.0[1].conj() * other.0[1]
11    }
12    fn norm(&self) -> f64 {
13        self.dot(self).re.sqrt()
14    }
15    // …
16}
17
18// …  (impl Mat: apply, mul, add, scale, sub, dagger, dist, commutator, expect)
19
20// the cast: identity and the three Pauli matrices
21const I2: Mat = Mat([[C::new(1.0, 0.0), C::new(0.0, 0.0)], [C::new(0.0, 0.0), C::new(1.0, 0.0)]]);
22const SX: Mat = Mat([[C::new(0.0, 0.0), C::new(1.0, 0.0)], [C::new(1.0, 0.0), C::new(0.0, 0.0)]]);
23const SY: Mat = Mat([[C::new(0.0, 0.0), C::new(0.0, -1.0)], [C::new(0.0, 1.0), C::new(0.0, 0.0)]]);
24const SZ: Mat = Mat([[C::new(1.0, 0.0), C::new(0.0, 0.0)], [C::new(0.0, 0.0), C::new(-1.0, 0.0)]]);

Then the program referees itself, and it is worth being exact about what “referees” buys, because the three checks are not the same kind of claim. The Pauli identities are exact: every entry in play is 0, ±1 or ±i, all of them exactly representable in binary, so the tolerance is literally 0.0 and the assertion is equality. The eigenvector formula, checked in 200 directions, does accumulate rounding — two different constructions of the same operator have to agree — so it gets a real tolerance, tightened down to 10⁻¹⁵. And the Monte Carlo sweep is a statistical claim, so it is gated statistically: the run aborts unless every sample mean sits within 4σ of the matrix element, where σ is that angle's own standard error. The panel below prints the achieved worst case in the same units.

That last one is the referee that actually earns its keep, and the reason is worth stating. Everywhere else in this lab a formula is being compared with a formula. In the sweep, two code paths that share nothing must land on the same number: the sampled side draws its coin bias from eigenkets_n and Ket::dot — the half-angle formula and the inner product — while the reference side builds ${\sigma }_{\hat{n}}$ out of the Pauli constants and sandwiches it between bras. Get the half-angle convention wrong, as everyone does once, and the two disagree by hundreds of σ rather than by one:

1// Tolerance 0.0: every entry is 0, +-1 or +-i, so these identities hold
2    // *exactly* in binary floating point. There is nothing to round.
3    const EXACT: f64 = 0.0;
4    let mut checks = vec![
5        check("sigma_x^2 = 1", SX.mul(&SX).dist(&I2), EXACT),
6        // … sigma_y^2, sigma_z^2 …
7        check("sigma_x sigma_y = i sigma_z", SX.mul(&SY).dist(&SZ.scale(i)), EXACT),
8        // … the two cyclic products …
9        check("[sigma_x, sigma_y] = 2i sigma_z", SX.commutator(&SY).dist(&SZ.scale(i * 2.0)), EXACT),
10        check("{sigma_x, sigma_y} = 0", SX.mul(&SY).add(&SY.mul(&SX)).dist(&Mat::ZERO), EXACT),
11        // … sigma_x is Hermitian …
12        check("sigma_y is Hermitian", SY.dagger().dist(&SY), EXACT),
13    ];
14
15    // …
16
17    // This is the one place where two genuinely independent code paths meet.
18    // The sampled side gets P(+) from eigenkets_n + Ket::dot (the half-angle
19    // formula and the inner product); the reference side gets it from
20    // sigma_n(theta, 0.0).expect(&up) (the matrix built out of the Pauli
21    // constants, sandwiched between bras). Nothing is shared. Get the
22    // half-angle convention wrong and the two disagree by hundreds of sigma.
23    let up = Ket([c(1.0, 0.0), c(0.0, 0.0)]);
24    let n_shots = 20_000u32;
25    let sweep: Vec<SweepPoint> = (0..=24)
26        .map(|k| {
27            let theta_deg = k as f64 * 15.0;
28            let theta = theta_deg * PI / 180.0;
29            let (plus_n, _) = eigenkets_n(theta, 0.0);
30            let p_plus = plus_n.dot(&up).norm_sqr();
31            let mut sum = 0i64;
32            for _ in 0..n_shots {
33                sum += if rng.gen_range(0.0..1.0) < p_plus { 1 } else { -1 };
34            }
35            let mean = sum as f64 / n_shots as f64;
36            // sample std of a ±1 variable with mean m is sqrt(1 - m^2)
37            let sigma = ((1.0 - mean * mean) / n_shots as f64).sqrt();
38            SweepPoint {
39                theta_deg,
40                sample_mean: mean,
41                sigma,
42                theory: sigma_n(theta, 0.0).expect(&up),
43                n: n_shots,
44            }
45        })
46        .collect();
47
48    // …
49
50    let sigma_floor = 2.0 / n_shots as f64;
51    let sweep_worst_sigma = sweep
52        .iter()
53        .map(|p| (p.sample_mean - p.theory).abs() / p.sigma.max(sigma_floor))
54        .fold(0.0f64, f64::max);
55    // 25 angles, so the largest of 25 standard normals is ~2.3 sigma typically;
56    // 4 sigma is the honest gate. A wrong half-angle convention lands at ~100.
57    let sweep_tol_sigma = 4.0;
58
59    // …
60
61    // Every referee is gated — the Monte Carlo sweep included. It is the only
62    // check here that two independent code paths have to agree on, so leaving
63    // it out of the gate would throw away the strongest referee in the file.
64    let algebra_pass = data.checks.iter().all(|c| c.pass);
65    let all_pass = algebra_pass && data.gate.sweep_pass && data.gate.unc_pass;

1. (F) Show that eigenvalues of a Hermitian matrix are real and that eigenvectors for distinct eigenvalues are orthogonal. (Two lines each, starting from $⟨v|\hat{A}|v⟩$.)
2. (F) Compute ${\sigma }_{\hat{n}}=\hat{n}\cdot \vec{\sigma }$ for $\hat{n}$ at polar angle θ in the x–z plane, find its eigenvectors, and recover equation (2.2) — the half-angle law, now as a theorem.
3. (C) In the Hermitian explorer, find slider settings whose eigen-axis points along +x. What matrix did you build? Verify it is ${\sigma }_x$ (up to scale and a shift by the identity).
4. (F) Insert completeness (3.2) in the x-basis between two z-brackets and compute the amplitude for an atom prepared in $|+z⟩$ to leave by the $|-z⟩$ port. Summing both x-paths, the two terms must cancel — completeness hands you back $⟨-z|+z⟩=0$, so nothing comes out. Now block one path: there is nothing left to interfere with, and the surviving term alone gives $|⟨-z|+x⟩⟨+x|+z⟩{|}^2=\frac{1}{4}$ — Chapter 2's cascade. Same apparatus, two different numbers; the filter is the entire difference.
5. (P) Extend qkit with a tensor(&Ket, &Ket) -> Ket4 and verify dimensions multiply. Then compute $⟨\Psi |{\sigma }_z\otimes {\sigma }_z|\Psi ⟩$ for the singlet state — you have just predicted your first entanglement correlation (Chapter 18 will make it famous).
6. (P, harder) Implement expm_i(&Mat, f64) // e^(iθA) for Hermitian A via the identity $e^{i\theta \hat{n}\cdot \vec{\sigma }}=\cos \theta 1+i\sin \theta \hat{n}\cdot \vec{\sigma }$ and check it is unitary. You have built rotation of a spin — the front door to Chapter 5's dynamics.
7. (F, hard) Prove the compatibility theorem used throughout this chapter: two Hermitian operators with non-degenerate spectra commute if and only if they share a complete orthonormal eigenbasis. (The ⇐ direction is two lines. For ⇒: show that if $[\hat{A},\hat{B}]=0$ and $\hat{A}|a⟩=a|a⟩$, then $\hat{B}|a⟩$ is also an eigenvector of $\hat{A}$ with eigenvalue a — and non-degeneracy forces it to be proportional to $|a⟩$.) Then explain, in one sentence each, what fails when the spectrum is degenerate, and how the notion of a “complete set of commuting observables” repairs it.
8. (F, hard) The overall-phase claim of Postulate 1 needs teeth. Show that if two states differ only by a global phase, no observable can distinguish them — but that a relative phase inside a superposition is always detectable: exhibit, for $(|+z⟩+e^{i\phi }|-z⟩)/\sqrt{2}$, an explicit Hermitian operator whose expectation value depends on φ, and identify which Stern–Gerlach experiment measures it. Then reconcile: why did the neutron interferometers of 1975 nonetheless detect the 360°-rotation sign flip — which looks like a global minus sign?