The Only Mystery

All three of our experiments use the same apparatus — only the ammunition changes. Figure 1.1 is the whole machine: a source on the left that emits things one at a time, a wall pierced by two narrow slits a distance $d$ apart, and a screen a distance $L$ beyond that records where each thing lands. We will run bullets, then water waves, then electrons through it, and keep an honest tally of the arrivals as a function of the screen position $x$. Nothing else is up our sleeve.

Start with bullets. Imagine a machine gun that sprays indestructible bullets toward a wall with two holes, and behind it a backstop of sand boxes that count where each bullet lands. Bullets have two properties that feel too obvious to state. First, they arrive in lumps: a sandbox either receives a whole bullet or nothing — never half of one. Second, each bullet goes through either hole 1 or hole 2. So if $P_1(x)$ is the arrival distribution with only hole 1 open, and $P_2(x)$ with only hole 2 open, then with both open,

Probabilities of exclusive alternatives add. The result is smooth, boring, and absolutely what you would bet your house on. How it looks depends on the geometry: pull the holes far apart and you see two separate humps, one behind each hole. In the apparatus we are about to simulate the holes are only $40\mu \mathrm{m}$ apart while each hump is tens of millimetres wide, so the two overlap almost perfectly and $P_{12}$ is a single broad mound with no structure in it at all. That featurelessness is the point. Switch the simulation below to Bullets and watch equation (1.1) assemble itself out of individual impacts.

Now flood the apparatus and drive it with a rhythmic wave source. Waves are the opposite of bullets in both respects. Nothing arrives in lumps — the absorber receives energy continuously, at any intensity you like. And a wave does not choose a hole: it passes through both at once, and the two emerging ripples overlap. What the detector measures is the intensity — the squared height of the total wave:

where $\delta$ is the phase difference between the two arrivals. That last term — the interference term — is the signature of waves. Where the ripples arrive in step ($\delta =0,2\pi ,\dots$) they reinforce; where they arrive out of step ($\delta =\pi ,3\pi ,\dots$) they cancel. The pattern is a corrugation of bright and dark fringes. Amplitudes add first; intensity comes second. Keep that order of operations in mind — it is about to become the organizing principle of all physics.

Now the third act. Fire electrons — one at a time, so slowly that each has arrived and been counted before the next is emitted. What we find is a result that is impossible, absolutely impossible, to explain in any classical way — and which has in it the heart of quantum mechanics:

• Electrons arrive in lumps, like bullets. One click at a time, at one place at a time. Never half a click.
• But the accumulated pattern of many clicks shows interference fringes, like waves — $P_{12}\ne P_1+P_2$.

Run it yourself. Watch single dots land at random — then watch order emerge from the randomness, fringe by fringe:

Sit with what you just saw. Each electron was alone in the apparatus. There is a place on the screen (a dark fringe) where electrons arrive freely when only one hole is open — but where they never arrive when both are open. Opening a second route forbids arrivals that a single route allowed. No story in which the electron “really goes through one hole” can produce that. And yet each electron lands at exactly one point. It propagates like a wave and is detected like a particle. So which is it, really — wave or particle? The only honest answer science can give: it is like neither. It is like an electron. And until this experiment, nobody had ever met anything that behaves like an electron.

You might reasonably object: why should an electron, a speck of matter, have a wavelength at all? That was exactly the leap Louis de Broglie made in his 1924 doctoral thesis — he proposed that every particle of momentum $p$ is accompanied by a wave of wavelength

where $h$ is Planck's constant. For an everyday bullet $p$ is so enormous that $\lambda$ is fantastically smaller than an atom and no fringes are ever seen — which is why classical intuition works so well for baseballs. For an electron $\lambda$ is a few picometers: small, but real. Matter is wavy; we simply never noticed until we made the apparatus small enough.

