Sum over Histories

Go back to the two-slit wall of Chapter 1 and do something a theorist can do for free: drill more holes. Three slits — the amplitude at the detector is a sum of three arrows. Thirty — thirty arrows. Now drill so many holes that the wall is more hole than wall; then drill away the rest. The wall is gone, but the bookkeeping refuses to simplify: the amplitude is still a sum over which-hole-you-went-through, one term per hole, even though the holes are now every point of empty space.

Next, the theorist's second free move: add more walls. A second perforated wall behind the first — every route now names a hole in each wall, and the sum runs over pairs. Ten walls: the sum runs over ten-hole itineraries. Fill the whole flight with walls, drill all of them to nothing, and look at what a “term in the sum” has become: a choice of position at every intermediate moment — a path. A trajectory $x(t)$, any trajectory, however absurd: backwards, jagged, halfway to the Moon and home again. The conclusion was hiding in Chapter 1 all along:

Nothing propagates “along the classical path with quantum corrections.” There is no chosen path at all — only a sum in which, as we are about to see, the classical path is where the votes pile up.

One question remains and it is the whole theory: how far is each arrow rotated? Two clues pin it down. First, phases along a route add (Chapter 1: multiply amplitudes, add clock-turns), so the rotation must be an integral along the path of something local. Second, the rotation is an angle — dimensionless — and quantum mechanics owns exactly one constant with the dimensions to cancel an integral of energy over time: ħ. Nature's choice is the most famous quantity in classical mechanics:

The integrand $L=\frac{m}{2}{\dot{x}}^2-V(x)$ is the Lagrangian — kinetic energy minus potential energy, $L=T-V$ — and its running total over the trip is the action $S$, the very functional whose minimization was classical mechanics' deepest mystery (“how does the particle know to minimize it?”). Here it is the phase of the quantum arrow. Every path gets an arrow of the same length: perfect democracy, with S/ħ as each voter's direction. The object $K(B,A)$ is the propagator, the amplitude to get from event A to event B, and it obeys a law you already own. Slide Chapter 3's completeness $\int d{x}_C|x_C⟩⟨x_C|=1$ into the middle of a journey:

— to go A→B, go A→C, then C→B, and sum the amplitude over every waypoint C. Iterate (8.3) into a thousand time slices and you have re-derived the sum over paths from the operator formalism; run the logic backwards over one thin slice and the Schrödinger equation falls out of (8.2) (exercise 5 walks you through it — it is how the equivalence of the three pictures was first proved). Matrices, waves, histories: one mechanics, three costumes, and you now own the wardrobe.

That the phase should be the classical action was not a lucky guess. It was a clue left in the literature by Dirac in 1933 and chased down by a graduate student a decade later — the origin story of this whole picture, and the reason equation (8.2) exists at all.

An honest objection: if a thrown baseball sums over paths via the Moon, why does it fly a parabola? Because democracy plus interference is not anarchy. Compare a path with its neighbors — the same route wiggled slightly. In general the wiggle changes S, the arrow turns, and since S for a baseball is ~10³⁴ ħ, “slightly” means the arrow spins millions of times: neighboring ballots point every which way and the whole district cancels. Except in one place. Where the action is stationary — first-order insensitive to wiggles — neighboring arrows all point the same way and add. And “stationary action” is precisely the Euler–Lagrange condition — the equation obeyed by the path that makes $S$ stationary, which, as the right-hand side shows, is nothing but Newton's law:

The coherent voting bloc is the bundle of paths within about $\pi \hslash$ of the least action — fat for an electron, invisibly thin for a baseball. Watch the election live:

The spiral on the right deserves a long look — and one honest caveat. Sorted by action and laid tip to tail, the arrows trace curls, then a long straight run, then curls again. The mechanism is exactly stationary phase: consecutive arrows turn by $\Delta S/\hslash$, so the figure runs straight wherever neighbouring histories share an action and curls wherever their actions spread out. In the true sum that crowding happens at the stationary path, because $S$ is flat there — which is why the straight run marks the classical trajectory. The widget, though, has only a few hundred randomly drawn histories, so its crowding sits at the most probable action of that sample rather than at the least action, and the gold run it highlights is mid-walk. Watch the mechanism; do not read the location as physics. Opticians have drawn the ideal figure since 1874 — it is the Cornu spiral of diffraction theory — because light obeys the same rule: Fermat's least-time principle is the photon's stationary phase, and a mirror reflects at equal angles because that is where the photon's ballots agree. Scrape away the “useless” canceling zones of a mirror in stripes and the leftover votes no longer cancel — you have invented the diffraction grating, a mirror that reflects at the “wrong” angle. The rainbow on a CD is a photograph of equation (8.2).

