Entanglement and Information

In 1935, Einstein — with Podolsky and Rosen — published the most productive objection in the history of physics. Strip their argument to its modern form (Bohm's version, using Chapter 11's singlet): two electrons fly apart in the state

which has total spin zero about every axis. Measure your electron along any direction you like — z, x, 45°, anything — and your partner's electron, measured along the same direction, is instantly guaranteed opposite. Every time. Light-years apart if you wish.

EPR's reasoning: nothing I do here can disturb a particle over there (locality), yet I can predict with certainty the outcome over there — along whichever axis I choose to measure. So the answers must have been written down in advance, all of them, in some ledger the particles carried from the source. Quantum mechanics, which contains no such ledger, must be incomplete — a statistical shadow of a deeper theory, the way thermodynamics shadows mechanics. It is a beautiful argument. Bohr's reply was murky, and for thirty years the matter was dinner-table philosophy — until John Bell, in 1964, noticed that the ledger hypothesis makes a quantitative prediction of its own, and that quantum mechanics violates it. Not philosophy: an inequality. Something an experiment can settle — and something a program can make painfully concrete, by building the best ledger anyone has thought of and watching exactly where it runs out of room.

First, make “entangled” precise. A two-part state is a product if it factorizes, ψ = φ_A ⊗ χ_B — then each part has its own state and its own story. It is entangled if it does not. The singlet cannot factorize (try it: matching the up-down terms forces coefficients that kill the down-up terms), and there is a canonical form that measures the failure. Any two-part pure state can be written as a Schmidt decomposition:

one orthonormal basis per side, weights λ_k. One term: product. More than one: entangled. And what does one observer, holding only particle A, actually see? Chapter 4's density operator — introduced there for honest-ignorance mixtures — pays its biggest debt here. The tool is the partial trace ${\mathrm{Tr}}_B$ from Chapter 4: it averages subsystem B completely away — summing over any basis of B's states — to leave the reduced state ${\rho }_A$ that describes everything Alice can measure on her particle alone. Tracing out B:

For the singlet, ρ_A = I/2: a fair coin. Every measurement on one electron alone, any axis, any cleverness, yields pure noise — S = ln 2, one full bit of ignorance — while the pair is in a single, perfectly definite pure state. Sit with that inversion: classically, to know the whole is to know the parts. Here the whole is known exactly and each part is maximally unknown, because what is definite is not either spin but the relation between them. That is entanglement, said in one sentence. It also disposes of the obvious telegraph scheme: since ρ_A never depends on anything done to B, no measurement choice over there can signal over here. Whatever spookiness is, it is not a radio.