One piece of honesty about the animation you just ran, before it misleads you. The logic of that experiment is the electron experiment — lumps that pile up into fringes — but the apparatus being simulated is optical: a helium–neon laser at $\lambda =633\mathrm{nm}$ through slits $40\mu \mathrm{m}$ apart, which is what puts the fringes millimetres from each other on a screen a metre away. Feed the same geometry an electron of a few picometers and equation (1.6) below shrinks the fringe spacing by five orders of magnitude, to a fraction of a micron — utterly invisible. That is precisely why the electron version took until 1961: to stretch the pattern back out to something a detector can resolve you need slits orders of magnitude closer together, and magnifying electron optics behind them. Jönsson used both — slits about a micron apart, and lenses to blow the fringes up. Exercise 2 asks you to do that arithmetic yourself, and it is worth doing — it converts “matter is wavy” from a slogan into a number.

And now the itch you should be feeling: how does one electron, alone in the machine, know whether the other slit is open? Resist the urge to invent gears — pilot ripples, secret signals, electrons that split in half. Every such story has been tried and dies on some experiment (we will kill a few ourselves in Section 1.5). Instead, let us do the more courageous thing: find the rules of the bookkeeping that gets every number right, and follow wherever they lead.

Now we are going to do something a little unusual: we are going to tell you the answer before you can possibly see why it is the answer. We cannot explain why nature keeps her books this way — we can only show you the bookkeeping and let you check, again and again, that it never fails. Three rules. Everything in this book grows out of them.

Rule 1. The probability of an event is the squared magnitude of a complex number $\psi$ called the probability amplitude:

Rule 2. When an event can happen in several indistinguishable ways, the amplitude is the sum of the amplitudes for each way:

Rule 3. If an experiment is performed which is capable of determining which way was taken, the ways become distinguishable: interference is lost and probabilities add, $P=P_1+P_2$.

Expand the square in (1.4) — this two-line computation is the whole ballgame:

Classical probability keeps only $P_1+P_2$. Quantum mechanics adds the cross term, which oscillates with the phase difference $\delta ={\theta }_2-{\theta }_1$ and can be as negative as it is positive. Where does the phase come from? Each path of length $r$ contributes $\theta =kr$ with $k=2\pi /\lambda$ — the amplitude is a little clock hand that turns once per wavelength of travel. For slits separated by $d$, a screen at distance $L$, and small angles, the path difference to the point $x$ is $\approx dx/L$, so

Read (1.6) as a design rule: long wavelength, distant screen and close slits all widen the fringes. Our apparatus is a helium–neon laser, $\lambda =633\mathrm{nm}$, through slits $d=40\mu \mathrm{m}$ apart onto a screen at $L=1\mathrm{m}$ — a ratio that lands $\lambda L/d$ squarely in the millimetres, which is the whole reason the pattern above is something you can look at. The widget below prints the exact figure its own model uses, and Section 1.7's lab prints both that number and the spacing it measures from fifty thousand simulated arrivals; we quote neither here, because a lab run is allowed to change them and this sentence is not. Now see equation (1.5): drag the detector along the screen and watch the two amplitudes add as arrows in the complex plane.

This picture — amplitudes as rotating arrows, probability as the squared length of their sum — scales without modification from two slits to atoms, chemical bonds, and quantum computers. It is the single mental image most worth owning in all of physics.

Rule 3 deserves its own experiment, because it sounds like mysticism and is in fact bookkeeping. Put a light source behind the slits: an electron scatters a photon as it passes, and the flash tells us which hole it used. The moment the apparatus records the path — whether or not any human looks — the two routes become distinguishable alternatives, and the interference term dies. Turn on the lamp in the electron simulation above (watch which slit) and see the fringes collapse into bullet humps.

The deeper point is quantitative. Let $\gamma \in [0,1]$ measure how much coherence survives the monitoring — $\gamma =1$ for no record, $\gamma =0$ for a perfect one. The detection law interpolates smoothly:

and the fringe visibility — the local contrast $V=(P_{\max }-P_{\min })/(P_{\max }+P_{\min })$ — equals $\gamma$ near the center of the pattern, where the two slits light the screen equally. Kept exactly, the contrast drags the single-slit envelopes along too, $V=\gamma \frac{2\sqrt{P_1{P}_2}}{P_1+P_2}$, which is $\gamma$ at $x=0$ (there $P_1=P_2$) and dips a little below it toward the edges, since one slit is nearer than the other. Visibility is just how completely the two paths still interfere: $V=1$ is a perfect superposition, $V=0$ a classical either/or, and partial which-path information lands you smoothly in between. That continuous slide — made precise in Chapter 4 as decoherence — is where the classical world comes from: big things are watched by everything around them all the time, so their $\gamma$ is driven to zero and the fringes we can coax from an electron are hopeless for a baseball.

Could a gentler lamp beat Rule 3 — find the path without killing the fringes? Heisenberg's answer is no, and the double slit shows why with almost no algebra. To tell the slits apart, a photon must resolve a distance $d$, so its wavelength must satisfy ${\lambda }_{\text{ph}}\lesssim d$. But a photon carries momentum $p_{\text{ph}}=h/{\lambda }_{\text{ph}}$, and scattering delivers a random kick of that order to the electron:

A kick $\Delta p$ smears the electron's arrival angle by $\Delta \theta \sim \Delta p/p=\lambda /d$ — using $p=h/\lambda$ for the electron itself. But $\lambda /d$ is, by equation (1.6), precisely the angular spacing of the fringes. The gentlest possible which-path measurement jiggles each electron by just enough to wash the pattern out. Try to be cleverer — redder light for a softer kick? Then the wavelength grows past $d$ and the flash can no longer tell you which slit it came from. Every scheme anyone has invented, and people have invented marvelous ones, fails by exactly this kind of accounting. Not roughly. Exactly. If someone ever beats it by even a hair, quantum mechanics is dead — that is what we mean by a physical law.

The general statement, which we will derive properly from the formalism in Chapter 4, bounds any simultaneous preparation of position and momentum:

Note what (1.9) is not: it is not about clumsy instruments, and it is not a statement that the electron “secretly has” a sharp position and momentum we merely fail to learn. There is no state of affairs in which both are sharp — that is a theorem about amplitudes, as we will prove.

Time to own this chapter by computing it. The lab Rust-QP/ch01-double-slit builds the entire experiment in one file: the amplitude model, the Born rule, a single-photon detector, six referees that try to break all of it, and the data files behind every chart on this page. The heart is a direct transcription of Rules 1–3 into num-complex:

1/// Fraunhofer (far-field) amplitude at screen position `x` from ONE slit
2/// of width `a` centered at `x0`. Two physical effects combine:
3///
4///   1. DIFFRACTION ENVELOPE. A slit of finite width `a` spreads light into
5///      a single-slit pattern whose amplitude is the normalized sinc,
6///      sin(beta)/beta, with beta = pi*a*sin(angle)/lambda and (small angle)
7///      sin(angle) ≈ (x - x0)/ell. As beta -> 0 the sinc -> 1, so we special-
8///      case that limit to avoid the 0/0 at the optic axis.
9///   2. PROPAGATION PHASE. Huygens: each slit is a secondary source, so the
10///      amplitude at the screen carries the phase exp(i*k*r) of the path it
11///      travelled, where k = 2*pi/lambda and r is the slit->screen distance.
12///      Using the paraxial (Fresnel) expansion of sqrt(ell^2 + (x-x0)^2),
13///      r ≈ ell + (x - x0)^2 / (2*ell). It is the DIFFERENCE of these phases
14///      between the two slits that produces the interference fringes.
15fn slit_amplitude(&self, x: f64, x0: f64) -> Complex64 {
16    let k = 2.0 * PI / self.lambda;
17    // paraxial slit->screen path length (Fresnel/small-angle expansion)
18    let r = self.ell + (x - x0) * (x - x0) / (2.0 * self.ell);
19    // single-slit diffraction envelope (normalized sinc, ->1 as beta->0)
20    let beta = PI * self.a * (x - x0) / (self.lambda * self.ell);
21    let envelope = if beta.abs() < 1e-12 { 1.0 } else { beta.sin() / beta };
22    envelope * Complex64::new(0.0, k * r).exp()
23}
24
25/// Quantum/wave intensity with partial which-path knowledge.
26///
27/// gamma = 1: no which-path information  -> full interference
28/// gamma = 0: complete which-path record -> classical sum P1 + P2
29///
30///   P(x) = |psi1|^2 + |psi2|^2 + 2*gamma*Re(psi1* . psi2)
31fn intensity(&self, x: f64, gamma: f64) -> f64 {
32    let psi1 = self.slit_amplitude(x, -self.d / 2.0);
33    let psi2 = self.slit_amplitude(x, self.d / 2.0);
34    let p1 = psi1.norm_sqr();
35    let p2 = psi2.norm_sqr();
36    p1 + p2 + 2.0 * gamma * (psi1.conj() * psi2).re
37}