Now the move that turns this pretty picture into a computational superpower — the same rotation that cooled Chapters 6 and 7 into their ground states, applied to the whole sum. Substitute $t=-i\tau$ in the action and track the signs:

— note the sign flip: the potential now adds. The whirling unit arrows have become positive, real weights: heavy for lazy, low-lying paths, feather light for frantic ones. A sum of positive weights over configurations is not quantum mechanics' invention — it is a Boltzmann distribution, statistical mechanics' bread and butter, with $S_E/\hslash$ playing energy-over-temperature and the imaginary-time span β playing inverse temperature. Quantum mechanics in imaginary time is the classical statistical mechanics of wiggly threads. And the dividend: run β large — cool the ensemble — and $e^{-\beta \hat{H}}$ starves every state but the lowest, so long-thread averages are ground-state expectation values. Count where the threads spend their time, and you are measuring $|{\psi }_0(x){|}^2$ — no Schrödinger equation solved, no matrix diagonalized. Just a census of histories. That is a computation begging to be run.

The lab Rust-QP/ch08-pathint samples the thread ensemble with the Metropolis algorithm — the 1953 recipe that founded computational physics: propose a small change, always accept improvements, accept setbacks with probability $e^{-\Delta S_E/\hslash }$. That forgiveness clause is everything — always-downhill would freeze at the classical path; the occasional uphill step is where the quantum fluctuations live:

1/// Change in Euclidean action when site i moves to x_new.
2fn delta_s(path: &[f64], i: usize, x_new: f64) -> f64 {
3    let left = path[(i + N - 1) % N];
4    let right = path[(i + 1) % N];
5    let x_old = path[i];
6    let kin = |x: f64| ((x - left).powi(2) + (right - x).powi(2)) / (2.0 * DT);
7    let pot = |x: f64| DT * 0.5 * OMEGA * OMEGA * x * x;
8    kin(x_new) + pot(x_new) - kin(x_old) - pot(x_old)
9}
10
11// … one sweep of the chain touches every site once:
12
13        for i in 0..N {
14            let x_new = path[i] + step * (rng.gen_range(0.0..1.0) - 0.5) * 2.0;
15            let ds = delta_s(&path, i, x_new);
16            proposed += 1;
17            // Metropolis: always accept downhill, uphill with e^{-dS}
18            if ds <= 0.0 || rng.gen_range(0.0..1.0) < (-ds).exp() {
19                path[i] = x_new;
20                accepted += 1;
21            }
22        }

And this chapter's war story, in the proud tradition of Chapters 5 and 6 — except that this one has three acts, and the third is about the referee rather than the physics.

Act one, the easy bug. The first run failed its own density check by 3%: the proposal step was mistuned — 21% acceptance, the chain barely moved. Widening the step fixed the histogram. It did not fix the error bar, and the error bar was the real problem.

Act two, critical slowing down. Write the worldline in Fourier modes. Because the discretized action is a circulant quadratic form, it diagonalizes: each Matsubara mode $q_k=2\pi k/N$ is an independent Gaussian with variance $1/{\lambda }_k$, where ${\lambda }_k=\frac{2}{d\tau }(1-\cos q_k)+d\tau {\omega }^2$. Now look at the long-wavelength end. As $k\to 0$ the kinetic part dies and ${\lambda }_k\to d\tau {\omega }^2$ — tiny, so the mode is enormously floppy. The k = 0 mode is the worldline's center of mass, and a single-site proposal shifts it by only about $\text{step}/N$. A floppy coordinate nudged in crumbs takes thousands of sweeps to forget where it started: critical slowing down, the disease every Monte Carlo of a nearly continuous field eventually catches. The estimator was not wrong, it was correlated — quoting a $1/\sqrt{n}$ error bar over samples that were not independent.

The cure exploits the diagonalization rather than fighting it. If each slow amplitude is an independent Gaussian of known variance, do not propose a change to it — throw the old value away and draw a new one from the exact conditional. A heat-bath move, accepted with probability one, that decorrelates the worst modes in a single sweep:

1/// Build the slow-mode basis. The discrete action is S = (1/2) x^T A x with A
2/// circulant, so its eigenvectors are the Fourier modes and each amplitude
3/// a_k = v_k . x is an INDEPENDENT Gaussian, a_k ~ Normal(0, 1/lambda_k) with
4/// lambda_k = (2/dt)(1 - cos q_k) + dt*omega^2. That exact decoupling is what
5/// lets us heat-bath these modes one at a time.
6fn build_slow_modes() -> Vec<Mode> {
7    let mut modes = Vec::new();
8    // k = 0: the constant (center-of-mass) mode, v_0 = (1,...,1)/sqrt(N).
9    modes.push(Mode {
10        vec: vec![1.0 / (N as f64).sqrt(); N],
11        std: (1.0 / lambda_k(0)).sqrt(),
12    });
13    // k = 1..K_SLOW: the cosine and sine partners, each orthonormal with
14    // norm sqrt(2/N) (valid while k stays well below the Nyquist mode N/2).
15    let norm = (2.0 / N as f64).sqrt();
16    for k in 1..=K_SLOW {
17        let q = 2.0 * std::f64::consts::PI * k as f64 / N as f64;
18        let std = (1.0 / lambda_k(k)).sqrt();
19        modes.push(Mode {
20            vec: (0..N).map(|i| norm * (q * i as f64).cos()).collect(),
21            std,
22        });
23        modes.push(Mode {
24            vec: (0..N).map(|i| norm * (q * i as f64).sin()).collect(),
25            std,
26        });
27    }
28    modes
29}
30
31// … then, every sweep, right after the single-site Metropolis pass above:
32
33        // SLOW-MODE HEAT-BATH — the key to the error bar.
34        // Single-site Metropolis mixes long-wavelength modes painfully slowly
35        // (critical slowing down: autocorrelation time ~ correlation-length^2).
36        // …
37        for m in &slow_modes {
38            let a_old: f64 = m.vec.iter().zip(path.iter()).map(|(v, x)| v * x).sum();
39            let a_new = m.std * std_normal(&mut rng);
40            let d = a_new - a_old;
41            for (x, &v) in path.iter_mut().zip(m.vec.iter()) {
42                *x += d * v;
43            }
44        }

Act three, the referee the cure broke. That worked — the integrated autocorrelation time collapses from hundreds of sweeps to a handful, and the honest blocking error bar finally shrinks. But read the code again and ask what is left to test. On every heat-bathed mode the sampler now draws from the exact answer, so it cannot be wrong there. And those modes are the floppy ones: only a few dozen of the several hundred, yet they carry the overwhelming majority of $⟨x^2⟩$ (the panel prints the exact split). Comparing the Monte-Carlo $⟨x^2⟩$ to the lattice mode sum therefore puts the same ${\lambda }_k$ on both sides of the scales, where it quietly cancels. The check still passed. It had stopped being able to fail.

So the load-bearing referee was rebuilt to grade only the sector the heat-bath never touches. The slow modes are orthonormal, so they can be projected straight back out of every measured configuration; what remains is the $⟨x^2⟩$ carried by the fast, short-wavelength modes — the ones local Metropolis alone has to thermalize — and that is compared with a reference built only from eigenvalues the sampler never sees. Mistune the step, drop a neighbour term in delta_s, or get ${\lambda }_k$ wrong, and this one moves:

1/// Is Matsubara mode k one of the ones the heat-bath resamples exactly?
2/// (k and N-k are the cosine/sine partners of the same wavenumber.)
3fn is_heat_bathed(k: usize) -> bool {
4    k.min(N - k) <= K_SLOW
5}
6
7/// <x^2> restricted to one sector of the mode spectrum: `fast = true` sums
8/// 1/lambda_k over the modes the heat-bath never touches, i.e. the ones local
9/// Metropolis alone has to thermalize. This is the reference for the
10/// chapter's load-bearing referee, and it shares no eigenvalue with the
11/// heat-bath (which only ever uses lambda_k for k <= K_SLOW).
12fn x2_sector_exact(fast: bool) -> f64 {
13    (0..N)
14        .filter(|&k| is_heat_bathed(k) != fast)
15        .map(|k| 1.0 / lambda_k(k))
16        .sum::<f64>()
17        / N as f64
18}
19
20// … at every measurement, project the heat-bathed sector back out:
21
22            // FAST-MODE SECTOR. The slow modes are orthonormal, so projecting
23            // them out is exact: sum_i x_i^2 - sum_{m in slow} (v_m . x)^2 is
24            // the squared amplitude carried by the 367 modes the heat-bath
25            // never resamples. Re-projecting here (rather than reusing the
26            // amplitudes the heat-bath just drew) keeps the measurement
27            // independent of the heat-bath's own numbers.
28            let slow_sq: f64 = slow_modes
29                .iter()
30                .map(|m| {
31                    let a: f64 = m.vec.iter().zip(path.iter()).map(|(v, x)| v * x).sum();
32                    a * a
33                })
34                .sum();
35            let config_x2_fast = (config_x2 - slow_sq) / N as f64;
36
37// … and the referee that measurement makes possible:
38
39    // R1 — THE LOAD-BEARING ONE. Project the 33 heat-bathed modes out of every
40    // configuration and grade what is left: the 367 fast modes that ONLY local
41    // Metropolis ever moves. Nothing on the measured side was drawn from
42    // lambda_k, and nothing on the reference side is a lambda_k the heat-bath
43    // uses, so this check has no shared dependence to cancel — it can fail.
44    // …
45    referees.push(Referee {
46        name: "⟨x²⟩ fast-mode sector (Metropolis alone) vs mode-sum reference".into(),
47        value: x2_fast_err,
48        tol: 6e-5,
49        pass: x2_fast_err < 6e-5,
50    });

