Reason 1: each diagonal has a fixed parity

The spiral visits cells one step at a time, so consecutive integers are always in adjacent cells. That means parity alternates like a chessboard: if a cell at position holds , then .

Moving along a diagonal changes and by each, so keeps its parity, and every number on a given diagonal has the same parity. Every prime except is odd, so half of all diagonals contain no primes beyond possibly . Even before looking at primes, the spiral is split into alternating diagonal stripes.

Reason 2: diagonals are quadratic polynomials

Follow a diagonal outward from the centre. The four rays starting at are

The diagonal rays through , for

Direction	Values	Formula
up-right
up-left
down-left
down-right

So the question “why are some diagonals full of primes?” becomes “why do some quadratic polynomials produce more primes than others?” The down-right ray has no primes at all, since its values are perfect squares. The up-left ray is especially rich in primes, and there is a reason for that:

So is never divisible by , which is half of all odd primes. It avoids the most common small factors, so its values are more likely to be prime. Other diagonals have the opposite problem: , for example, so it is divisible by whenever .

Euler’s lucky polynomial

The most famous diagonal belongs to Euler’s polynomial , which is prime for every from to . Start the spiral at instead of and those forty primes lie on a single unbroken diagonal. At it fails, since .

Try other constants in . The run of primes is long only for a few special values:

viewof A = Inputs.range([2, 101], {value: 41, step: 1, label: "Constant A"})

isPrime = (m) => { if (m < 2) return false; for (let d = 2; d * d <= m; d++) if (m % d === 0) return false; return true; }
values = d3.range(0, 60).map(n => ({n, v: n * n + n + A, prime: isPrime(n * n + n + A)}))
run = { let r = 0; while (isPrime(r * r + r + A)) r++; return r; }
html`<p class="am-ojs-caption">n² + n + ${A} is prime for n = 0, …, ${run - 1} — a run of <strong>${run}</strong>${run === A - 1 && A > 1 ? " (as long as possible!)" : ""}.</p>
<div class="am-prime-grid">${values.map(d => html`<span class=${d.prime ? "is-prime" : ""} title=${`n = ${d.n}`}>${d.v}</span>`)}</div>`

Only give the longest possible run, primes for all . These are Euler’s lucky numbers, and there are exactly six of them. The reason is deep: a theorem of Rabinowitsch says the run is as long as possible exactly when the number field has unique factorisation, and the Baker–Heegner–Stark theorem shows there are only finitely many such fields.

So the same spiral goes from a parity argument, to quadratic residues, to an open conjecture, to class numbers.

Convergence is the easy part

Comparing with a telescoping sum shows that Equation 1 converges, and to something less than :

Finding the exact value is much harder. Convergence is also slow: the tail after terms is about , so after a hundred terms you are still off by about 0.01. Try it:

viewof N = Inputs.range([1, 2000], {value: 25, step: 1, label: "Terms N"})

partial = { let s = 0; for (let n = 1; n <= N; n++) s += 1 / (n * n); return s; }
target = Math.PI ** 2 / 6
html`<div class="am-stat-row">
  <div><span>Partial sum</span><strong>${partial.toFixed(8)}</strong></div>
  <div><span>π²/6</span><strong>${target.toFixed(8)}</strong></div>
  <div><span>Error × N</span><strong>${((target - partial) * N).toFixed(5)}</strong></div>
</div>`

Plot.plot({
  height: 260,
  marginLeft: 50,
  style: {background: "transparent", fontFamily: "Familjen Grotesk, sans-serif", fontSize: "13px"},
  x: {label: "n", grid: false},
  y: {label: "partial sum", domain: [1, 1.7], grid: true},
  marks: [
    Plot.ruleY([target], {stroke: "currentColor", strokeDasharray: "4 4", strokeOpacity: 0.6}),
    Plot.line(d3.range(1, N + 1).map(n => ({n, s: d3.sum(d3.range(1, n + 1), k => 1 / (k * k))})),
      {x: "n", y: "s", stroke: "#e3a21a", strokeWidth: 2.5})
  ]
})

The last number, error × N, approaches . That follows from comparing the tail with an integral: .

The proof: Fourier series and Parseval’s identity

The idea is to compute one integral in two different ways. The will come from the length of the interval .

This is the Pythagorean theorem in infinitely many dimensions: the functions form an orthonormal basis for the inner product , and the squared length of a vector is the sum of the squares of its coordinates.

The same trick gives more sums

Using in Parseval gives , and higher even powers of give every as a rational multiple of . The odd values are different. Apéry proved in 1978 that is irrational, but no closed form for it is known.

Euler: the harmonic series diverges

Euler’s proof gives much more than infinitude. It shows that the primes are dense enough that the sum of their reciprocals diverges.

Fürstenberg: topology on

In 1955, as an undergraduate, Hillel Fürstenberg published a proof that sounds like a joke and isn’t.

It’s quick to check this is a topology: the intersection of two progressions is either empty or another progression, with step equal to the of the two steps. Two features matter:

1. Every non-empty open set is infinite, since it contains a whole progression.
2. Every is also closed, because its complement is a union of the progressions with .

What each proof shows

Three proofs, side by side

Proof	Main idea	What you get beyond infinitude
Euclid	has a new prime factor	An explicit bound: the -th prime is at most
Euler	Unique factorisation + divergence	, and the start of analytic number theory
Fürstenberg	Topology of arithmetic progressions	Not much, but it’s a good example of switching languages

Fürstenberg’s proof is often described as Euclid’s in disguise: strip out the topology and what’s left is an argument about integers coprime to a finite product of primes. That kind of thing is common in mathematics: changing the language of a proof can make it look completely new.