Exact Verification — Brute-Force vs. Formula
For several (n₁,…,n_k, p), every (r, M₁,…,M_k) tuple mod p was enumerated directly and the survival
fraction compared against the closed-form local factor. All five test cases below match to full floating-point
precision — this isn't a numerical coincidence, the local-factor derivation is exact combinatorics mod p.
| (n₁,…,n_k) | p | brute-force | formula |
|---|---|---|---|
| (2, 3, 1) | 7 | 0.88213244 | 0.88213244 |
| (0, 0, 0) | 5 | 0.90240000 | 0.90240000 |
| (4, 1) | 5 | 0.80000000 | 0.80000000 |
| (1, 1, 1, 1) | 5 | 0.82592000 | 0.82592000 |
| (10, 2, 7) | 11 | 0.90909091 | 0.90909091 |
Live Calculator
k (number of blocks) 3
Animates n₁ 0→60 (loops), driving the calculator, per-prime table, and lattice canvas together.
C(n₁,…,n_k)
—
∏ᵢ C(nᵢ)
—
ρ_k = D(n₁,…,n_k) / ∏ᵢD(nᵢ)
—
∞ asymptotic product truncated at primes ≤ 2,000,000 — reliable to ~7–8 dp.
Per-Prime Local Factors
First 500 primes shown (scroll for more) — click any value for its exact step-by-step derivation as a fraction. CSV export covers all ≤2,000,000 (~148,933 rows) at the current k.
| p | f_p(n₁,…,n_k) | ∏ᵢf_p(nᵢ) | local ρ_p |
|---|
Finite Lattice Canvas — G×G, k Blocks
Same rendering as Page 7, generalized to k blocks: r runs along x, M₁ (block 1) runs along y, and
M₂,…,M_k are held at fixed anchors below. Color encodes how many of the k blocks a cell survives —
dark = 0, gold = all k. Use the filter to isolate cells surviving at least a chosen number of blocks.
G (grid size) 80
View
Color
Filter — min blocks survived 0
Finite fraction surviving all k (G×G count)
—
Asymptotic D(n₁,…,n_k) = C(n₁,…,n_k)/ζ(2)
—
n capped inside this canvas for render speed — the asymptotic value above uses the true, uncapped n values.
Reading This Page as Prime k-Tuples
Turn on constellation mode above and set every nᵢ=0, so every block shrinks to a single
point: block 1 = {M₁}, block i = {M₁+hᵢ}. As M₁ ranges — exactly what the y-axis of the lattice already
sweeps — "some block hits 0 mod p" happens iff M₁ mod p lands in one of the residues occupied by
ℋ = {0, h₂, …, h_k}. That set has size ν_p(ℋ), so the per-prime survival probability becomes
$$f_p(\mathcal{H}) \;=\; 1-\frac{\nu_p(\mathcal{H})}{p^2},\qquad \nu_p(\mathcal{H})=\#\{h \bmod p : h\in\mathcal{H}\}$$
ν_p(ℋ) is exactly the quantity that drives the Hardy–Littlewood singular series for the k-tuple
conjecture: an admissible ℋ is one with ν_p(ℋ)<p for every prime p (so the pattern isn't ruled out
by some prime dividing every shift by 0,…,p−1). {0,2,6} and {0,4,6} are the two admissible prime
triples below 8; {0,2,6,8} is the smallest admissible quadruple.
As on Page 7, what's computed here is not the Hardy–Littlewood prime density itself —
that's a claim about M₁, M₁+h₂, …, M₁+h_k being simultaneously prime, which lives on Page 4's prime
filter. This page measures the structurally identical but elementary coprimality-density analogue: the
density, over random r, of surviving a random point and its k−1 fixed shifts at once. Same ν_p(ℋ),
same admissibility condition, fully elementary and exactly computable.
The "Asymptotic D(n₁,…,n_k)" box in the lattice card above switches to the exact, closed-form value
C(ℋ) = ζ(2)·∏ₚ(1−ν_p(ℋ)/p²) automatically once constellation mode + all nᵢ=0 are on — compare it
against the live G×G finite fraction directly above it, and against ρ_k below to see how much the
shared-r correlation grows as the tuple gets denser.
Correlation Growth — ρ_k(n) vs. k (symmetric case, n₁=⋯=n_k=n)
Log-scale y-axis (ρ spans orders of magnitude). k runs 1–12, computed at full precision (primes ≤ 2,000,000) for each point.
Why ρ_k Grows Geometrically, Not Just >1
1 — The formula generalizes with no new assumptions
Same setup as Page 7: k independent random starting points M₁,…,M_k, block i has length nᵢ+1. r survives
iff it survives every block. At a prime p, independence of the M_i gives
P(no block hits 0 mod p) = ∏ᵢ(1 − min(nᵢ+1,p)/p), exactly as before — nothing about the derivation depended on k=2.
2 — Per-prime behavior as k grows, n fixed
Write q = min(n+1,p)/p ∈ (0,1]. The single-block factor is f_p(1) = 1 − q/p, so f_p(1)^k → 0
exponentially in k (it's a fixed number below 1, raised to the k-th power). But the true joint
factor is f_p(k) = 1 − (1/p)[1 − (1−q)^k], and (1−q)^k → 0 as k grows, so f_p(k) → 1 − 1/p — a fixed
positive limit, not decaying to 0.
3 — The gap is structural, not a rounding effect
The naive independence model (∏C(nᵢ)) requires every one of the k blocks to individually survive — a
probability that compounds down geometrically. The true event only requires that not all k blocks hit
the same prime at once — a much weaker requirement that saturates near 1−1/p instead of vanishing.
Since this happens at essentially every prime simultaneously, the ratio ρ_k = D(n,…,n)/D(n)^k is a product
of per-prime terms that are each individually diverging, so ρ_k itself grows without bound as k→∞, for
any fixed n ≥ 0.
4 — Sanity checks against Pages 1 and 7
k=1 collapses the bracket exactly to Page 1's C(n). k=2 is exactly Page 7's C(n₁,n₂) — same formula,
no relabeling needed. The brute-force table above confirms both the k=2 and general-k cases are exact,
not asymptotic approximations of a different true object.