One loop remains. If ${\lambda }_k$ is the shared ingredient, what certifies ${\lambda }_k$? A second, independent derivation. Instead of diagonalizing the action, invert it: the discretized action is periodic tridiagonal, and the inverse of that Toeplitz form is a textbook closed expression, giving $⟨x^2{⟩}_{\mathrm{lat}}=\frac{\coth (N\theta /2)}{2\omega \sqrt{1+(\omega d\tau {)}^2/4}},\theta =2\mathrm{asinh}\left(\frac{\omega d\tau }{2}\right)$. No Fourier modes, no ${\lambda }_k$, and it agrees with the mode sum at rounding level. Which brings us to the last thing the lab refuses to hide:

the answer is not ½. Splitting $e^{-d\tau (\hat{T}+\hat{V})}\approx e^{-d\tau \hat{T}}{e}^{-d\tau \hat{V}}$ drops a commutator of order $d{\tau }^2$, so the discretized action is not the oscillator's — it is a slightly stiffer lattice theory whose exact ground-state spread is $\frac{1}{2}-(\omega d\tau {)}^2/16+O(d{\tau }^4)$. That is the Trotter bias, and the chain converges to it, not to Chapter 7's ½. A Monte Carlo that quotes agreement with the continuum answer to better than its own discretization error is quoting luck. So the panel prints three numbers where most write one: the measurement with its blocking error bar, the lattice value it should converge to, and the continuum ½ — and the referees grade against both references, separately.

Tuned, cured, and refereed where it can actually fail, the census reports below — graded, fittingly, by Chapter 7's exact answers. When one chapter's results referee the next chapter's methods, a book stops being a stack of topics and becomes a load-bearing structure.

1. (F) Dimensional warm-up: verify that S/ħ is dimensionless, and estimate S/ħ for (a) a thrown baseball, (b) an electron crossing an atom. How wide — in paths — is each one's coherent bundle?
2. (C) In the widget, set gravity on and ħ small. The blue bundle hugs the parabola. Now drag “wildness” from one end to the other. The number of sampled histories never changes — only how far they roam — yet the coherent counter collapses and |Σ arrows| falls toward $1/\sqrt{N_{\mathrm{paths}}}$. Explain both: why does adding wilder histories subtract nothing on net, and why is that residual floor exactly what you would get from arrows pointed at random? What theorem are you watching, and what does the floor tell you about the sampling rather than the physics?
3. (F) Evaluate the free propagator exactly: slice (8.3) into N Gaussian integrals and take the limit, obtaining $K\propto e^{im(x_B-x_A{)}^2/2\hslash (t_B-t_A)}$. Check that the exponent is iS_cl/ħ for the straight-line path — for quadratic Lagrangians, the classical path's arrow carries the whole answer.
4. (F, hard) The stationary-phase width made precise: expand $S[x_{\mathrm{cl}}+\eta ]=S_{\mathrm{cl}}+\frac{1}{2}{\delta }^{2}S[\eta ]+\cdots$ (the linear term dies — why?), and evaluate the Gaussian sum over η for the harmonic oscillator to derive the exact propagator prefactor. Where does the answer blow up, and what is special about those times? (Hint: Chapter 6's revivals; every path refocuses.)
5. (F, hard) Feynman's 1948 derivation, guided: write ψ(x, t + ε) via (8.2) over one thin slice, expand to first order in ε and second order in the jump (x − x'), do the three Gaussian moments, and watch $i\hslash {\partial }_t\psi =-\frac{{\hslash }^2}{2m}{\psi }^{\prime \prime }+V\psi$ assemble itself. One page, and the two great formalisms become one.
6. (P) Add an energy estimator to the lab: measure ⟨kinetic⟩ via the virial trick AND naively via $⟨m(\Delta x{)}^2/2d{t}^2⟩$. The naive one diverges as dt → 0 (quantum paths are fractal — their velocity doesn't exist!). Verify, then look up and implement the corrected kinetic estimator.
7. (P, hard) The double well $V=(x^2-a^2{)}^2$: run the lab and watch worldlines hop between wells — instantons, localized in imaginary time. Measure the hop rate vs barrier height, and connect it to the tunneling splitting 2A of Chapter 5's ammonia (the two-level system was a double well all along). You are one abstraction away from how theorists compute tunneling in quantum field theory.