Combining and Conserving

Tune a radio telescope to 1420.4 MHz — a wavelength of 21 centimeters — and point it anywhere. The plane of the Milky Way. A patch of “empty” sky. Another galaxy. You will hear hydrogen. Cold, dark, invisible-to-every-optical-telescope hydrogen, humming the same pure note from everywhere in the universe at once. Radio astronomers used that note to map the spiral arms of our own galaxy — the first picture of our cosmic address — and it is printed on the Pioneer and Voyager plaques as the unit of measure any physicist in the universe should recognize.

Now the puzzle. Chapter 10 solved hydrogen completely — every level, every Balmer line, five significant figures — and nothing in that solution sings at 21 cm. The lowest real transition we found — Lyman-α, 10.204 eV — lives in the far ultraviolet, about 1.7 million times more energetic than the 5.874 µeV a 21 cm photon carries. So where does the note come from?

From what we ignored. The electron is a spin-½; so is the proton. The ground state of hydrogen is therefore not one state but four — two spin choices each — and the tiny magnetic handshake between the two spins splits those four into a group of three and a group of one, a whisper of energy apart. The 21 cm note is an atom dropping from the three to the one. The size of the whisper needs Chapter 12's tools; but the structure — why three-plus-one, what those states are, and why one of them is the strangest object we have met yet — is pure angular momentum arithmetic, and it is this chapter's prize. The question, precisely: what is the total angular momentum of two combined spins?

Classically the question is beneath asking: angular momenta are arrows, arrows add tip-to-tail, done. But our “arrows” are triples of non-commuting operators whose components cannot even be known at once — Chapter 9 taught us to expect subtlety, and here is where it lives. Start with what is easy. On the product space (Chapter 3: dimensions multiply, $(2j_1+1)(2j_2+1)$ states), define

acting on both factors. Since ${\hat{\vec{J}}}_1$ and ${\hat{\vec{J}}}_2$ commute with each other (different systems), the sum inherits the rotation algebra $[{\hat{J}}_x,{\hat{J}}_y]=i\hslash {\hat{J}}_z$ — so all of Chapter 9 applies wholesale: there must exist states $|j,m⟩$ of definite total ${\hat{J}}^2$ and ${\hat{J}}_z$. The subtlety is which questions can be asked together. Expand:

The cross term is the troublemaker: total-$j$ and the individual z-components are incompatible observables. You may know how each spin points, or how the pair combines — never both. So there are two natural bases, two complete questionnaires: the product basis $|m_1⟩|m_2⟩$ (ask each spin separately) and the total basis $|j,m⟩$ (ask the pair), and this chapter is the dictionary between them.

Which $j$'s appear? Counting settles it without solving anything. ${\hat{J}}_z$ does add simply — $m=m_1+m_2$ — so list how many product states share each m: exactly one has the maximum $m=j_1+j_2$, two have $m=j_1+j_2-1$, and the count climbs by one per step until it saturates. Each ladder $j$ claims one state at every $|m|\le j$; matching the staircase forces one ladder each of

The dimension check on the right is the accountant's signature (exercise 2 — it telescopes in two lines). The classical “tip-to-tail” picture survives as a shadow: $j$ ranges from the arrows aligned to the arrows opposed — but in integer steps, and with the genuinely quantum twist that the pair can have less total angular momentum than either part alone. How much less? All the way to zero — and that state is where we are headed.

Now do the most important example in physics, in full, by hand. Two spin-½ particles: four product states $|\uparrow \uparrow ⟩,|\uparrow \downarrow ⟩,|\downarrow \uparrow ⟩,|\downarrow \downarrow ⟩$, and (11.3) promises $\frac{1}{2}\otimes \frac{1}{2}=1\oplus 0$: a triplet and a singlet, 4 = 3 + 1. The construction has two moves, both old friends. Move one: the top is unmistakable — only one state has $m=1$:

Move two: descend with the total lowering operator ${\hat{J}}_{-}={\hat{J}}_{1-}+{\hat{J}}_{2-}$ — each term flips one arrow with Chapter 9's matrix element (here every factor is $\hslash$), while the left side costs $\hslash \sqrt{j(j+1)-m(m-1)}=\hslash \sqrt{2}$:

That exhausts the triplet — three states, all symmetric under swapping the two particles. One state remains: whatever part of the $m=0$ plane is orthogonal to $|1,0⟩$:

Stop and stare at the singlet, because it will follow you for the rest of the book. It has total angular momentum zero — measure the pair along any axis whatsoever and the answers cancel; a rotation does nothing to it at all; it is the one combination with no direction in it. It is antisymmetric — swap the particles and it flips sign, while the triplet shrugs; that one bit of exchange bookkeeping is the seed Chapter 15 grows into the Pauli principle and the whole periodic table. And try to write it as (state of particle 1) × (state of particle 2) — you cannot, as you proved in Chapter 3's exercise: it is entangled, the very state whose too-perfect correlations Chapter 18 will put on trial in a Bell test. Three chapters' worth of plot, hiding in one minus sign.

And the galaxy's hum, decoded: hydrogen's ground state is this exact system. The triplet sits a whisper above the singlet; an atom falls from $|1,m⟩$ to $|0,0⟩$ and mails the difference as a 21 cm photon. (The fall is fantastically slow — a given atom waits ten million years — but a galaxy holds a lot of hydrogen.)

Nothing in those two moves was special to spin-½. For any $j_1\otimes j_2$: seed the top ladder with the unique maximal state, descend with ${\hat{J}}_{-}$; at each new $j$, the top of the next ladder is the vector in the $m=j$ subspace orthogonal to everything above — the same Gram–Schmidt move (subtract off a vector's overlap with each direction already used, and what survives is perpendicular to all of them) that orthogonalizes any set of vectors — pinned down by a single sign choice, the Condon–Shortley phase convention (declare the coefficient of the largest-$m_1$ term positive), so that everyone's tables agree to the last minus sign. The overlaps this machine generates,

are the most heavily tabulated numbers in physics — printed inside the back cover of every quantum text, hardwired into every atomic-structure code.

The names are a historical accident worth knowing. Alfred Clebsch and Paul Gordan were nineteenth-century mathematicians who tabulated these very numbers in the 1870s while grinding through invariant theory — decades before anyone had heard of spin or a quantum state. It was Eugene Wigner and his contemporaries in the 1930s who recognized that the same coefficients are exactly the dictionary between the product and total bases, and built the modern theory of angular momentum on them. They are yours to generate on demand:

Why does “total angular momentum” deserve its own basis? Because nature keeps its books in it. Chapter 5 proved the master theorem in one line — equation (5.4): $d⟨\hat{A}⟩/dt=\frac{i}{\hslash }⟨[\hat{H},\hat{A}]⟩$ — whatever commutes with the Hamiltonian is conserved. If the world has no preferred direction, H commutes with every rotation, hence with ${\hat{J}}^2$ and ${\hat{J}}_z$: total angular momentum is conserved even while the spins inside trade it back and forth (the individual ${\hat{J}}_{1z}$ is not conserved once the spins interact — the cross term in (11.2) again, now read as physics: coupling makes the parts trade, symmetry makes the total hold). And degeneracy comes along free: rotate an energy eigenstate and you get another one at the same energy, so levels arrive in complete multiplets of $2j+1$ — the reason spectra organize into the singlets, doublets, and triplets that named the whole subject.

Rotations are not the only symmetry on duty. The humblest is the mirror: parity, $\hat{\Pi }\psi (\vec{r})=\psi (-\vec{r})$. Two applications restore everything, ${\hat{\Pi }}^2=1$, so its only eigenvalues are ±1 — a single bit per state, no fractions allowed. For any central potential $[\hat{H},\hat{\Pi }]=0$, and the eigenstates you built in Chapters 9–10 already commit: inverting $\hat{n}$ sends $\theta \to \pi -\theta ,\phi \to \phi +\pi$, and

— even $l$ states are mirror-proof, odd $l$ states flip wholesale. See the bit with your own eyes:

Now collect the chapter's two threads into one weapon. When an atom emits light, the workhorse process (the dipole transition, Chapter 12's subject) inserts the operator $\hat{\vec{r}}$ between initial and final states — an operator that is parity-odd and carries angular momentum one (its components are built from $Y_1^m$). So the matrix element $⟨f|\hat{\vec{r}}|i⟩$ survives only if the parity flips and the angular momenta satisfy this chapter's addition rule $l_f\in l_i\otimes 1$:

Half of hydrogen's conceivable spectral lines, annihilated by two symmetries and no dynamics whatsoever. This is why the 2s state cannot radiate its way to 1s and sits metastable for a glorious eighth of a second (a hundred million times the 2p lifetime), and why spectroscopy tables are mostly empty space. One more symmetry deserves its one honest paragraph: time reversal. Running the film backwards must flip momenta while fixing positions, which no ordinary operator can do — T is antiunitary, complex-conjugating the amplitudes it touches. Its deepest consequence is Kramers' theorem: for any time-reversal-symmetric system with half-integer total spin, every level is at least doubly degenerate — no electric field, however cruel, can fully split it. We will lean on this in Part IV; the full story belongs to a more advanced course, and we flag the debt honestly.

The lab Rust-QP/ch11-cg implements the two-move algorithm exactly as section 11.4 stated it — all $j$'s and $m$'s carried as two_j integers (twice their value), so half-integers are exact and no floating-point ghost can haunt the bookkeeping:

1/// The whole algorithm: start at the top, descend, and at each new j the
2/// top state is the unique vector in the m = j subspace orthogonal to
3/// every higher ladder (Gram-Schmidt), with the Condon-Shortley sign
4/// (largest-m1 coefficient positive).
5fn decompose(space: &Space) -> Vec<Ladder> {
6    let (two_j1, two_j2) = (space.two_j1, space.two_j2);
7    let two_j_max = two_j1 + two_j2;
8    let two_j_min = (two_j1 - two_j2).abs();
9    let mut ladders: Vec<Ladder> = Vec::new();
10
11    for two_j in (two_j_min..=two_j_max).rev().step_by(2) {
12        // -- find the top state |j, m=j> ---------------------------------
13        let mut top = vec![0.0; space.dim];
14        if two_j == two_j_max {
15            top[space.index(two_j1, two_j2)] = 1.0;
16        } else {
17            // the m = j subspace, ordered by descending m1 (Condon-Shortley
18            // wants the largest-m1 coefficient positive)
19            let mut members: Vec<usize> = (0..space.dim)
20                .filter(|&p| {
21                    let (m1, m2) = space.ms(p);
22                    m1 + m2 == two_j
23                })
24                .collect();
25            members.sort_by_key(|&p| -space.ms(p).0);
26            // start from the largest-m1 member, project out higher ladders
27            top[members[0]] = 1.0;
28            for ladder in &ladders {
29                let k = ((ladder.two_j - two_j) / 2) as usize; // their m = our j
30                let higher = &ladder.states[k];
31                let overlap: f64 = top.iter().zip(higher).map(|(a, b)| a * b).sum();
32                for (t, h) in top.iter_mut().zip(higher) {
33                    *t -= overlap * h;
34                }
35            }
36            let norm: f64 = top.iter().map(|x| x * x).sum::<f64>().sqrt();
37            assert!(norm > 1e-10, "m={} subspace exhausted early", two_j);
38            for t in top.iter_mut() {
39                *t /= norm;
40            }
41            if top[members[0]] < 0.0 {
42                for t in top.iter_mut() {
43                    *t = -*t;
44                }
45            }
46        }
47        // -- then descend: |j,m−1> = J_- |j,m> / sqrt(j(j+1) − m(m−1)) ---
48        let mut states = vec![top];
49        let mut two_m = two_j;
50        while two_m > -two_j {
51            let raw = apply_j_minus(space, states.last().unwrap());
52            let norm = c_minus(two_j, two_m);
53            states.push(raw.iter().map(|x| x / norm).collect());
54            two_m -= 2;
55        }
56        ladders.push(Ladder { two_j, states });
57    }
58    ladders
59}

Now the referees. The construction above never forms a matrix; the judge builds ${\hat{J}}^2$ and ${\hat{J}}_z$ as explicit matrices by tensoring Chapter 9's operators — Kronecker products, the Chapter 3 way — and demands that every constructed state be an exact eigenvector of both. Those tensored matrices also get Chapter 9's own algebra self-check, $[{\hat{J}}_x,{\hat{J}}_y]=i{\hat{J}}_z$, because a judge whose operators are not really a rotation algebra is not a judge at all:

1// -----------------------------------------------------------------
2        // The independent judge: J^2 and Jz as explicit Kronecker-product
3        // matrices
4        // -----------------------------------------------------------------
5        let (x1, y1, z1) = build_j(two_j1);
6        let (x2, y2, z2) = build_j(two_j2);
7        let i1 = Mat::identity((two_j1 + 1) as usize);
8        let i2 = Mat::identity((two_j2 + 1) as usize);
9        let jx = x1.kron(&i2).add(&i1.kron(&x2));
10        let jy = y1.kron(&i2).add(&i1.kron(&y2));
11        let jz = z1.kron(&i2).add(&i1.kron(&z2));
12        let j2 = jx.mul(&jx).add(&jy.mul(&jy)).add(&jz.mul(&jz));
13
14        // The self-check Chapter 9 runs on its factors, run here on the
15        // factors AND on the tensored totals: if [Jx,Jy] != i Jz then the
16        // judge is not judging su(2) and its verdict is worthless.
17        worst_commutator = worst_commutator
18            .max(x1.mul(&y1).sub(&y1.mul(&x1)).dist(&z1.scale(c(0.0, 1.0))))
19            .max(x2.mul(&y2).sub(&y2.mul(&x2)).dist(&z2.scale(c(0.0, 1.0))))
20            .max(jx.mul(&jy).sub(&jy.mul(&jx)).dist(&jz.scale(c(0.0, 1.0))));
21
22        for &(two_j, two_m, v) in &flat {
23            let j = two_j as f64 / 2.0;
24            worst_j2_eigen = worst_j2_eigen.max(j2.eigen_residual(v, j * (j + 1.0)));
25            worst_jz_eigen = worst_jz_eigen.max(jz.eigen_residual(v, two_m as f64 / 2.0));
26        }
27
28        // -- and the closed-form judge, coefficient by coefficient. The
29        //    zeros are compared too: a coefficient that should vanish and
30        //    does not is exactly as wrong as a mistyped sqrt(2/3).
31        for &(two_j, two_m, v) in &flat {
32            for p in 0..space.dim {
33                let (m1, m2) = space.ms(p);
34                let exact = racah_cg(two_j1, m1, two_j2, m2, two_j, two_m);
35                worst_racah = worst_racah.max((v[p] - exact).abs());
36            }
37        }

How independent is that, honestly? Less than it looks, and the earlier edition of this page overstated it. The two routes share no data structure, no loop and no basis convention — but build_j's only non-trivial content is the ladder matrix element $\sqrt{j(j+1)-m(m\mp 1)}$, which is the same closed form the descent divides by at every step, so a wrong ladder formula is common cause rather than independent evidence. Worse, the ${\hat{J}}^2$ test is structurally blind to the entire phase convention: flip the Condon–Shortley sign and every state is still an eigenvector, because $-|j,m⟩$ is one too. (We checked: inverting that one comparison leaves the ${\hat{J}}^2$, ${\hat{J}}_z$, orthonormality and completeness referees passing at machine precision, and the sign convention wrong in every table.) So the lab runs a third route that shares nothing at all — Racah's explicit formula, integer factorials and one alternating sum, forming no operator and taking no step:

1// ---------------------------------------------------------------------------
2// The closed-form judge: Racah's explicit formula for a CG coefficient
3// ---------------------------------------------------------------------------
4// <j1 m1; j2 m2 | j m> as factorials and one alternating sum. No operator
5// is formed, no ladder is climbed, no vector is orthogonalized — this is
6// the route that shares NOTHING with the generator, not even the matrix
7// element sqrt(j(j+1) − m(m∓1)) the Kronecker judge inherits from
8// build_j. Every factorial argument below is an integer, because every
9// combination like (j1 + j2 − j) is one.
10// …
11fn racah_cg(two_j1: i32, two_m1: i32, two_j2: i32, two_m2: i32, two_j: i32, two_m: i32) -> f64 {
12    // …
13    let prefactor = ((two_j + 1) as f64
14        * fact(h(two_j1 + two_j2 - two_j))
15        * fact(h(two_j1 - two_j2 + two_j))
16        * fact(h(-two_j1 + two_j2 + two_j))
17        / fact(h(two_j1 + two_j2 + two_j) + 1))
18    .sqrt()
19        * (fact(h(two_j + two_m))
20            * fact(h(two_j - two_m))
21            * fact(h(two_j1 - two_m1))
22            * fact(h(two_j1 + two_m1))
23            * fact(h(two_j2 - two_m2))
24            * fact(h(two_j2 + two_m2)))
25        .sqrt();
26
27    let mut sum = 0.0;
28    for k in 0..=h(two_j1 + two_j2 + two_j) {
29        let args = [
30            k,
31            h(two_j1 + two_j2 - two_j) - k,
32            h(two_j1 - two_m1) - k,
33            h(two_j2 + two_m2) - k,
34            h(two_j - two_j2 + two_m1) + k,
35            h(two_j - two_j1 - two_m2) + k,
36        ];
37        if args.iter().any(|&a| a < 0) {
38            continue; // a factorial of a negative argument means no term
39        }
40        let denom: f64 = args.iter().map(|&a| fact(a)).product();
41        sum += if k % 2 == 0 { 1.0 } else { -1.0 } / denom;
42    }
43    prefactor * sum
44}