Bell's move: stop arguing about what the ledger is and bound what any ledger could do. Suppose outcomes are determined by shared information λ (any information, any distribution) and each station's result depends only on its own setting and λ: A(a, λ) = ±1, B(b, λ) = ±1. Consider the CHSH combination (after Clauser, Horne, Shimony, and Holt, who in 1969 recast Bell's inequality into this experiment-ready form) of correlations at four settings. For each λ,

identically — one bracket is 0 and the other ±2, because the B's are just two numbers ±1. Average over any λ whatsoever and

That is the entire theorem — three lines, no quantum mechanics anywhere. Now ask the singlet. Its correlation is E(a, b) = −cos(a − b) (the lab computes it twice without ever writing that cosine down: once as a literal 4×4 expectation value, once as a trace against an explicitly built density matrix), and at the settings a = 0°, a′ = 90°, b = 45°, b′ = 135° each term contributes 1/√2 with the right sign:

The ledger hypothesis and quantum mechanics disagree about a measurable number. No interpretation can arbitrate that — only apparatus. Figure 18.1 is that apparatus, and every real Bell test since 1972 is a version of it: one entangled pair, two freely chosen settings, two detectors, and a counter that turns clicks into $S$.

Nature answered in stages: Freedman–Clauser (1972), Aspect with time-varying analyzers (1982), and in 2015 three loophole-free experiments at once — entangled electrons in Delft separated by 1.3 km, detection- efficient photons in Vienna and Boulder, setting choices made after the particles were in flight. S > 2 every time; the 2022 Nobel Prize certified the campaign. Be precise about the casualty: what died is local realism — the conjunction of “outcomes pre-exist” and “no influence travels faster than light.” You may keep either half, but not both, and no future theory — however deep, however clever — gets them both back. Einstein asked exactly the right question, and the answer is the one he bet against.

One boundary worth marking before the lab, because it is the difference between physics and bookkeeping: a computer cannot do what those experiments did. Simulate the singlet as carefully as you like and you have measured a model, not the world; the arithmetic can only tell you what quantum mechanics predicts. What a program can do — and what §18.6 does — is build local realism's best machine, run it, and watch it stall at exactly 2 while the quantum prediction sails past. The stalling is the theorem, made concrete. The verdict on nature was and remains experimental.

If superposition and entanglement are so fundamental, why have you never seen a chair in two places? The answer was hiding in (18.3), and it is the same machinery running in reverse. A chair — or a dust grain, or Schrödinger's cat — cannot avoid interacting with its surroundings: every photon that bounces off it, every gas molecule it deflects, becomes entangled with its position. Each scatter is a tiny which-path record carried off into the environment. And interference between two branches survives only to the extent that the environment's records of them overlap: the fringe term picks up a factor ⟨E_left|E_right⟩ per record. Nobody reads the records; nobody needs to. The interference is not destroyed — it is exported into correlations with 10²⁰ scattered photons, where no screen made by humans can ever reassemble it.

This is decoherence, and it earns three paychecks at once. It says why the classical world looks classical without paying an observer: environments measure incessantly, and the states that survive the measuring — position-like “pointer states” — are exactly the ones we call classical. It says why Haroche's cavity cats (Chapter 17's half-revival states) died faster the bigger he made them, precisely on schedule. And it names the enemy of the entire quantum-information enterprise: a quantum computer is a machine whose whole job is to keep large superpositions coherent while the universe tries to read them — which is why error correction, not more qubits, is the real frontier. One honesty note, in this book's tradition: decoherence explains the appearance of definite outcomes, not the selection of one — Chapter 4's measurement question retires undefeated. What it does explain is why you will never catch the superposition in the act.

The modern turn — the one that renamed this field “quantum information” — was to stop treating all this strangeness as a bug to be interpreted and start treating it as a resource to be spent. First, a ground rule, provable in one line: quantum information cannot be copied. A cloner would need U|ψ⟩|0⟩ = |ψ⟩|ψ⟩ for every ψ; apply it to two states and compare inner products — unitarity preserves them, so ⟨φ|ψ⟩ = ⟨φ|ψ⟩², an equation with exactly two solutions, 0 and 1. A machine may copy states it knows to be mutually orthogonal (that is ordinary classical copying: measure which one, write it down twice), and of course it may copy a state onto itself — and nothing else. Every superposition in between is uncopyable. No cloning: the theorem that makes quantum cryptography honest (an eavesdropper cannot copy the key without trace) and quantum error correction hard (you cannot back up a qubit).

But you can move a qubit without moving anything quantum. Teleportation (1993): Alice holds an unknown |ψ⟩ and shares one entangled pair with Bob. She measures her two qubits in the Bell basis — the four maximally-entangled two-qubit states (the singlet of equation (18.1) and its three siblings), so the measurement yields four outcomes, two classical bits — and sends the bits by ordinary radio. Bob applies one of four Paulis: the identity, a bit-flip $X$, a phase-flip $Z$, or both $XZ$ — the same single-qubit gates from Chapter 2, $X$ swapping $|0⟩\leftrightarrow |1⟩$ and $Z$ flipping the sign of $|1⟩$. His qubit is now |ψ⟩ — exactly, provably, every time (the lab runs 200 random input states through the full protocol and referees the infidelity against 10⁻¹⁴), while Alice's original is destroyed by her measurement, as no-cloning insists. And until the radio message lands, Bob holds I/2 — nothing. Entanglement is a currency that only clears when accompanied by classical communication; relativity is never even inconvenienced.

Then the largest idea: if states carry information, dynamics is computation. A qubit is Chapter 2's two-level system wearing an information hat; gates are the unitaries this book has built throughout; and n qubits span 2ⁿ amplitudes evolving at once. The catch — and the art — is that measurement reads out only n bits: raw parallelism is useless without interference, arranging the 2ⁿ paths so wrong answers cancel and right ones reinforce. Chapter 1's arrows, aimed on purpose. Watch it done:

Grover's √N is the honest, provably optimal speedup for structureless search. Structure buys more: Shor's algorithm factors integers in polynomial time by using the quantum Fourier transform to find periods — the exponential threat that made cryptographers care — and quantum simulation of quantum matter (Chapters 15–16's exponentially large Fock spaces, natively represented) is likely the first place real value lands, just as Feynman proposed in 1982. Between here and there stands decoherence, and the remarkable discovery that defeats it in principle: quantum error correction, which protects a logical qubit by entangling it across many physical ones — fighting entanglement's curse with entanglement's own tools. That story — codes, thresholds, algorithms, and the machines being built right now — is a book of its own. It is, in fact, the next one.

The finale's lab (Rust-QP/ch18-bell) has one delicate job to do honestly. It computes the singlet correlation three independent ways, and the third way is the interesting one: instead of sampling a formula for E(a,b), it measures — it builds the projectors $P^{\pm }=(I\pm {\sigma }_{\hat{n}})/2$ out of the analyzer matrices, draws Alice's outcome from the Born probability, collapses the pair, and draws Bob's outcome from what is left. Four hundred thousand such pairs at each of 37 angles, and a million at each CHSH setting. Nothing in the sampler knows the answer is a cosine, so when it reproduces the density matrix's number, that means something:

1/// PATH (c). One Monte-Carlo estimate of E(a,b) by actually MEASURING:
2/// Alice's outcome is drawn from the Born probability ⟨ψ|P⁺_a ⊗ I|ψ⟩, the
3/// state is collapsed and renormalized, and Bob's outcome is drawn from
4/// the survivor. The pair state is the same for every event, so the Born
5/// probabilities are computed once and sampled n times — but they come
6/// from projectors and a state vector, never from a closed form for the
7/// correlation. Returns (⟨s₁s₂⟩, frequency of s₁ = +1).
8fn singlet_e_mc(a: f64, b: f64, n: usize, rng: &mut StdRng) -> (f64, f64) {
9    let psi = singlet();
10    // Alice measures σ_a: |φ₊⟩ = (P⁺_a ⊗ I)|ψ⟩, P(s₁ = +1) = ⟨ψ|φ₊⟩
11    let phi_p = apply_a(&proj_plus(a), &psi);
12    let p1 = dot4(&psi, &phi_p).clamp(0.0, 1.0);
13    let mut phi_m = [0.0f64; 4];
14    for i in 0..4 {
15        phi_m[i] = psi[i] - phi_p[i]; // because P⁻ = I − P⁺
16    }
17    // collapse and renormalize each branch, then Bob measures σ_b on it
18    let mut collapsed = [[0.0f64; 4]; 2];
19    let mut q = [0.0f64; 2]; // P(s₂ = +1 | s₁ = ±1)
20    for (branch, (raw, norm2)) in [(phi_p, p1), (phi_m, 1.0 - p1)].iter().enumerate() {
21        let nrm = norm2.max(1e-300).sqrt();
22        for i in 0..4 {
23            collapsed[branch][i] = raw[i] / nrm;
24        }
25        let chi = apply_b(&proj_plus(b), &collapsed[branch]);
26        q[branch] = dot4(&collapsed[branch], &chi).clamp(0.0, 1.0);
27    }
28    let mut sum = 0i64;
29    let mut n_plus = 0i64;
30    for _ in 0..n {
31        let plus1 = rng.gen::<f64>() < p1;
32        let s1: i64 = if plus1 { 1 } else { -1 };
33        n_plus += plus1 as i64;
34        let s2: i64 = if rng.gen::<f64>() < q[if plus1 { 0 } else { 1 }] { 1 } else { -1 };
35        sum += s1 * s2;
36    }
37    (sum as f64 / n as f64, n_plus as f64 / n as f64)
38}

Now local realism's best hand. The hidden-variable machine below is not a straw man: a shared random axis λ agreed on at the source, deterministic ±1 outcomes at each station depending only on λ and that station's own setting. It gets the endpoints exactly right — perfect anticorrelation at 0°, perfect correlation at 180° — and at the CHSH angles it climbs all the way to its ceiling and no further. The lab referees that from both sides: the model must not sneak past 2, and it must actually reach 2, or we would be congratulating ourselves for beating something feeble.

1/// The explicit LHV model, played to win: a shared random axis λ and
2/// deterministic outcomes A = sign(cos(a−λ)), B = −sign(cos(b−λ)).
3/// It is local (each station sees only its own setting and λ) and it is
4/// realist (both outcomes exist before either is read).
5fn lhv_e_mc(a: f64, b: f64, n: usize, rng: &mut StdRng) -> f64 {
6    let mut sum = 0i64;
7    for _ in 0..n {
8        let lambda = rng.gen::<f64>() * 2.0 * PI;
9        let s1: i64 = if (a - lambda).cos() >= 0.0 { 1 } else { -1 };
10        let s2: i64 = if (b - lambda).cos() >= 0.0 { -1 } else { 1 };
11        sum += s1 * s2;
12    }
13    sum as f64 / n as f64
14}
15// …
16    let mut s_lhv = 0.0;
17    let mut var_lhv = 0.0;
18    for (sign, a, b) in [(1.0, a1, b1), (-1.0, a1, b2), (1.0, a2, b1), (1.0, a2, b2)] {
19        let e = lhv_e_mc(a, b, n_chsh, &mut rng);
20        s_lhv += sign * e;
21        var_lhv += (1.0 - e * e) / n_chsh as f64;
22    }
23    s_lhv = s_lhv.abs();
24    let s_lhv_sigma = var_lhv.sqrt();
25    // refereed from BOTH sides: the model must not sneak past 2, and it must
26    // actually REACH 2 — otherwise we would be beating a straw man.
27    let lhv_sigmas_from_2 = (s_lhv - 2.0) / s_lhv_sigma;

Read the scoreboard below with one caution, which the lab prints in its own output. The Monte Carlo's σ count above 2 is large, and it is not a refutation of local realism: those samples were drawn from the quantum state, so the number says how sharply this many simulated pairs resolve the gap between the quantum prediction and the classical ceiling — resolving power, not a verdict on nature. The verdict on nature is the 2015 experiments. The refutation this lab can deliver is one row lower: an explicit local ledger, given every advantage, stuck at 2.

1// entangle qubits 1,2 into a Bell pair
2        apply_1q(&mut psi, 1, h_gate);
3        apply_cnot(&mut psi, 1, 2);
4        // Bell measurement on qubits 0,1
5        apply_cnot(&mut psi, 0, 1);
6        apply_1q(&mut psi, 0, h_gate);
7        // Bob's unconditioned state (before Alice's classical message):
8        // accumulate the reduced density matrix of qubit 2
9        // …
10        n_rho += 1.0;
11        let m0 = measure(&mut psi, 0, &mut rng);
12        let m1 = measure(&mut psi, 1, &mut rng);
13        // corrections on Bob's qubit 2
14        if m1 == 1 {
15            apply_1q(&mut psi, 2, x_gate);
16        }
17        if m0 == 1 {
18            apply_1q(&mut psi, 2, z_gate);
19        }
20        // fidelity of qubit 2 with the input: after the measurements only
21        // one (m0, m1) branch survives, so ψ = |m0 m1⟩ ⊗ |φ⟩ and the
22        // overlap ⟨ψ_in|φ⟩ is a single coherent sum
23        let mut amp = C::new(0.0, 0.0);
24        for rest in 0..4usize {
25            amp += alpha.conj() * psi[rest] + beta.conj() * psi[(1 << 2) | rest];
26        }
27        let fid = amp.norm_sqr();
28        worst_infid = worst_infid.max((1.0 - fid).abs());
29    }
30    let mut nosignal = 0.0f64;
31    for i in 0..2 {
32        for j in 0..2 {
33            let target = if i == j { 0.5 } else { 0.0 };
34            nosignal = nosignal.max((rho_avg[i][j] / n_rho - C::new(target, 0.0)).norm());
35        }
36    }

