Decomposition into weight × level + jump
Deep Analysis — Eighth Edition (final): The Closed Ledger

1.The construction, its base case, and the classification plane

For a strictly increasing integer sequence \(a(1)jump (gap). Set \(l(n)=a(n)-d(n)\) when \(a(n)-d(n)>d(n)\), else \(l(n)=0\). The weight \(k(n)\) is the smallest divisor of \(l(n)\) exceeding \(d(n)\) (when \(l(n)\neq 0\)), and the level is \(L(n)=l(n)/k(n)\). Then

the decomposition existing iff \(a(n{+}1)<\tfrac32\,a(n)\) (Lemma 2 of the manuscript). A term is level-classified when \(k(n)>L(n)\), weight-classified when \(k(n)

2.The verified record at \(10^9\), re-derived from nothing

The census pipeline was rebuilt from an empty directory this session: a fresh C engine (segmented odd-bitmap sieve streaming consecutive primes; factoring-light classifier by \(g\)-smooth part, Miller–Rabin on the rough part, and divisor search on the smooth part; internal fast-vs-naive gate on every prime up to \(2\times 10^6\)), the project’s own PARI/GP kernels (decompwlj_optimized.txt: orig_naive, orig_sieve, decomp, decomp_fact, plus selftest()), and an independently coded Python classifier. Protocol: the three engines share no code and no intermediate data; any cross-engine disagreement is a blocker. Results:

• C vs PARI. Full recount to \(10^7\) by decomp_fact: 664,576 decomposable, 138,049 level, 44,011 level-one, 94,038 level-above-one, 58,979 with \(k=3\) — every value equal to the C stream. Three congruence-lock cells recounted in PARI at \(10^7\) (19,115/99,987 at \((g,r)=(6,7)\); 5,579/65,513 at \((12,13)\); 19,495/58,620 at \((4,5)\)) — equal to the C checkpoint. The kernel’s selftest() passed (Table 2 of the paper, the Cube-Lemma exception list, the \(L=d\) sharpness witness \(72\to76\): \([17,4,4]\)), and the three algorithms orig_sieve, decomp, decomp_fact agree on every prime below \(10^6\). VERIFIED
• C vs Python. Row-by-row diff of all 78,495 decomposable primes to \(10^6\) (tuples \((g,l,k,L,\text{class})\)): zero mismatches. VERIFIED
• C internal gate. Fast classifier vs naive divisor scan on every decomposable prime \(\le 2\times 10^6\): zero mismatches. VERIFIED

Invariants, all at zero violations over 50,847,531 primes

• Lemma 4 (twin column). \(k=3 \iff g=2\) for decomposable \(p>3\): \(\#\{k=3\}=\#\{g=2\}\) equals 8,168 / 58,979 / 440,311 / 3,424,505 at \(10^6/10^7/10^8/10^9\), with zero one-sided cases. The column splits as 3,424,504 weight-classified plus the single level-classified member \(p=5\). VERIFIED
• Proposition 2 (mod-3 rigidity). \(3\mid l \iff 6\nmid g\): zero violations. This retires founding-paper Conjectures 7 and 8 as elementary facts — they are not contributions and are never presented as such. PROVED
• Lemma 3 (level bound). \(L\le d-1\) for level-classified odd-gap-free primes (parity-sharpened form): zero violations. PROVED
• Lemma 5 exception sets. Empty-window primes (\(g\ge\sqrt{l}\)): exactly \(\{5,13,19,23,31,113\}\); level-one with composite \(l\): exactly \(\{13,31\}\). VERIFIED to \(10^9\) today; CARRIED closure to \(4\times10^{18}\) (refereed gap tables) with session frontier \(2^{64}\).
• Proposition 3 (Cube Lemma). Level class with composite weight \(\Rightarrow l\le(g-1)^3\), sharp at \(p=131\); exception set exactly \(\{13,31,113,131,887\}\) (weights 9, 25, 33, 25, 51): zero further members, zero violations. VERIFIED to \(10^9\); same carried closure.
• Maximal-gap ladder. The record-gap sequence from \(g=2\) at \(p=3\) onward matches A002386 entry for entry, ending \(g=250\) at 387,096,133 and \(g=282\) at 436,273,009 below \(10^9\). VERIFIED

3.Theorem 1 — rarefaction of the level class

The finite-\(x\) content is the envelope statistic \(f(x)\sqrt{\log x}/\log\log x\), which must remain bounded (and should decrease) if the bound has the right shape. Fresh values:

monotone decreasing with no plateau — consistent with the conjectured truth \(N_{\mathrm{lev}}(x)\asymp x\log\log x/\log x\) (the sieve exponent \(3/2\) being an artifact of the dimension-3 normal form; manuscript Problem 1 asks for exponent 2 on the level-one stratum). VERIFIED at \(10^6\)–\(10^9\).

4.Theorem 2, Lemma 1, and the constant \(2C_2\) — with a manuscript erratum

Level-one primes are, up to the two composite-\(l\) exceptions \(p=13,31\) and the additive constant of Lemma 5, exactly the primes \(p_n\) with \(\ell(n)=2p_n-p_{n+1}\) prime. The conditional asymptotic (Theorem 2 CONDITIONAL on Hardy–Littlewood for triples plus a Gallagher-type gap hypothesis) is \(N_1(x)\sim 2C_2\,x/\log^2 x\), whose constant comes from Lemma 1: the line average of the triple singular series \(\mathfrak S_3(g)\) over \(6\mid g\) equals \(2C_2\), via the per-prime identity

re-verified today symbolically in PARI (exact zero) and numerically to 38 digits: \(C_2=0.66016181584686957\ldots\), \(2C_2=1.32032363169373915\ldots\), residual \(0.\mathrm{E}{-}38\). PROVED (the identity and line average; the asymptotic remains conditional).

Gap-by-gap test of the Theorem-2 machinery at \(10^9\)

Removing the gap-distribution layer isolates hypothesis H1: for each \(6\mid g\), the predicted level-one count is \(\big(\sum_{g(n)=g}1/\log p_n\big)\cdot \mathfrak S_3(g)/\mathfrak S_2(g)\), against the observed count in the \(\ell\)-prime convention. A conventions note first: today’s engine initially reported 672,963 at \(g=6\) against the record’s 672,962. The difference is exactly the composite-\(l\) exception \(p=31\) (\(l=25\), \(g=6\)): the complete-count convention includes it, the \(\ell\)-prime convention (which the prediction models) excludes it, as it excludes \(p=13\) at \(g=4\). With the convention stated, the two sessions agree digit-for-digit. This is not an erratum; it is the same population-convention lesson as corrections item 5, now documented.

Erratum-14 confirmation. The seven per-gap ratios outside the manuscript’s originally claimed window \([0.97,1.05]\) reproduce identically: \(g=84\) (1.0513), 102 (1.0560), 108 (0.9669), 114 (1.0515), 132 (1.1318, on 484 observations, a \(\approx2.5\sigma\) Poisson fluctuation), 138 (1.0602), 144 (0.9627). The manuscript sentence must be reworded exactly as item 14 prescribes: the window claim holds for the eleven gaps with \(\ge 10^4\) observations, and small-count gaps scatter as Poisson noise. VERIFIED

The constant, honestly

The raw windowed density \(\Delta N_1\cdot\log^2 x_m/\Delta x\) rises through 0.9472 / 0.9804 / 1.0079 on the decade windows ending at \(10^7/10^8/10^9\) (fine windows reach 1.0522 at \(10^9\)) — still 20% below the conditional asymptote \(2C_2=1.3203\), with logarithmically slow approach. The identification of the constant therefore rests on Lemma 1’s exact identity plus the gap-by-gap test above, not on the raw density at accessible \(x\); Figure 4 shows both so no reader mistakes the state of play.

5.Species II — the level-above-one stratum

The level-above-one share obeys the working law \(f_{>1}(x)\approx \hat c_2\,\log\log x/\log x\) with

band \(0.773\pm 0.010\) — today’s four fresh windows equal the record to every printed digit. The cumulative diagnostic \(f_{>1}\log x/\log\log x\) descends 0.8312 / 0.8204 / 0.8108 / 0.8046 at \(10^6\)–\(10^9\) (0.7999 at \(10^{10}\) carried) — the slow drift that forced the retraction of the once-conjectured \(c_2=1\) (corrections item 11; the retraction stands). VERIFIED / constant identification OPEN (Ford–Koukoulopoulos divisors-of-shifted-primes territory).

Erratum-15 confirmation. The Mertens-normalized ratio \(R_2\) (mass \(2\log g_n/\log l_n\) per decomposable prime) gives cumulatively 0.4469 / 0.4460 / 0.4436 / 0.4422 at \(10^6\)–\(10^9\) today; the seventh edition printed 0.4470 and 0.4435 at the first and third decade — differences of one unit in the fourth decimal, traced to floating-point accumulation order over \(5\times10^7\) summands, i.e. sub-\(10^{-4}\) agreement and no substantive change. On the decade windows the two sessions agree exactly: 0.4458 / 0.4432 / 0.4420 on the three windows from \((10^6,10^7]\). The manuscript’s “\(R_2\approx 0.4412\), flat to three decimals over \(10^6\)–\(10^{10}\)” remains wrong as written (item 15): flatness at that precision holds only from \(10^9\) upward in the natural-mass convention. VERIFIED

6.The congruence lock made exact: column identities and the interior-credit law

The seventh edition established the congruence lock: for an odd prime \(r\) and a decomposable prime \(p\) with gap \(g\),

and measured that for \(r>g\) the lock class occupies the flat share \(1/(r-2)\) of gap-\(g\) primes to within a small, structured bias: exact at \((r,g)\) with \(g\in\{2,4\}\), a deficit growing toward \(\approx 4.6\%\) as \(g\to r\). It posed the anatomy of that bias as an open micro-problem. This section answers it in three steps: two exact identities that turn weight columns into lock counts, a derived first-order law for the bias, and a residue-resolved test of the law’s mechanism.

6.1  Exact column identities

These are exact bridges: a multiplicative weight column is a finite union of residue-conditioned gap events. They explain quantitatively why the columns are non-monotone in Figure 6 (the \(k=5\) column draws on a single gap, \(k=7\) on two) and they give the census a new cross-check, passed on the nose. They also yield a clean CRT-independence measurement: within \(g=4\), the joint lock \(\#\{35\mid l\}=228{,}191\) against the product prediction \(\#\{7\mid l\}/3 = 228{,}221\) — a deviation of \(-30=-0.08\sigma\) (\(\sigma\approx 390\)): the two locks are statistically independent at \(10^9\) to the resolution available. VERIFIED

6.2  The interior-credit law

Fix a gap \(g\) and an odd prime \(r>g\), and condition on \(p, p+g\) being consecutive primes. Consecutiveness means every interior even offset \(j\in E_g=\{2,4,\dots,g-2\}\) has \(p+j\) composite. Here is the mechanism: if \(p\equiv -j \pmod r\), then \(r\mid p+j\) and the compositeness of that interior point is guaranteed for free; that residue class needs one fewer accident to achieve gap exactly \(g\), so it is over-represented among gap-\(g\) primes. The lock class \(p\equiv g\) earns no such credit (its offset \(r-g\) is odd, outside \(E_g\)), so it is under-represented relative to the credited classes — the observed deficit. First-order bookkeeping makes this quantitative. Let

be the Hardy–Littlewood conditional probability that the interior point \(p+j\) is prime given the prime pair \((p,p+g)\) — the “prime-risk” the credit removes — where \(\langle 1/\log p\rangle_g\) is measured within the gap-\(g\) population (no free parameter). Weight each admissible residue \(a\bmod r\) by

the factor \(r/(r-1)\) renormalizing the risk of the non-credited points once \(r\nmid p+j\) is known. Expanding at the lock class gives the closed-form first-order deficit

Parameter-free test. Over all 341 cells \((g,r)\) with even \(g\le 40\) and prime \(g0.916, with \(\chi^2/\mathrm{pt}=2.24\) — the law predicts the full shape of the bias surface (both the \(g/r\) growth and the per-\(g\) fine structure) with magnitudes running \(\approx23\%\) low.

One-parameter completion. A single global factor \(\hat\lambda = 1.2324\pm0.0105\) (weighted least squares through the origin) absorbs the second-order enhancement: \(\chi^2/\mathrm{ndf}=0.806\) over 340 degrees of freedom. Flagship cells: \((6,7)\) measured \(0.9683\pm0.0008\) vs \(0.9681\); \((12,13)\): \(0.9537\pm0.0015\) vs \(0.9530\); \((30,31)\): \(0.9466\pm0.0035\) vs \(0.9453\). One number renders the entire 341-cell surface statistically complete.

6.3  The mechanism, residue by residue

The law predicts more than the lock-class deficit: it assigns each admissible residue its own occupancy, with credited classes surplused in proportion to their particular \(u_j\) — a fingerprint no flat model produces. Reading all residue histograms for \(g\le 14\), \(3g\) (237 admissible classes) against the parameter-free prediction: \(\chi^2/\mathrm{pt}=18.3\), against the flat null 527 — a 29-fold reduction with zero fitted constants; applying the same global \(\hat\lambda\) gives \(\chi^2/\mathrm{pt}=0.997\). The mechanism — not merely the aggregate — is confirmed. VERIFIED

7.The Cramér verdict

The mandatory deflationary control, run fresh with two random models through the same classifier (fixed seed 20260807, \(10^9\) each): Model A, the classic Cramér sequence (each \(n\) included with probability \(1/\log n\)); Model B, parity-matched (odd \(n\) with probability \(2/\log n\), so gaps are even and \(l\) odd, as for primes).

The verdict is sharper than in previous editions, and it cuts both ways. The aggregate level share of the primes is generic: the classic model tracks it within 1% at every decade and to 0.1% at \(10^9\) (0.1708 vs 0.1709 — the three-decimal coincidence at the last decade is luck, the percent-level tracking is not). Any presentation of Conjecture 9’s rarefaction rate as prime-specific structure would be wrong: the decay shape is what any \(1/\log n\)-density sequence does under this construction. But the composition is arithmetic through and through: the parity-matched model, which one might expect to be the fairer control, overshoots the level share by 20% and doubles Species I (0.1021 vs 0.0533 at \(10^9\)), because real \(\ell=2p_n-p_{n+1}\) is prime with the Hardy–Littlewood conditional density \(\approx\mathfrak S_3/\mathfrak S_2\cdot 1/\log\), not the bare \(2/\log\) of the random odd model. The framework’s genuine content at the level of counting is therefore the species split, its constants (\(2C_2\); the open Species-II constant), and the exact lock/column structure of §6 — not the aggregate decay. This paragraph should be read as binding on all future prose about Conjecture 9.

8.The conjecture ledger of the founding paper

The difficulty-conservation principle stands unweakened: recasting a classical problem in weight–level coordinates does not lower its difficulty, and every classically-hard item above remains exactly that. The framework’s native yield is the row set {Theorem 1, Proposition 2/3, Lemmas 1–5, the lock and column structure} — and it is on that yield that the manuscript stakes its claim.

9.Horizon and the submission checklist

The single highest-priority action of the programme is unchanged: submit the manuscript (Journal of Integer Sequences, Integers, or Experimental Mathematics), which is the only step that can remove the asterisk from Theorem 1. Pre-submission checklist, consolidated from the ledger:

• Correct the printed constant: \(D=5.7164975\ldots \to 5.71649719\ldots(=2C_3)\), and fix the truncation sentence (item 17, §4).
• Reword the per-gap window sentence per item 14 (window claim only for gaps with \(\ge 10^4\) observations).
• Qualify the \(R_2\) flatness sentence per item 15 (flat to three decimals only from \(10^9\) in the natural-mass convention).
• Keep \(4\times10^{18}\) (refereed) in all statements; \(2^{64}\) as a remark only (item 16).
• Author email and affiliation line; verify the two outstanding bibliography page numbers.
• Optional, author’s call: a short remark adding the §6 column identities and the interior-credit law to the numerics section — both strengthen the “dictionary” theme (multiplicative column = additive lock) at the cost of one page.

Research horizon, in the order of expected yield: (i) the function-field analogue over \(\mathbb F_q[t]\), \(q\) odd, where the analogue of Conjecture 9 may be provable unconditionally with today’s technology, since the coupling obstruction (the “next prime” dependence that blocks a direct application of Ford-type theorems here) weakens in the polynomial setting; (ii) the second-order derivation of \(\hat\lambda\) and, through the same calculus, Problem 4’s +1.2% excess; (iii) the Species-II constant (Ford–Koukoulopoulos); (iv) arithmetical congruence monoids \(M_{1,m}\); (v) the automated atlas sweep computing regime certificates across the \(\sim\)1,000 decomposed OEIS sequences. All are additive to, and none is a prerequisite of, submission.

A.Appendix A — algorithms and engines

Everything below ran today, single core, 4 GB RAM. Timings: C census to \(10^9\), 49 s; PARI driver (self-test, three-algorithm regression to \(10^6\), \(10^7\) recount, constants, deep witnesses), 4.4 s; Cramér controls, 34 s + 30 s; Python audit, under a minute.

A.1  PARI/GP (reference engine, project kernels)

The project’s optimized kernel (decompwlj_optimized.txt) provides orig_naive / orig_sieve (the paper’s originals), decomp (trial division), decomp_fact (factorization + fordiv), decomp_auto, classification and sequence drivers, and selftest(). The session driver:

\r kernel.gp            \\ the project kernel, CRLF-stripped
selftest();

\\ three-algorithm regression on all primes < 1e6 (+ tie census)
V = primes(primepi(10^6)+1);
for (i = 1, #V-1,
  a = orig_sieve(V[i],V[i+1]); b = decomp(V[i],V[i+1]); c = decomp_fact(V[i],V[i+1]);
  if (a != b || b != c, error("MISMATCH at ", V[i])));

\\ constants (38 digits) and the Lemma-1 identity
C2 = prodeulerrat(1 - 1/(x-1)^2, 1, 3);          \\ 0.66016181584686957...
D  = 9*prodeulerrat((1-3/x)/(1-1/x)^3, 1, 5);    \\ 5.71649719143844086... = 2*C3
A  = prodeulerrat((x-1)*(x-2)/(x*(x-3)), 1, 5);
D/6*A - 2*C2                                      \\ 0.E-38  (line average = 2*C2)
q='q; simplify((1-3/q)/(1-1/q)^3*(q-1)*(q-2)/(q*(q-3)) - (1-1/(q-1)^2))  \\ 0, symbolic

\\ deep witnesses via decomp_fact  [k, L, d]
\\ p = 1000000000039            (g=22): [461, 2169197397, 22]              weight
\\ p = 10^18 + 3                (g= 6): [47, 21276595744680851, 6]         weight
\\ p = 10^24 + 7                (g=42): [11909, 83970106642035435385, 42]  weight

A.2  C census engine (fresh, this session)

Segmented odd-bitmap sieve (span \(2^{24}\)) streaming consecutive primes; classification without full factorization: split \(l\) into its \(g\)-smooth part \(S\) (primes \(\le g\)) and rough part \(R=l/S\); a divisor-DFS over \(S\) yields the smallest smooth divisor \(>g\) and the largest \(\le g\); \(R\) is resolved by one Miller–Rabin call (bases 2,3,5,7, valid far beyond the range where it decides compositeness here; primality of rough \(R>\sqrt l\) is what the classification needs). Level terms get exact \((k,L)\); weight terms exact \(k\) up to the histogram cap. Every prime \(\le 2\times10^6\) is re-classified by a naive divisor scan inside the same run — zero mismatches gate the stream. Checkpoints at \(x=10^{j/8}\); per-gap level-one counts, \(\sum 1/\log p\) masses, lock numerators \(p\bmod r\equiv g\) for \(g\le 40\), \(r\le 103\), residue histograms for \(g\le 14\), \(r\le 17\), weight/level histograms, exception lists, and the maximal-gap ladder are accumulated exactly. Full source:

/* decompwlj census engine — 8th edition fresh sweep.
 * Streams consecutive primes to LIMIT via a segmented sieve and classifies
 * every decomposable prime p (gap g, l = p-g) as weight/level, with exact
 * level value L, weight k (exact when k <= KCAP or from the smooth part),
 * congruence-lock counters, residue histograms, per-gap level-one counts,
 * per-gap logarithmic mass, R2 mass, and invariant checks.
 *
 * Classification without full factoring:
 *   S = g-smooth part of l (primes q <= g), R = l/S (all prime factors > g).
 *   - R > 1 and R <= sqrt(l)          -> weight (divisor R in (g, sqrt l]).
 *   - R > sqrt(l), R composite        -> weight (spf(R) <= sqrt R <= sqrt l).
 *   - R > sqrt(l), R prime (or R = 1) -> decided by divisors of S:
 *       weight iff S has a divisor in (g, sqrt l]; else level with
 *       k = min(smallest divisor of S exceeding g, R), L = l/k.
 * Deterministic Miller-Rabin bases {2,3,5,7} (valid < 3.215e9 > any l here).
 * For p <= DUMPMAX a naive reference classifier re-derives every row and the
 * two paths are compared (internal zero-mismatch gate) + rows dumped to CSV.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <math.h>

typedef uint64_t u64; typedef uint32_t u32; typedef __uint128_t u128;

static u64 LIMIT = 1000000000ULL;
static const u64 DUMPMAX = 2000000ULL;
#define KCAP 1000
#define GMAX 512            /* per-gap arrays (max gap below 1e9 is 282) */
#define LOCK_GMAX 40
static const int lock_r[] = {3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103};
#define NLOCKR ((int)(sizeof(lock_r)/sizeof(lock_r[0])))

/* ---------- small primes ---------- */
static u32 *base_primes; static int n_base;          /* primes to sqrt(LIMIT+pad) */
static u32 small_primes[2048]; static int n_small;   /* primes to 1550 (>= any g, and KCAP scans) */

static void gen_small(void){
  char c[1551]; memset(c,0,sizeof c);
  for(int i=2;i<=1550;i++) if(!c[i]){ small_primes[n_small++]=i; for(int j=2*i;j<=1550;j+=i)c[j]=1; }
}
static void gen_base(u64 n){
  u32 lim=(u32)floor(sqrt((double)n))+2;
  char *c=calloc(lim+1,1);
  base_primes=malloc(sizeof(u32)*((u64)lim+16)); n_base=0;
  for(u32 i=2;i<=lim;i++) if(!c[i]){ base_primes[n_base++]=i; for(u64 j=(u64)i*i;j<=lim;j+=i)c[j]=1; }
  free(c);
}

/* ---------- Miller-Rabin, bases 2,3,5,7 (deterministic < 3,215,031,751) ---------- */
static u64 mulmod(u64 a,u64 b,u64 m){ return (u64)((u128)a*b%m); }
static u64 powmod(u64 a,u64 e,u64 m){ u64 r=1; a%=m; while(e){ if(e&1)r=mulmod(r,a,m); a=mulmod(a,a,m); e>>=1;} return r; }
static int is_prime64(u64 n){
  if(n<2)return 0; for(int i=0;i<12 && (u64)small_primes[i]*small_primes[i]<=n+1;i++){ u32 q=small_primes[i]; if(n==q)return 1; if(n%q==0)return 0; }
  if(n<121)return n>1;
  u64 d=n-1; int s=0; while(!(d&1)){d>>=1;s++;}
  static const u64 bases[4]={2,3,5,7};
  for(int i=0;i<4;i++){ u64 a=bases[i]%n; if(!a)continue; u64 x=powmod(a,d,n); if(x==1||x==n-1)continue;
    int ok=0; for(int r=1;r<s;r++){ x=mulmod(x,x,n); if(x==n-1){ok=1;break;} } if(!ok)return 0; }
  return 1;
}
static u64 isqrt64(u64 n){ u64 r=(u64)sqrtl((long double)n); while(r*r>n)r--; while((r+1)*(r+1)<=n)r++; return r; }

/* ---------- divisor DFS over the smooth part ---------- */
static u64 sf_p[24]; static int sf_e[24]; static int sf_n;   /* factorization of S */
static u64 g_thresh, dmin_out, lbest_out, sqrtl_glob;
static void dfs(int i,u64 cur){
  if(cur>g_thresh){ if(cur<dmin_out)dmin_out=cur; return; }   /* prune: children only larger */
  if(cur>lbest_out)lbest_out=cur;                             /* candidate divisor <= g */
  if(i==sf_n)return;
  u64 v=cur;
  dfs(i+1,v);
  for(int e=1;e<=sf_e[i];e++){ v*=sf_p[i]; dfs(i+1,v); if(v>g_thresh)break; }
}
/* dmin = smallest divisor of S exceeding g (UINT64_MAX if none, i.e. S<=g);
 * lbest = largest divisor of S that is <= g. */
static void s_divisors(u64 g){
  g_thresh=g; dmin_out=UINT64_MAX; lbest_out=1; dfs(0,1);
}

/* ---------- statistics ---------- */
typedef struct {
  u64 ndec, nweight, nlevel, nlev1, ngt1, ntie;
  u64 twin_k3, twin_g2, twin_bad;      /* Lemma 4 */
  u64 mod3_viol;                        /* Theorem A */
  u64 lev_Lgtg_viol;                    /* L <= g-1 check on level class */
  u64 khist[KCAP+2];                    /* weight-class k histogram; [KCAP+1]=overflow */
  u64 lhist[GMAX];                      /* level-class L histogram */
  u64 n1_by_gap[GMAX]; u64 cnt_by_gap[GMAX];
  double mass_by_gap[GMAX];             /* sum 1/ln p over gap-g pairs */
  double r2mass;                        /* sum 2 ln g / ln l over decomposables */
  u64 lock_num[LOCK_GMAX+2][NLOCKR];    /* lock hits: p == g mod r, per (g,r) */
  u64 reshist[LOCK_GMAX+2][NLOCKR][104];/* residue histogram of p mod r given gap g */
  u64 gap_sq_cnt;                       /* g >= sqrt(l) primes (empty-window) */
  u64 comp_weight_level_cnt;            /* level-classified with composite weight */
  u64 cube_viol;                        /* Cube Lemma l <= (g-1)^3 violations   */
} Stats;
static Stats S;

static u64 ewp[64]; static int n_ewp=0;      /* empty-window primes found */
static u64 cwl[64]; static int n_cwl=0;      /* composite-weight level primes */

/* checkpoints: x = 10^(j/8), j=24..72, plus exact decades */
#define NCK 128
static u64 ck[NCK]; static int nck=0, ck_i=0;
static void build_ck(void){
  for(int j=24;j<=72;j++){ double v=pow(10.0,j/8.0); u64 x=(u64)(v+0.5); if(x<=LIMIT) ck[nck++]=x; }
  for(int d=3;d<=15;d++){ u64 x=1; for(int i=0;i<d;i++)x*=10; if(x<=LIMIT){ ck[nck++]=x; } }
  /* sort unique */
  for(int i=0;i<nck;i++)for(int j=i+1;j<nck;j++)if(ck[j]<ck[i]){u64 t=ck[i];ck[i]=ck[j];ck[j]=t;}
  int m=0; for(int i=0;i<nck;i++) if(!m||ck[i]!=ck[m-1]) ck[m++]=ck[i];
  nck=m;
}
static void dump_ck(u64 x, FILE*f){
  fprintf(f,"{\"x\":%llu,\"ndec\":%llu,\"nw\":%llu,\"nlev\":%llu,\"n1\":%llu,\"ngt1\":%llu,\"ntie\":%llu,"
            "\"twin_k3\":%llu,\"twin_g2\":%llu,\"twin_bad\":%llu,\"mod3v\":%llu,\"Lviol\":%llu,\"r2mass\":%.6f,"
            "\"gapsq\":%llu,\"cwl\":%llu,\"cubev\":%llu",
    (unsigned long long)x,(unsigned long long)S.ndec,(unsigned long long)S.nweight,(unsigned long long)S.nlevel,
    (unsigned long long)S.nlev1,(unsigned long long)S.ngt1,(unsigned long long)S.ntie,
    (unsigned long long)S.twin_k3,(unsigned long long)S.twin_g2,(unsigned long long)S.twin_bad,
    (unsigned long long)S.mod3_viol,(unsigned long long)S.lev_Lgtg_viol,S.r2mass,
    (unsigned long long)S.gap_sq_cnt,(unsigned long long)S.comp_weight_level_cnt,(unsigned long long)S.cube_viol);
  /* selected lock cells at every checkpoint (for cross-engine diff) */
  fprintf(f,",\"lock\":[");
  int first=1;
  for(int gi=2;gi<=12;gi+=2) for(int ri=0;ri<NLOCKR;ri++){
    int r=lock_r[ri]; if(r<=gi||r>13)continue;
    if(!first)fprintf(f,","); first=0;
    fprintf(f,"[%d,%d,%llu]",gi,r,(unsigned long long)S.lock_num[gi][ri]);
  }
  fprintf(f,"],\"cnt_g\":[");
  for(int gg=2;gg<=12;gg+=2){ fprintf(f,"%s%llu",gg>2?",":"",(unsigned long long)S.cnt_by_gap[gg]); }
  fprintf(f,"]}\n"); fflush(f);
}

/* ---------- classification ---------- */
/* returns class (1 weight, 2 level); *kout exact weight if known (else 0 => >KCAP unknown), *Lout level (exact for class 2; for class 1 exact iff *kout>0) */
static int classify(u64 l,u64 g,u64 *kout,u64 *Lout){
  u64 sqrtl=isqrt64(l);
  /* smooth part over primes <= g */
  u64 rem=l; sf_n=0; u64 Ssm=1;
  for(int i=0;i<n_small && (u64)small_primes[i]<=g;i++){
    u32 q=small_primes[i];
    if(rem%q==0){ int e=0; while(rem%q==0){rem/=q;e++;} sf_p[sf_n]=q; sf_e[sf_n]=e; sf_n++; u64 pw=1; for(int t=0;t<e;t++)pw*=q; Ssm*=pw; }
  }
  u64 R=rem;
  s_divisors(g);                     /* dmin_out, lbest_out over S */
  u64 Dmin=dmin_out;
  int cls; u64 kv=0, Lv=0;
  if(R==1){
    if(Dmin<=sqrtl){ cls=1; kv=Dmin; Lv=l/kv; }
    else{ cls=2; kv=Dmin; Lv=l/kv; }
  } else if(R<=sqrtl){
    cls=1;
    /* exact k = min(Dmin, spf(R)); spf(R) in (g, sqrt R] or R prime */
    u64 spf=0;
    for(int i=0;i<n_small;i++){ u32 q=small_primes[i]; if(q<=g)continue; if((u64)q*q>R){ spf=R; break; } if(R%q==0){ spf=q; break; } if(q>KCAP)break; }
    if(spf==0){ /* spf(R)>KCAP and R composite-or-prime with spf>1000 */ kv = (Dmin<=KCAP)?Dmin:0; if(kv)Lv=l/kv; }
    else { kv = Dmin<spf?Dmin:spf; Lv=l/kv; }
  } else { /* R > sqrt(l) */
    if(!is_prime64(R)){
      cls=1;
      u64 spf=0;
      for(int i=0;i<n_small;i++){ u32 q=small_primes[i]; if(q<=g)continue; if(R%q==0){ spf=q; break; } if(q>KCAP)break; }
      if(spf==0){ kv=(Dmin<=KCAP)?Dmin:0; if(kv)Lv=l/kv; } else { kv=Dmin<spf?Dmin:spf; Lv=l/kv; }
    } else {
      if(Dmin<=sqrtl){ cls=1; kv=Dmin; Lv=l/kv; }
      else{ cls=2; kv=(Dmin<R?Dmin:R); Lv=l/kv; }
    }
  }
  *kout=kv; *Lout=Lv; return cls;
}

/* naive reference (used for p <= DUMPMAX internal gate) */
static int classify_naive(u64 l,u64 g,u64 *kout,u64 *Lout){
  u64 s=isqrt64(l);
  for(u64 m=g+1;m<=s;m++) if(l%m==0){ *kout=m; *Lout=l/m; return 1; }
  for(u64 e=(g< l?g:l); e>=1; e--) if(l%e==0 && l/e>g){ *kout=l/e; *Lout=e; return 2; }
  return 0;
}

int main(int argc,char**argv){
  if(argc>1) LIMIT=strtoull(argv[1],0,10);
  gen_small(); gen_base(LIMIT+4000); build_ck();
  FILE *fck=fopen("/home/claude/out/ck.jsonl","w");
  FILE *fdump=fopen("/home/claude/out/rows_2e6.csv","w");
  fprintf(fdump,"p,g,l,k,L,cls\n");
  memset(&S,0,sizeof S);

  /* segmented sieve over odds */
  const u64 SPAN=1ULL<<24;            /* numbers per segment */
  u64 nbytes=SPAN/16+2;
  unsigned char *seg=malloc(nbytes);
  u64 hi_target=LIMIT+3000;           /* need next prime past LIMIT */
  u64 prev=2; int have_prev=0; u64 mismatches=0;
  u64 maxgap=0; u64 maxgap_at=0;
  char ladder[8192]; int lad_len=0; ladder[0]=0;

  for(u64 lo=3; lo<=hi_target; lo+=SPAN){
    u64 hi=lo+SPAN-1; if(hi>hi_target)hi=hi_target;
    if(!(lo&1)) lo++;                 /* ensure odd start (only first time matters) */
    u64 count=(hi-lo)/2+1;
    memset(seg,0,(count+7)/8+1);
    for(int i=1;i<n_base;i++){        /* skip 2 */
      u64 q=base_primes[i]; u64 q2=q*q; if(q2>hi)break;
      u64 start=q2; if(start<lo){ u64 k=(lo+q-1)/q; if(!(k&1))k++; start=k*q; }
      if(!(start&1))start+=q;
      for(u64 v=start; v<=hi; v+=2*q){ u64 idx=(v-lo)>>1; seg[idx>>3]|=(unsigned char)(1u<<(idx&7)); }
    }
    for(u64 idx=0; idx<count; idx++){
      if(seg[idx>>3]&(1u<<(idx&7)))continue;
      u64 p=lo+2*idx;
      if(!have_prev){ /* p==3 */ have_prev=1;
        /* handle pair (2,3): d=1,l=1 -> not decomposable; nothing to count */
        prev=3; continue;
      }
      /* consecutive pair (prev, p): stats attach to prev if prev <= LIMIT */
      u64 pn=prev, g=p-prev;
      prev=p;
      if(pn>LIMIT) goto done;
      /* checkpoints keyed on pn */
      while(ck_i<nck && pn>ck[ck_i]){ dump_ck(ck[ck_i],fck); ck_i++; }
      if(g>maxgap){ maxgap=g; maxgap_at=pn; lad_len+=snprintf(ladder+lad_len,sizeof(ladder)-lad_len,"[%llu,%llu],",(unsigned long long)g,(unsigned long long)pn); }
      if(2*p >= 3*pn) continue;   /* not decomposable */
      u64 l=pn-g;
      /* decomposable */
      S.ndec++;
      double lnp=log((double)pn);
      S.r2mass += 2.0*log((double)g)/log((double)l);
      if(g<GMAX){ S.cnt_by_gap[g]++; S.mass_by_gap[g]+=1.0/lnp; }
      u64 kv,Lv; int cls=classify(l,g,&kv,&Lv);
      if(pn<=DUMPMAX){
        u64 k2,L2; int c2=classify_naive(l,g,&k2,&L2);
        if(c2!=cls || (kv&&kv!=k2) || ((cls==2||kv) && Lv!=L2)) { mismatches++; fprintf(stderr,"MISMATCH p=%llu fast(%d,%llu,%llu) naive(%d,%llu,%llu)\n",(unsigned long long)pn,cls,(unsigned long long)kv,(unsigned long long)Lv,c2,(unsigned long long)k2,(unsigned long long)L2); }
        fprintf(fdump,"%llu,%llu,%llu,%llu,%llu,%d\n",(unsigned long long)pn,(unsigned long long)g,(unsigned long long)l,(unsigned long long)k2,(unsigned long long)L2,c2);
      }
      { u64 sq=isqrt64(l); if(sq*sq==l){ u64 k2,L2; int c2=classify_naive(l,g,&k2,&L2);
          if(c2!=cls){ mismatches++; fprintf(stderr,"SQ-GATE p=%llu\n",(unsigned long long)pn); }
          if(!kv && c2==cls){ kv=k2; Lv=L2; }
          if(cls==1 && k2==sq) S.ntie++; } }
      if(cls==1){
        S.nweight++;
        if(kv){ if(kv<=KCAP)S.khist[kv]++; else S.khist[KCAP+1]++; }
        else S.khist[KCAP+1]++;
      } else {
        S.nlevel++;
        if(Lv==1)S.nlev1++; else S.ngt1++;
        if(Lv<GMAX)S.lhist[Lv]++;
        if(Lv==1 && g<GMAX)S.n1_by_gap[g]++;
        if(pn>3 && Lv>g-1)S.lev_Lgtg_viol++;
        /* composite weight? (Cube Lemma / C4) */
        if(!is_prime64(kv)){ S.comp_weight_level_cnt++; if(n_cwl<64)cwl[n_cwl++]=pn; if(l>(g-1)*(g-1)*(g-1))S.cube_viol++; }
      }
      if(kv==3)S.twin_k3++;
      if(kv==3 && g!=2)S.twin_bad++;
      if(g==2){ S.twin_g2++; if(kv!=3)S.twin_bad++; }
      /* Theorem A (mod 3 rigidity), p>3 */
      if(pn>3){ int a3=(g%3==0), b3=(l%3==0); if(a3==b3)S.mod3_viol++; }
      /* empty window g >= sqrt(l) */
      if((u64)g*g>=l){ S.gap_sq_cnt++; if(n_ewp<64)ewp[n_ewp++]=pn; }
      /* congruence lock + residue histograms */
      if(g<=LOCK_GMAX){
        for(int ri=0;ri<NLOCKR;ri++){ u32 r=lock_r[ri]; u32 a=(u32)(pn%r);
          S.reshist[g][ri][a]++;
          if(a==(u32)(g%r)) S.lock_num[g][ri]++;
        }
      }
    }
  }
done:
  while(ck_i<nck && ck[ck_i]<=LIMIT){ dump_ck(ck[ck_i],fck); ck_i++; }
  fclose(fck); fclose(fdump);
  if(mismatches){ fprintf(stderr,"INTERNAL GATE FAILED: %llu mismatches\n",(unsigned long long)mismatches); return 2; }
  fprintf(stderr,"internal fast-vs-naive gate: 0 mismatches on all p <= %llu\n",(unsigned long long)DUMPMAX);
  /* final dumps */
  FILE*f=fopen("/home/claude/out/final.json","w");
  fprintf(f,"{\"limit\":%llu,\"ladder\":[%s[0,0]],\"ewp\":[",(unsigned long long)LIMIT,ladder);
  for(int i=0;i<n_ewp;i++)fprintf(f,"%s%llu",i?",":"",(unsigned long long)ewp[i]);
  fprintf(f,"],\"cwl\":[");
  for(int i=0;i<n_cwl;i++)fprintf(f,"%s%llu",i?",":"",(unsigned long long)cwl[i]);
  fprintf(f,"],\"khist\":[");
  for(int i=0;i<=KCAP+1;i++)fprintf(f,"%s%llu",i?",":"",(unsigned long long)S.khist[i]);
  fprintf(f,"],\"lhist\":[");
  for(int i=0;i<GMAX;i++)fprintf(f,"%s%llu",i?",":"",(unsigned long long)S.lhist[i]);
  fprintf(f,"],\"n1_by_gap\":[");
  for(int i=0;i<GMAX;i++)fprintf(f,"%s%llu",i?",":"",(unsigned long long)S.n1_by_gap[i]);
  fprintf(f,"],\"cnt_by_gap\":[");
  for(int i=0;i<GMAX;i++)fprintf(f,"%s%llu",i?",":"",(unsigned long long)S.cnt_by_gap[i]);
  fprintf(f,"],\"mass_by_gap\":[");
  for(int i=0;i<GMAX;i++)fprintf(f,"%s%.6f",i?",":"",S.mass_by_gap[i]);
  fprintf(f,"],\"lock\":[");
  int first=1;
  for(int g=2;g<=LOCK_GMAX;g+=2)for(int ri=0;ri<NLOCKR;ri++){
    if(!first)fprintf(f,","); first=0;
    fprintf(f,"[%d,%d,%llu]",g,lock_r[ri],(unsigned long long)S.lock_num[g][ri]);
  }
  fprintf(f,"],\"reshist\":{");
  first=1;
  for(int g=2;g<=14;g+=2)for(int ri=0;ri<NLOCKR;ri++){ int r=lock_r[ri]; if(r>17)continue;
    if(!first)fprintf(f,","); first=0;
    fprintf(f,"\"%d_%d\":[",g,r);
    for(int a=0;a<r;a++)fprintf(f,"%s%llu",a?",":"",(unsigned long long)S.reshist[g][ri][a]);
    fprintf(f,"]");
  }
  fprintf(f,"}}\n"); fclose(f);
  fprintf(stderr,"done. maxgap=%llu at %llu\n",(unsigned long long)maxgap,(unsigned long long)maxgap_at);
  return 0;
}

/* Cramer control for the decompwlj census.
 * Model A (classic): each n >= 3 independently "prime" with prob 1/ln n.
 * Model B (parity-matched): each odd n >= 3 with prob 2/ln n  (even gaps, odd l).
 * Same classification engine as sweep.c (smooth-part + MR), streamed.
 * Fixed seed for reproducibility. Dumps checkpoint JSON lines.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <math.h>
typedef uint64_t u64; typedef uint32_t u32; typedef __uint128_t u128;

static u32 small_primes[2048]; static int n_small;
static void gen_small(void){ char c[1551]; memset(c,0,sizeof c);
  for(int i=2;i<=1550;i++) if(!c[i]){ small_primes[n_small++]=i; for(int j=2*i;j<=1550;j+=i)c[j]=1; } }
static u64 mulmod(u64 a,u64 b,u64 m){ return (u64)((u128)a*b%m); }
static u64 powmod(u64 a,u64 e,u64 m){ u64 r=1; a%=m; while(e){ if(e&1)r=mulmod(r,a,m); a=mulmod(a,a,m); e>>=1;} return r; }
static int is_prime64(u64 n){
  if(n<2)return 0;
  for(int i=0;i<12 && (u64)small_primes[i]*small_primes[i]<=n+1;i++){ u32 q=small_primes[i]; if(n==q)return 1; if(n%q==0)return 0; }
  if(n<121)return n>1;
  u64 d=n-1; int s=0; while(!(d&1)){d>>=1;s++;}
  static const u64 bases[4]={2,3,5,7};
  for(int i=0;i<4;i++){ u64 a=bases[i]%n; if(!a)continue; u64 x=powmod(a,d,n); if(x==1||x==n-1)continue;
    int ok=0; for(int r=1;r<s;r++){ x=mulmod(x,x,n); if(x==n-1){ok=1;break;} } if(!ok)return 0; }
  return 1;
}
static u64 isqrt64(u64 n){ u64 r=(u64)sqrtl((long double)n); while(r*r>n)r--; while((r+1)*(r+1)<=n)r++; return r; }
static u64 sf_p[24]; static int sf_e[24]; static int sf_n;
static u64 g_thresh,dmin_out,lbest_out;
static void dfs(int i,u64 cur){
  if(cur>g_thresh){ if(cur<dmin_out)dmin_out=cur; return; }
  if(cur>lbest_out)lbest_out=cur;
  if(i==sf_n)return;
  u64 v=cur; dfs(i+1,v);
  for(int e=1;e<=sf_e[i];e++){ v*=sf_p[i]; dfs(i+1,v); if(v>g_thresh)break; }
}
static int classify(u64 l,u64 g,u64 *kout,u64 *Lout){
  u64 sqrtl=isqrt64(l);
  u64 rem=l; sf_n=0;
  for(int i=0;i<n_small && (u64)small_primes[i]<=g;i++){ u32 q=small_primes[i];
    if(rem%q==0){ int e=0; while(rem%q==0){rem/=q;e++;} sf_p[sf_n]=q; sf_e[sf_n]=e; sf_n++; } }
  u64 R=rem; g_thresh=g; dmin_out=UINT64_MAX; lbest_out=1; dfs(0,1);
  u64 Dmin=dmin_out; int cls; u64 kv=0,Lv=0;
  if(R==1){ if(Dmin<=sqrtl){cls=1;kv=Dmin;} else {cls=2;kv=Dmin;} Lv=l/kv; }
  else if(R<=sqrtl){ cls=1; }
  else if(!is_prime64(R)){ cls=1; }
  else { if(Dmin<=sqrtl){cls=1;kv=Dmin;Lv=l/kv;} else {cls=2;kv=(Dmin<R?Dmin:R);Lv=l/kv;} }
  *kout=kv;*Lout=Lv; return cls;
}
/* xorshift64* */
static u64 rngs;
static double rnd(void){ rngs^=rngs>>12; rngs^=rngs<<25; rngs^=rngs>>27; return (double)((rngs*2685821657736338717ULL)>>11)/9007199254740992.0; }

int main(int argc,char**argv){
  u64 LIMIT = argc>1?strtoull(argv[1],0,10):100000000ULL;
  int model = argc>2?atoi(argv[2]):0;   /* 0 = classic, 1 = odd-only */
  u64 seed  = argc>3?strtoull(argv[3],0,10):20260807ULL;
  gen_small(); rngs=seed^0x9E3779B97F4A7C15ULL; for(int i=0;i<16;i++)rnd();
  u64 ck[128]; int nck=0,cki=0;
  for(int j=24;j<=8*(int)round(log10((double)LIMIT));j++){ double v=pow(10.0,j/8.0); u64 x=(u64)(v+0.5); if(x<=LIMIT)ck[nck++]=x; }
  ck[nck++]=LIMIT;
  u64 prev=0; u64 ndec=0,nlev=0,n1=0,ngt1=0,nterm=0;
  printf("[");
  int firstout=1;
  for(u64 n=3;n<=LIMIT+2000;n++){
    if(model==1 && !(n&1))continue;
    double pr=(model==1?2.0:1.0)/log((double)n);
    if(rnd()>=pr)continue;
    if(prev){
      u64 pn=prev,g=n-prev;
      while(cki<nck && pn>ck[cki]){
        if(!firstout)printf(","); firstout=0;
        printf("{\"x\":%llu,\"nterm\":%llu,\"ndec\":%llu,\"nlev\":%llu,\"n1\":%llu,\"ngt1\":%llu}",
          (unsigned long long)ck[cki],(unsigned long long)nterm,(unsigned long long)ndec,
          (unsigned long long)nlev,(unsigned long long)n1,(unsigned long long)ngt1);
        cki++;
      }
      if(pn<=LIMIT){
        nterm++;
        if(2*n<3*pn){
          u64 l=pn-g,kv,Lv; int cls=classify(l,g,&kv,&Lv);
          ndec++;
          if(cls==2){ nlev++; if(Lv==1)n1++; else ngt1++; }
        }
      }
    }
    prev=n;
  }
  while(cki<nck && ck[cki]<=LIMIT){
    if(!firstout)printf(","); firstout=0;
    printf("{\"x\":%llu,\"nterm\":%llu,\"ndec\":%llu,\"nlev\":%llu,\"n1\":%llu,\"ngt1\":%llu}",
      (unsigned long long)ck[cki],(unsigned long long)nterm,(unsigned long long)ndec,
      (unsigned long long)nlev,(unsigned long long)n1,(unsigned long long)ngt1);
    cki++;
  }
  printf("]\n");
  return 0;
}

A.3  Python audit

An independently written sieve and classifier (trial division for the weight branch, descending divisor scan for the level branch) recomputed every decomposable prime to \(10^6\) and diffed the full tuple \((g,l,k,L,\mathrm{class})\) against the C rows: zero mismatches on all 78,495. The singular-series machinery of §6 (\(\mathfrak S_2\), \(\mathfrak S_3\) over patterns, products over primes to \(2\times10^5\)) and all figures are NumPy; figures are square, equal-aspect where the \(k\)–\(L\) ratio is drawn, house palette, embedded as base64.

B.Appendix B — session record and failures

Per the honest-ledger rule, failures precede summaries. Today’s session had four, all caught by the pipeline’s own gates before any number reached this document:

• Heap corruption at \(10^7\). The C engine’s base-prime buffer was sized by the estimate \(\pi(\sqrt{\mathrm{lim}})\approx\sqrt{\mathrm{lim}}/10\), which fails below \(\sqrt{\mathrm{lim}}\approx 22{,}000\); the overflow corrupted the allocator at the first \(10^7\) attempt. Caught by the crash itself at the gate scale; buffer resized; re-run clean.
• Lemma-4 counter mis-scoped. The \(k=3\) tally sat in the weight branch only, missing the unique level-classified member \(p=5\); the \(10^6\) anchor \(\#\{k=3\}=\#\{g=2\}\) failed by exactly one. Caught by the anchor; counter moved to class-independent scope; equality restored at every checkpoint.
• Python audit boundary bug. The audit’s sieve stopped at \(10^6{+}2\), silently dropping the final pair \((999983,\,1000003)\); the row-count diff flagged one missing row. The same class of error as corrections item 6 — boundary conventions remain the most reliable generator of bugs in this project. Sieve extended; zero mismatches.
• Cosmetic. One figure legend initially covered data points; regenerated.

Also for the record: the background-process constraint documented in earlier sessions (sweeps must run foreground) was respected throughout; no run died. The \(10^{10}\) census and the \(2^{64}\) frontier were not re-run today and appear only as CARRIED with their provenance (seventh edition, 5 Aug 2026).

C.Cumulative corrections log

The complete log, carried verbatim in substance from the seventh edition (items 1–16) with today’s addition. The log only grows.