Note how faithfully the code mirrors the physics: psi1 + psi2 never happens as such — instead the cross term 2.0 * gamma * (psi1.conj() * psi2).re carries the interference, with gamma implementing Rule 3 as a dial. The synthetic experiment is then rejection sampling: propose a landing spot, accept it with probability proportional to $P(x)$ — one accepted sample is one click of a photon counter:

1/// Sample one photon arrival from the Born-rule density P(x) = |psi|^2 on
2/// [-x_max, x_max] by REJECTION SAMPLING — the computational Born rule.
3///
4/// The recipe: throw a dart uniformly into the bounding box
5/// [-x_max, x_max] x [0, p_max] and keep its x-coordinate whenever the dart
6/// falls UNDER the curve P(x). The accepted x's are then distributed exactly
7/// in proportion to P(x), one "click" of the detector per photon.
8///
9/// CORRECTNESS CONDITION: the ceiling `p_max` must be a true upper bound of
10/// P(x) over the whole interval. If p_max < max P(x), the region above p_max
11/// is silently truncated and the samples are biased. We therefore derive
12/// p_max from the actual maximum of the intensity over the grid (see main),
13/// not from an assumed peak location.
14fn fire_photon(app: &Apparatus, gamma: f64, x_max: f64, p_max: f64, rng: &mut StdRng) -> f64 {
15    loop {
16        let x = rng.gen_range(-x_max..x_max);
17        let u = rng.gen_range(0.0..p_max);
18        if u < app.intensity(x, gamma) {
19            return x;
20        }
21    }
22}
23
24// …
25
26let grid_max = xs
27    .iter()
28    .map(|&x| app.intensity(x, 1.0))
29    .fold(f64::NEG_INFINITY, f64::max);
30assert!(grid_max.is_finite(), "intensity grid produced a non-finite maximum");
31let p_max = grid_max * 1.01;
32let arrivals_mm: Vec<f64> = (0..n_photons)
33    .map(|_| fire_photon(&app, 1.0, x_max, p_max, &mut rng) * 1e3)
34    .collect();

Now the part that makes this a lab and not a demo. A simulation nobody audits is just a rumour: it will happily draw a beautiful fringe pattern out of an equation with a factor of two in the wrong place. So the program ends by trying to break itself. The rule we hold ourselves to for the rest of the book is that a self-check must be capable of failing: it is worthless if it compares a quantity against the very formula that produced it, or asserts something that is true by construction. (Checking that our $P(x)$ is symmetric about the axis would be exactly that kind of theatre — it is an even function of $x$ whether or not the physics is right.)

The honest way is a second, independent route to the same number. Our closed form asserted a $\mathrm{sinc}$ envelope; so let us earn that envelope instead, by taking Huygens literally — chop the open slit into a continuum of point sources, give each one its own path length, and add up the arrows numerically. The word sinc never appears:

1/// An INDEPENDENT SECOND PATH to the same amplitude, built from Huygens'
2/// principle instead of a closed form. Treat the open slit as a continuum
3/// of secondary point sources at offsets s in [-a/2, a/2], give each the
4/// far-field (Fraunhofer) path length
5///
6///     r(s, x) = ell + (x - x0)^2/(2*ell) - s*(x - x0)/ell,
7///
8/// and integrate exp(i*k*r) across the aperture with Simpson's rule,
9/// dividing by the width so the on-axis value is 1.
10///
11/// The word "sinc" does not appear in this function and neither does
12/// `beta`. If `slit_amplitude`'s envelope had the wrong argument, the
13/// wrong normalization, or the wrong sign in the propagation phase, the
14/// two routes would part company. That is Referee 1 — and it is exactly
15/// the derivation Exercise 7 asks the reader to do by hand.
16fn slit_amplitude_huygens(&self, x: f64, x0: f64, panels: usize) -> Complex64 {
17    let k = 2.0 * PI / self.lambda;
18    let m = 2 * panels; // even node count -> Simpson's rule
19    let h = self.a / m as f64;
20    let r0 = self.ell + (x - x0) * (x - x0) / (2.0 * self.ell);
21    let mut acc = Complex64::new(0.0, 0.0);
22    for j in 0..=m {
23        let s = -self.a / 2.0 + h * j as f64;
24        let r = r0 - s * (x - x0) / self.ell;
25        let w = if j == 0 || j == m {
26            1.0
27        } else if j % 2 == 1 {
28            4.0
29        } else {
30            2.0
31        };
32        acc += Complex64::new(0.0, k * r).exp() * w;
33    }
34    acc * (h / 3.0) / self.a
35}

Two referees fall out of comparing the routes across the whole screen. The first asks whether the closed-form amplitude and the aperture integral agree at all. The second asks something sharper: take the magnitudes from the quadrature, put in the phase $\delta (x)=2\pi dx/\lambda L$ from equation (1.6) — which the code never evaluates, since it works with complex exponentials of path lengths — and see whether that reproduces the interference term the model actually computes. If (1.6) were wrong, this is where the book would break:

1let quad_panels = 2_000;
2let mut worst_huygens = 0.0f64;
3let mut worst_cross = 0.0f64;
4for &x in &xs {
5    let closed1 = app.slit_amplitude(x, -app.d / 2.0);
6    let closed2 = app.slit_amplitude(x, app.d / 2.0);
7    let quad1 = app.slit_amplitude_huygens(x, -app.d / 2.0, quad_panels);
8    let quad2 = app.slit_amplitude_huygens(x, app.d / 2.0, quad_panels);
9    for (c, q) in [(closed1, quad1), (closed2, quad2)] {
10        assert!(
11            c.re.is_finite() && c.im.is_finite() && q.re.is_finite() && q.im.is_finite(),
12            "non-finite slit amplitude at x = {x:.6} m"
13        );
14        worst_huygens = worst_huygens.max((c - q).norm());
15    }
16    let measured_cross = app.intensity(x, 1.0) - app.intensity(x, 0.0);
17    let delta = 2.0 * PI * app.d * x / (app.lambda * app.ell); // equation (1.6)
18    let predicted_cross = 2.0 * quad1.norm() * quad2.norm() * delta.cos();
19    assert!(measured_cross.is_finite(), "non-finite cross term at x = {x:.6} m");
20    worst_cross = worst_cross.max((measured_cross - predicted_cross).abs() / peak);
21}
22referees.push(Referee {
23    name: "Huygens quadrature vs closed-form sinc: max |Δψ|".into(),
24    value: worst_huygens,
25    tol: 2e-9,
26    pass: worst_huygens < 2e-9,
27});
28referees.push(Referee {
29    name: "Interference term vs eq (1.6): max |Δ| / P(0)".into(),
30    value: worst_cross,
31    tol: 2e-9,
32    pass: worst_cross < 2e-9,
33});