1// -- 4. Grover ---------------------------------------------------------------
2    let n_items = 1024usize;
3    let target = 137usize;
4    let theta = (1.0 / (n_items as f64).sqrt()).asin();
5    let k_opt = (PI / (4.0 * theta)).floor() as usize;
6    let mut amp = vec![1.0 / (n_items as f64).sqrt(); n_items];
7    let mut grover_k = Vec::new();
8    let mut grover_p = Vec::new();
9    let mut grover_analytic = Vec::new();
10    let mut grover_worst = 0.0f64;
11    for k in 0..=40usize {
12        let p = amp[target] * amp[target];
13        // analytic P after k iterations: sin²((2k+1)θ)
14        let p_analytic = ((2.0 * k as f64 + 1.0) * theta).sin().powi(2);
15        grover_k.push(k);
16        grover_p.push(p);
17        grover_analytic.push(p_analytic);
18        grover_worst = grover_worst.max((p - p_analytic).abs());
19        // one Grover iteration: oracle (flip target) + diffusion
20        amp[target] = -amp[target];
21        let mean: f64 = amp.iter().sum::<f64>() / n_items as f64;
22        for a in amp.iter_mut() {
23            *a = 2.0 * mean - *a;
24        }
25    }
26    let grover_p_kopt = grover_p[k_opt];
27    // the analytic optimum must be where the NUMERIC curve actually peaks
28    let k_argmax = grover_p
29        .iter()
30        .enumerate()
31        .max_by(|x, y| x.1.partial_cmp(y.1).unwrap())
32        .map(|(k, _)| k)
33        .unwrap();
34    let kopt_vs_argmax = (k_argmax as f64 - k_opt as f64).abs();