That is the referee that catches a corrupted matrix element or a flipped convention, and it is the one to read first in the scoreboard below. Every number in it is the run's own output, tolerance included:

1. (F) Verify the troublemaker: compute $[{\hat{\vec{J}}}_1\cdot {\hat{\vec{J}}}_2,{\hat{J}}_{1z}]$ term by term using Chapter 9's algebra and confirm (11.2). Then show $[{\hat{J}}^2,{\hat{J}}_z]=0$ — the total basis is at least self-consistent.
2. (F) Prove the dimension identity in (11.3) by writing $2j+1$ as $(j)(j+1)-(j-1)j+1$... or more honestly: just telescope the sum. Then check it against the lab's five pairs.
3. (F) The operator identity that runs magnetism: from ${\hat{J}}^2={\hat{J}}_1^2+{\hat{J}}_2^2+2{\hat{\vec{J}}}_1\cdot {\hat{\vec{J}}}_2$, show $⟨{\hat{\vec{S}}}_1\cdot {\hat{\vec{S}}}_2⟩=+{\hslash }^2/4$ in the triplet and $-3{\hslash }^2/4$ in the singlet. A Hamiltonian $A{\hat{\vec{S}}}_1\cdot {\hat{\vec{S}}}_2$ therefore splits them by ${\hslash }^{2}A$ — the exact form of the hyperfine coupling (Chapter 12) and of the Heisenberg exchange model behind every magnet you own.
4. (C) In the explorer, set 1 ⊗ 1 and inspect all nine states. Which total-j families are symmetric under swapping the two spins, and which antisymmetric? (Check j = 2, 1, 0 separately.) The alternating pattern you find is general — and it is the rule that will decide which states of two identical photons are allowed to exist at all.
5. (F, hard) Derive the selection rule (11.9) properly: write $\hat{z}=r\sqrt{4\pi /3}{Y}_1^0$, use the fact that a product $Y_1^0{Y}_l^m$ decomposes into $Y_{l^{\prime }}^m$ with $l^{\prime }\in \{l-1,l,l+1\}$ (this chapter's addition rule applied to functions), and kill the $l^{\prime }=l$ term with parity. Then explain why the 21 cm transition itself survives despite Δl = 0: what kind of operator connects triplet to singlet, and why is it so much weaker than a dipole? (This is why the atom waits ten million years.)
6. (P) Extend the lab to 2 ⊗ 2 and verify the symmetric/antisymmetric alternation of exercise 4 programmatically: apply the swap operator (exchange the two factors of every product state) to each |j, m⟩ and confirm the eigenvalue is $(-1{)}^{j_1+j_2-j}$.
7. (P, hard) The flip-flop rides again. Build $\hat{H}=A{\hat{\vec{S}}}_1\cdot {\hat{\vec{S}}}_2$ as a 4×4 matrix with Kronecker products, prepare $|\uparrow \downarrow ⟩$, and evolve it (reuse Chapter 5's RK4 or exponentiate exactly). Show the system oscillates $|\uparrow \downarrow ⟩\leftrightarrow |\downarrow \uparrow ⟩$ at the singlet-triplet gap frequency — Chapter 5's ammonia flip-flop reborn, with the two “wells” now spin configurations. Spin-exchange oscillations like these are how quantum-dot qubits talk to each other.