Four more follow the same discipline. One measures the fringe visibility at the pattern centre for every $\gamma$ in the sweep and demands it come back equal to $\gamma$ — the claim §1.5 makes and nothing else in the lab enforces. One recovers the fringe period from the arrival positions alone, with a tapered periodogram that has never seen $\lambda L/d$, and compares; the statistical scale it is judged against is measured from the run itself, by splitting it into ten disjoint blocks, rather than guessed. And two audit the sampler: the Born density is integrated over forty bins by Simpson's rule — a code path that never touches the random number generator — and the observed counts are compared bin by bin, worst bin and total ${\chi }^2$ alike. A rejection ceiling set too low would shave the bright fringes and nothing else in the program would notice; these two would.

Running cargo run --release produces double_slit.json (theory curves, the arrivals, the decoherence sweep and the referee array), a small summary.json, arrivals.csv, and a native plotters chart. The replay below streams the actual file your lab produced — the same statistical flicker, the same slow emergence of order — and the scoreboard under it is read straight out of that file, so what you see is your own run's verdict, not ours:

A statistical check worth doing consciously: with $N$ photons, bin counts fluctuate as $\sqrt{N}$ — the hallmark of Poisson statistics, the law obeyed by independent random arrivals like raindrops or detector clicks — so the fractional noise falls like $1/\sqrt{N}$. That is why the fringes are invisible after a hundred counts and razor-sharp after fifty thousand — quantum randomness is lawless per event and iron-lawed in aggregate. It is also why the last three referees are quoted in standard deviations rather than decimal places: against random data, “how close” is meaningless until you say close compared to what.

1. (F) From equation (1.5), show that the fringe visibility of a two-slit pattern with unequal slit amplitudes $r_1,r_2$ is $V=2r_1{r}_2/(r_1^2+r_2^2)$. What ratio $r_1/r_2$ gives $V=0.5$?
2. (F) An electron accelerated through 50 kV has de Broglie wavelength $\lambda =h/\sqrt{2m_{e}eU}$ (ignore relativity). Compute $\lambda$, then put it into (1.6) with this chapter's geometry — $d=40\mu \mathrm{m}$, $L=1$ m — and get the fringe spacing an electron would give on the simulated bench. Compare it with the optical pattern you watched. Then invert the problem: what $d$ would you need for 1 mm fringes at $L=1$ m? Why did it take until 1961 (Jönsson) to do this with electrons?
3. (C) In the phasor widget, find the first position where the two arrows exactly oppose. Verify it sits at half the fringe spacing the widget reports. Then explain, in one sentence, why the fringes get shallower toward the edges of the screen (hint: the arrows have lengths, not just angles), and compute where the single-slit envelope would first vanish completely — the lab prints that number, so check yourself against it. Is it on the screen or off it?
4. (P) Modify the lab to fire photons with the lamp on (gamma = 0.0) and overlay both histograms with plotters. Confirm the lamp-on histogram matches $P_1+P_2$.
5. (P) Add a third slit at x0 = 3d/2 and predict the pattern before running. (Amplitudes add — all three of them.) Where are the new principal maxima?
6. (P, harder) Estimate the fringe visibility from your 50,000 arrivals by fitting $A{\mathrm{sinc}}^2(\beta )(1+V\cos \delta )$ with a least-squares grid search over $V$. How close to 1 do you get, and what limits it?
7. (F, hard) The lab's slit_amplitude asserts a sinc envelope. Earn it: treat the slit of width $a$ as a continuum of point sources (Huygens), write the total amplitude as the integral $\psi (x)\propto {\int }_{-a/2}^{a/2}{e}^{ikr(s,x)}ds$ with the small-angle expansion of the path length $r(s,x)$, and carry out the integral to derive $\mathrm{sinc}(\pi ax/\lambda L)$. Then show where the far-field (Fraunhofer) approximation enters: which term of $r(s,x)$ did you drop, and for what $L$ does it fail? Verify your failure threshold numerically by modifying the lab to keep the quadratic term.
8. (P, hard) A real detector has dark counts: a fraction $f$ of clicks are uniformly random on the screen. Derive the measured visibility $V(f)$ as a function of dark-count fraction, then add dark counts to the Rust lab, fit V from the synthetic data at several $f$, and check your formula. At what $f$ would you no longer be able to claim (at 5σ, with 50,000 clicks) that interference exists at all?