Live Calculator
n₁ (block 1 length − 1) 6
n₂ (block 2 length − 1) 6
Animates n₁ 0→60 (loops), driving the calculator, per-prime table, heatmap marker, and lattice canvas together.
C(n₁)
—
C(n₂)
—
C(n₁,n₂)
—
ρ = D(n₁,n₂) / [D(n₁)·D(n₂)]
—
∞ asymptotic product truncated at primes ≤ 2,000,000 (~148,933 primes) — reliable to ~7–8 dp. The product cost doesn't depend on n₁/n₂ at all (always the same prime list), so the slider range is 0–2000, not an artificial cap.
Per-Prime Local Factors
Table below shows the first 500 primes (scroll to see more) — click any value to see its exact step-by-step derivation. CSV export computes all ≤2,000,000 (~148,933 rows).
| p | f_p(n₁) | f_p(n₂) | f_p(n₁,n₂) | local ρ_p |
|---|
Finite Lattice Canvas — G×G Direct Verification
Same rendering logic as Page 1's Block-Coprimality Canvas, extended to two blocks: r runs along x,
M₁ runs along y, and M₂ is held at a fixed value below (a true 3-free-variable object flattened to 2D).
A cell is gold if r survives both blocks,
teal if it survives block 1 only,
coral if it survives block 2 only, and dark if it survives neither.
Uses n₁, n₂ from the calculator above.
G (grid size) 80
M₂ (block 2 anchor, fixed) 1
View
Color
Filter (ported from index.html's χ(r) filter pattern):
gold = survives both blocks
teal = block 1 only
coral = block 2 only
dark = survives neither
Finite gold fraction (G×G count)
—
Asymptotic D(n₁,n₂) = C(n₁,n₂)/ζ(2)
—
n from the calculator above is capped at 200 inside this canvas for render speed (each cell costs up to n₁+n₂ gcd calls) — the asymptotic value above uses the true, uncapped n₁,n₂.
Reading This Page as Prime Gaps
Turn on gap mode above and set n₁=n₂=0, so each block shrinks to a single point:
block 1 = {M₁}, block 2 = {M₁+g}. As M₁ ranges (that's exactly what the y-axis of the lattice already
sweeps), the two "does p divide the block" events become mutually exclusive instead of
independent whenever p∤g — M₁ and M₁+g can't both be ≡0 (mod p) at once unless p | g. That changes the
per-prime survival probability from the independent-block formula on this page to
$$f_p(g) \;=\; 1-\frac{\nu_p(g)}{p^2},\qquad \nu_p(g)=\begin{cases}1 & p\mid g\\2 & p\nmid g\end{cases}$$
ν_p(g) is literally the number of residues mod p occupied by the offset set {0,g} — the same quantity
that drives the Hardy–Littlewood singular series for the pair (n, n+g). g=2 gives twin primes, g=4
cousin primes, g=6 sexy primes; any g reachable from the presets or the gap slider is one finite
instance of the same question. What this page computes is not the Hardy–Littlewood prime
density itself — that's a statement about n and n+g both being prime, a genuinely harder
object living on Page 4's prime filter. What's shown here is the coprimality-density analogue: the
density, over random r, of surviving both a random point and its +g shift. The two share the exact
same local factor ν_p(g)/p at each prime, which is why the twin/cousin/sexy structure shows up here
first, in a fully elementary and exactly computable form.
Use the "Asymptotic D(n₁,n₂)" box in the lattice card above (it switches to the exact, closed-form
value automatically once gap mode + n₁=n₂=0 are both on) to read off C(g) = ζ(2)·∏ₚ(1−ν_p(g)/p²) for
any gap g, and compare it against the live G×G finite fraction directly above it.
Correlation Ratio Heatmap — ρ(n₁,n₂)
blue = lowest ρ in view
green = mid-range
red = highest ρ in view
white tick on bar = ρ = 1 (independence)
Colormap ported from index.html's own heatmap mode, normalized to the actual ρ range in this grid (not a fixed ±1 scale) so the true structure shows instead of solid color. Grid: primes ≤ 60,000, 50×50 resolution, axes 0–70 — click any cell to load its exact (n₁,n₂) into the calculator above (magenta crosshair = current calculator position).
Coupled Jump Structure — D(n₁, n₂) vs. n₁
n₂ held fixed 6
What the original Jump Theorem says: D(x) = C(x)/ζ(2) has an exact discontinuity of size
1/(p(p−1)) at every x = p−1, one prime at a time, independent of anything else.
What changes here: D(n₁,n₂) still jumps exactly at n₁ = p−1 for each prime p, but the jump
size is now scaled by the other block's local factor at that same prime:
Δ = [1/(p(p−1))] · (1 − min(n₂+1,p)/p), exactly — the same normalization as the original theorem, just scaled by block 2's factor. The two blocks are coupled through every prime simultaneously —
the jump at n₁=p−1 gets smaller as n₂ grows past p−1 too, since block 2 has already "used up" some of
that prime's exclusion budget.
Dotted vertical lines mark n₁ = p−1 for primes p ≤ 61. Computed at full precision (primes ≤ 2,000,000) at each of the 61 integer points.
Step-by-Step Derivation
1 — Setup
Fix r. Take two independent random starting points M₁, M₂, and two block lengths n₁+1, n₂+1. We want the
density of r such that r survives block 1 and block 2 entirely — coprime to every integer in both.
2 — Local failure probability at a prime p
r fails at p iff p | r and p divides some entry of some block. Since M₁, M₂ are independent,
P(block i hits 0 mod p) = min(nᵢ+1,p)/p, so P(neither block hits) = ∏ᵢ(1 − min(nᵢ+1,p)/p) by independence.
3 — Local survival factor
$$f_p(n_1,n_2) = 1 - \frac{1}{p}\Big[1-\Big(1-\tfrac{\min(n_1+1,p)}{p}\Big)\Big(1-\tfrac{\min(n_2+1,p)}{p}\Big)\Big]$$
This is exact — no approximation. Independence across primes (CRT) is the same assumption the
original C(n) Euler product already relies on.
4 — Sanity check against Page 1
Setting n₂ = −1 makes block 2 empty: min(n₂+1,p) = 0, so its factor is literally 1 and the bracket collapses to
1 − min(n₁+1,p)/p, giving f_p(n₁) = 1 − (1/p)·min(n₁+1,p)/p = 1 − min(n₁+1,p)/p² — exactly Page 1's
local factor. C(n₁,n₂) is a strict generalization, not a different object.
5 — Global product
$$C(n_1,n_2) = \zeta(2)\cdot\prod_p f_p(n_1,n_2)$$
generalizes immediately to k blocks: replace the single-pair bracket product with ∏ᵢ₌₁ᵏ(1−min(nᵢ+1,p)/p),
and the same Euler-product machinery (asymptotic tail, exact n=1 endpoint values, etc.) carries over unchanged.