Introduction: How to Read This Book

Quantum mechanics is usually taught twice, badly. The first time, you meet it as a historical costume drama — blackbody radiation, Bohr orbits, half-truths that must later be unlearned. The second time, in graduate school, it arrives as an avalanche of formalism in which the physics drowns. Most of us emerge able to calculate but not to see, or able to talk but not to compute.

This book is a third path, distilled from seven canonical texts. From Feynman it takes the storyline: start with the one experiment that contains the whole mystery, and let two-state systems carry the weight. From Sakurai and Susskind it takes the modern entry point: spins and qubits first, bra-ket language from page one, no detour through wave-mechanics nostalgia. From Cohen-Tannoudji it takes the standard of rigor: when we derive something, we derive all of it. And from Ballentine it takes the modern development: probability treated honestly, measurement treated carefully, and the frontier — Bell tests, quantum information — treated as physics, not philosophy.

What none of those books could do in print is what this one is built for: every concept here is something you can poke. The experiments run live in your browser, and the numbers behind them come from programs you can read, run, and break — written in Rust.

Each chapter interleaves three layers. They are color-coded throughout the book, and a full pass through a chapter touches all three:

The order within each chapter varies, but the contract does not: nothing is asserted that is not derived; nothing is derived that is not visualized; nothing is visualized that you cannot compute yourself.

The book has four parts, and the route is logical rather than historical:

Part I earns the formalism: two experiments — the double slit and Stern–Gerlach — whose results are impossible classically, force complex amplitudes and state vectors on us. Only then do we build the machinery and state the postulates. Part II sets states in motion, from the ammonia maser to wave packets, the harmonic oscillator, and Feynman's sum over histories. Part III is the physics of structure: rotations, the hydrogen atom, perturbation theory, scattering. Part IV reaches the modern frontier: many identical particles, quantum matter, quantum light, and the entanglement experiments that settled the Einstein–Bohr debate.

Honest prerequisites: calculus, linear algebra, and complex numbers. Everything else is built on the way. The single most important object in this entire book is embarrassingly small — a complex number attached to a possibility,

called a probability amplitude. Quantum mechanics is, mathematically, the discovery that nature computes probabilities as

— squaring after summing over indistinguishable alternatives — rather than the classical $P=P_1+P_2+\cdots$. The cross terms in that square are interference, and interference is the engine of every phenomenon in this book, from atomic spectra to superconductivity. If you internalize equation (0.1), Chapter 1 will feel like watching it happen.

Physics codes live or die by two things: numerical correctness and speed. Rust gives both, plus something pedagogically precious — the compiler forces you to say exactly what you mean. Dimensional slips, aliasing bugs, and accidental copies that silently corrupt a Python simulation simply do not compile here. The crates we use:

• num-complex — complex arithmetic, the native language of amplitudes
• nalgebra — vectors, matrices, operators
• rand + rand_distr — Monte Carlo sampling: our synthetic experiments
• rustfft — split-operator evolution of wave packets (Part II)
• plotters — native charts straight from the simulation
• serde / csv — data exchange with this web book's Nivo charts

Install Rust once with rustup, then every lab is cargo run --release inside Rust-QP/<chapter-lab>/. Here is the spirit of the whole enterprise in fifteen lines:

1// Your first quantum computation: a state is a complex vector,
2// a measurement is a projection, a probability is a squared length.
3use num_complex::Complex64;
4
5fn main() {
6    let inv_sqrt2 = 1.0 / 2.0_f64.sqrt();
7    // |+> = (|0> + |1>) / sqrt(2)   — an equal superposition
8    let psi = [
9        Complex64::new(inv_sqrt2, 0.0),
10        Complex64::new(inv_sqrt2, 0.0),
11    ];
12    // Born rule: P(0) = |<0|psi>|^2
13    let p0 = psi[0].norm_sqr();
14    let p1 = psi[1].norm_sqr();
15    println!("P(0) = {p0:.3}, P(1) = {p1:.3}"); // 0.500, 0.500
16}

Five works — seven volumes, counting Cohen-Tannoudji's three — stand behind every chapter; each chapter's Sources line names the ones it leans on, so you can go deeper at any point.

One warning inherited from all of them, especially Feynman and Susskind: do not ask “but what is it really doing?” expecting a classical answer. The honest answer — the one this book equips you to own rather than merely repeat — is that nature runs on amplitudes. Our job is to learn that language well enough to calculate, predict, visualize, and build.