1. (F) Prove the singlet is rotationally invariant — write it in the basis of any axis n̂ and show the form (18.1) survives — and conclude the perfect anticorrelation EPR leaned on. Then prove it cannot be written as a product state.
2. (F) Derive E(a,b) = −cos(a−b) for the singlet three ways: brute expectation value (as the lab does), rotational invariance plus the z-axis case, and the joint distribution P(s₁,s₂) = ¼(1 − s₁s₂ cos θ) — which is what the lab's projector sampler generates event by event without ever being handed it. Check the LHV model's sawtooth −1 + 2θ/π against the widget.
3. (F) Walk (18.4)–(18.5) yourself, then find the four angles that maximize S for the singlet and prove no settings do better than 2√2 for this state. (Tsirelson proved no quantum state and settings beat 2√2 at all — try the 2×2 operator-norm argument.)
4. (C) In the Bell explorer, the two curves agree at 0°, 90°, 180°. Explain why any LHV model that reproduces the three agreement points must be linear-ish in between (hint: monotonicity and the triangle inequality on disagreement probabilities), and why the cosine's curvature is therefore the whole ballgame.
5. (F) Trace the teleportation algebra: write |ψ⟩⊗|Φ⁺⟩, regroup Alice's two qubits in the Bell basis, and show the four branches leave Bob holding |ψ⟩, X|ψ⟩, Z|ψ⟩, XZ|ψ⟩ with equal probability ¼ — hence the two classical bits, hence I/2 before they arrive, hence no signaling.
6. (F, hard) Decoherence, quantitatively. A superposition of two positions separated by Δx in a photon bath: each scattered photon of wavelength λ ≫ Δx records which-path information ~(Δx/λ)². Show the off-diagonal element decays at rate Γ_dec ≈ Φ(Δx/λ)² (Φ = scattering flux), estimate Γ_dec for a 1 μm dust grain in sunlight, and compare with its classical relaxation time. (You will find factors of 10²⁰ — why superposition is a microscopic luxury.)
7. (F, hard) The three-qubit bit-flip code, by hand: encode α|0⟩+β|1⟩ → α|000⟩+β|111⟩ (with two CNOTs — why doesn't this violate no-cloning?), let one unknown qubit flip, and show the two syndrome measurements Z₁Z₂ and Z₂Z₃ locate the error without ever learning α or β — the loophole that makes error correction possible at all. Then find the code's blind spot (phase errors) and sketch why nine qubits (Shor) can cover both.
8. (P, hard) Build Deutsch–Jozsa in the lab's state-vector kit: n = 8 qubits plus an ancilla, oracles for constant and balanced functions, and show one query separates them with certainty where classical logic needs 2ⁿ⁻¹ + 1. Referee: the final amplitude on |0…0⟩ must be exactly ±1 (constant) or exactly 0 (balanced) — machine precision, no sampling. Then count gates honestly and reflect on what the “speedup” did and did not cost.