// ============================================================================ // localized-04-maxsum.js // // QUESTION. The Localized Merge Lemma (research/LOCALIZED-GAP.md) reduces the // whole upper chain to ONE unknown: how does // // maxsum_m(T_x, [0,Y)) = max { s_{i+m} - s_i : s_i < Y } // // grow in m? Here s_1 < s_2 < ... are the twin slots of T_x, that is the r // with r and r+2 both x-rough. The chain needs // // maxsum_m <= C * m * mbar for m up to about x / ln^2 x, // // with mbar the mean twin-slot gap (Mertens/HL says mbar ~ 2.4 ln^2 x). // This script measures R(m) = maxsum_m / (m * mbar) and asks where it stops // looking like a constant. // // PREDICTION ON RECORD (Chris, written before the first run). // "Read as an interval statement it says: every interval of length about x/4 // inside [0,Y) contains at least about x/(9.6 ln^2 x) twin slots of T_x. // Interval length ~x against sift level x puts this at sifting parameter // u = 1, below the linear sieve limit beta_1 = 2 and far below the // two-class limit beta_2 = 4.2665. So I predict it FAILS, or at minimum // that the ratio maxsum_m/(m*mbar) drifts UPWARD with m rather than // settling. Measure by how much, and where it turns over." // // HONEST DOUBT, mine, also written before the run. // maxsum_m is a MAX over roughly Y/mbar windows. A max of m-sums should // CONCENTRATE as m grows (the large-deviation rate needed is ln(#windows)/m, // which falls), so R(m) should DECREASE toward 1, not rise. If that is what // happens then the binding constraint is R(1) = M(x,Y)/mbar, the localized // maximal-gap ratio, and the whole question is how R(1) grows with x, not // with m. I may be measuring the wrong end of the curve. Also: at k = 2 // the head is crystallised and the slots below x'^2 are literally twin // primes, so any statement there is TPC-hard by construction. Substantive // runs are k >= 3 and every table below is labelled with its k. // // ENGINE. Segmented-in-spirit bitset sieve of [0, Y + BUF) by the primes // <= x. Never the tile. One pass folds the whole ladder and dumps the full // maxsum curve at chosen checkpoints. // // USAGE // node research/localized-04-maxsum.js [mcap] [xmax] // Y window; must stay under 2^32 for the bit arithmetic // xlist 'auto' = 5 checkpoints to Y^(1/3); 'scan' = 24 geometric ones; // or a comma list of primes // mcap largest m in the curve; 0 = auto (~4x/ln^2x, min 192) // xmax top of the ladder; 0 = Y^(1/3), i.e. k >= 3 at every checkpoint // node research/localized-04-maxsum.js 1e9 auto 256 // node research/localized-04-maxsum.js 1e9 scan 8 16000 // node research/localized-04-maxsum.js 1e9 997,16001 1024 16000 // ============================================================================ 'use strict'; const Y = Number(process.argv[2] || 1e9); const XARG = String(process.argv[3] || 'auto'); const MCAP_ARG = Number(process.argv[4] || 0); // 0 = auto const XMAX_ARG = Number(process.argv[5] || 0); // 0 = Y^(1/3), i.e. k >= 3 const BUF = Math.max(1 << 16, Math.ceil(Y * 0.005)); const YTOP = Y + BUF; function primesUpTo(n) { const s = new Uint8Array(n + 1), out = []; for (let i = 2; i <= n; i++) if (!s[i]) { out.push(i); for (let j = i * i; j <= n; j += i) s[j] = 1; } return out; } // ---- checkpoints ---------------------------------------------------------- const XMAX = XMAX_ARG || (Math.floor(Math.pow(Y, 1 / 3)) + 1); // default k >= 3 let ladder = primesUpTo(Math.max(XMAX * 2, XMAX + 4000, 3)); // headroom for q_m lookups let checkpoints; if (XARG === 'auto' || XARG === 'scan') { const want = XARG === 'scan' ? Array.from({ length: 24 }, (_, i) => (XMAX / 24) * Math.pow(24, i / 23)) : [XMAX / 16, XMAX / 8, XMAX / 4, XMAX / 2, XMAX]; checkpoints = [...new Set(want.map(v => { let best = ladder[0]; for (const p of ladder) if (Math.abs(p - v) < Math.abs(best - v)) best = p; return best; }))].filter(p => p >= 11); } else { checkpoints = XARG.split(',').map(Number); const need = Math.max(...checkpoints); if (need + 4000 > ladder[ladder.length - 1]) ladder = primesUpTo(need + 4000); } const cpSet = new Set(checkpoints); const t0 = Date.now(); const el = () => ((Date.now() - t0) / 1000).toFixed(1); console.log(`# localized-04-maxsum Y=${Y.toExponential(3)} BUF=${BUF} YTOP=${YTOP.toExponential(4)}`); console.log(`# ladder to x=${ladder[ladder.length - 1]} checkpoints: ${checkpoints.join(', ')}`); console.log(`# k = lnY/lnx at each checkpoint: ${checkpoints.map(x => (Math.log(Y) / Math.log(x)).toFixed(2)).join(', ')}`); // ---- bitset of x-rough integers ------------------------------------------ // Executable, not prose. `W[j >>> 5]` addresses the bitset with a 32-bit // shift, so every index it ever sees must be below 2^32; the usage note at // the top and the comment on the next line have said so since the file was // written, and neither of them stops a run. natal-cap-34-wrap-precision.js:164 // is the pattern this one was missing. (2026-08-20.) if (!(YTOP + 66 < 2 ** 32)) throw new Error(`Y is too large for the 32-bit bitset: YTOP = ${YTOP} needs YTOP + 66 < 2^32`); const NW = Math.floor((YTOP + 66) / 32) + 2; // Y must stay below 2^32 for the bit ops const W = new Uint32Array(NW).fill(0xFFFFFFFF); W[0] &= ~1; // 0 is not rough function strike(p) { for (let j = p; j <= YTOP + 2; j += p) W[j >>> 5] &= ~(1 << (j & 31)); } // ---- twin-slot extraction, word-wise ------------------------------------- // slot r <=> bit r set AND bit r+2 set. function slotList(x) { const est = Math.ceil(YTOP / (1.8 * Math.log(x) ** 2)) + 4096; let arr = new Float64Array(est), n = 0; // Float64 so Y may exceed 2^31 const lastW = Math.floor((YTOP + 2) / 32); for (let w = 0; w <= lastW; w++) { const a = W[w], b = W[w + 1] | 0; let t = a & ((a >>> 2) | (b << 30)); const base = w * 32; while (t !== 0) { const low = t & -t; const r = base + (31 - Math.clz32(low)); if (r >= 1 && r <= YTOP) { if (n === arr.length) { const g = new Float64Array(arr.length * 2); g.set(arr); arr = g; } arr[n++] = r; } t ^= low; } } return { arr, n }; } // ---- the maxsum curve at one checkpoint ---------------------------------- function curve(x, s, n) { // iY = first index with slot >= Y. D = iY = #slots below Y. let iY = 0; while (iY < n && s[iY] < Y) iY++; let iB = 0; while (iB < n && s[iB] <= Y + 4096) iB++; // the old 4096-buffer rule const D = iY, mbar = Y / D; const lg2 = Math.log(x) ** 2; let MCAP = MCAP_ARG || Math.max(192, Math.ceil(4 * x / lg2)); MCAP = Math.min(MCAP, Math.max(8, Math.floor(1.2e10 / D)), n - iY - 2); // gap statistics below Y (for the extreme-value fit) let s1 = 0, s2 = 0, nAbove2p = 0; const twoP = 2 * (ladder[ladder.indexOf(x) + 1] || x); for (let i = 0; i + 1 < iY; i++) { const g = s[i + 1] - s[i]; s1 += g; s2 += g * g; if (g >= twoP) nAbove2p++; } const gm = s1 / (iY - 1), gsd = Math.sqrt(s2 / (iY - 1) - gm * gm); if (MCAP < 4) { console.log(`# x=${x}: MCAP too small, skipping`); return null; } const ms = new Float64Array(MCAP + 1); // rule (a): left endpoint < Y, no cap on right const msS = new Float64Array(MCAP + 1); // rule (b): whole window below Y const msB = new Float64Array(MCAP + 1); // rule (c): slot list truncated at Y+4096 const at = new Float64Array(MCAP + 1); const atEnd = new Float64Array(MCAP + 1); const msE = new Float64Array(MCAP + 1); // rule (a) restricted to windows STARTING in [Y-4096, Y) const iE = (() => { let j = iY; while (j > 0 && s[j - 1] >= Y - 4096) j--; return j; })(); const c15 = new Float64Array(MCAP + 1); const c20 = new Float64Array(MCAP + 1); const t15 = new Float64Array(MCAP + 1), t20 = new Float64Array(MCAP + 1); for (let m = 1; m <= MCAP; m++) { t15[m] = 1.5 * m * mbar; t20[m] = 2.0 * m * mbar; } let tick = Date.now(); for (let i = 0; i < iY; i++) { const si = s[i]; for (let m = 1; m <= MCAP; m++) { const v = s[i + m] - si; if (v > ms[m]) { ms[m] = v; at[m] = si; atEnd[m] = s[i + m]; } if (i + m < iY && v > msS[m]) msS[m] = v; if (i + m < iB && v > msB[m]) msB[m] = v; if (i >= iE && v > msE[m]) msE[m] = v; if (v >= t15[m]) c15[m]++; if (v >= t20[m]) c20[m]++; } if ((i & 0xFFFFF) === 0 && Date.now() - tick > 30000) { tick = Date.now(); console.error(`# [${el()}s] x=${x} maxsum scan ${(100 * i / iY).toFixed(1)}%`); } } return { x, D, mbar, MCAP, ms, msS, msB, msE, at, atEnd, c15, c20, iY, iB, iE, n, gm, gsd, nAbove2p }; } // ---- reporting ------------------------------------------------------------ const results = []; function report(r) { const { x, D, mbar, MCAP, ms, msS, msB, msE, at, atEnd, c15, c20, iY, iE, gm, gsd, nAbove2p } = r; // EXTREME-VALUE MODEL, fitted to nothing: a max over D overlapping windows of // an m-sum of gaps with mean gm and sd gsd. Gaussian regime (m >> ln D): // R(m) = 1 + (gsd/gm) * sqrt(2 ln D / m). // Exponential-tail regime (m = 1): R(1) ~ ln D. const lnD = Math.log(D); const Rg = (m) => 1 + (gsd / gm) * Math.sqrt(2 * lnD / m); const lnx = Math.log(x), lg2 = lnx * lnx; const k = Math.log(Y) / lnx; const pNext = ladder[ladder.indexOf(x) + 1] || (x + 2); const mTarget = Math.max(1, Math.round(x / lg2)); // the chain's m range const mBlock9 = Math.max(1, Math.round(x / (9.6 * lg2))); // LOCALIZED-GAP.md sec 7 block console.log(`\n================ x = ${x} k = lnY/lnx = ${k.toFixed(2)} ================`); console.log(`# D(Y)=${D} mbar=Y/D=${mbar.toFixed(2)} vs 2.4 ln^2 x = ${(2.4 * lg2).toFixed(2)}` + ` (ratio ${(mbar / (2.4 * lg2)).toFixed(3)})`); console.log(`# M(x,Y)=maxsum_1=${ms[1]} M/mbar=R(1)=${(ms[1] / mbar).toFixed(3)} M/x^2=${(ms[1] / (x * x)).toExponential(3)}`); console.log(`# chain m-range: x/ln^2x = ${mTarget}, x/(9.6 ln^2x) = ${mBlock9}; MCAP = ${MCAP}`); console.log(`# gap stats below Y: mean=${gm.toFixed(2)} sd=${gsd.toFixed(2)} sd/mean=${(gsd / gm).toFixed(4)}` + ` lnD=${lnD.toFixed(2)} [EV model: R(1)~lnD=${lnD.toFixed(1)}, R(m)~1+(sd/mean)sqrt(2lnD/m)]`); console.log('m\tmaxsum_m\tR=ms/(m*mbar)\tR_EVmodel\tR/R_EV\tstrict(b)\tbuf4096(c)\t#win>=1.5mean\t#win>=2mean\targmax slot'); const show = []; for (let m = 1; m <= Math.min(12, MCAP); m++) show.push(m); for (const m of [16, 20, 24, 32, 48, 64, 96, 128, 192, 256]) if (m <= MCAP && !show.includes(m)) show.push(m); if (!show.includes(mTarget) && mTarget <= MCAP) show.push(mTarget); show.sort((a, b) => a - b); for (const m of show) { const R = ms[m] / (m * mbar); console.log(`${m}\t${ms[m]}\t\t${R.toFixed(4)}\t\t${Rg(m).toFixed(4)}\t\t${(R / Rg(m)).toFixed(4)}\t` + `${msS[m]}\t\t${msB[m]}\t\t${c15[m]}\t\t${c20[m]}\t\t${at[m]}`); } // where does R stop falling / is it monotone? let mono = true, mMin = 1, Rmin = Infinity; for (let m = 1; m <= MCAP; m++) { const R = ms[m] / (m * mbar); if (R < Rmin) { Rmin = R; mMin = m; } if (m > 1 && ms[m] / (m * mbar) > ms[m - 1] / ((m - 1) * mbar) + 1e-12) mono = false; } // observed C over the chain's own m-range let Cobs = 0, CobsAt = 1; for (let m = 1; m <= Math.min(mTarget, MCAP); m++) { const R = ms[m] / (m * mbar); if (R > Cobs) { Cobs = R; CobsAt = m; } } // measured block length: how many folds does maxsum_m <= (p-2)/4 actually allow? let mBlockObs = 0; for (let m = 1; m <= MCAP; m++) if (ms[m] <= (pNext - 2) / 4) mBlockObs = m; else break; const gateC = (pNext - 2) / (4 * mbar); // boundary sensitivity: rule (a) vs (b) vs (c) let worstAB = 0, worstAC = 0; for (let m = 1; m <= MCAP; m++) { worstAB = Math.max(worstAB, ms[m] / msS[m]); worstAC = Math.max(worstAC, ms[m] / msB[m]); } // A5 Theorem B / C, with c_min(j) = 3*p*j (Run Cost Theorem A) let Bm = 0; for (let m = 1; m <= MCAP; m++) if (ms[m] >= 3 * pNext * m) Bm = m; const Lbound = 1 + Bm; const kap = []; for (let m = 1; m <= Math.min(6, MCAP); m++) { let best = 1; for (let kk = 2; m + kk - 2 <= MCAP; kk++) if (ms[m + kk - 2] >= 3 * pNext * (kk - 1)) best = kk; kap.push(`kappa(${m})<=${best}`); } // how well does the EV model do over the Gaussian regime m >= 2 lnD? let evLo = Infinity, evHi = 0; for (let m = Math.ceil(2 * lnD); m <= MCAP; m++) { const q = (ms[m] / (m * mbar)) / Rg(m); evLo = Math.min(evLo, q); evHi = Math.max(evHi, q); } console.log(`# EV model over m in [${Math.ceil(2 * lnD)}, ${MCAP}]: R/R_EV in [${evLo.toFixed(3)}, ${evHi.toFixed(3)}];` + ` R(1)/lnD = ${(ms[1] / mbar / lnD).toFixed(3)}`); console.log(`# R(m) monotone non-increasing in m: ${mono ? 'YES' : 'NO'}; min R = ${Rmin.toFixed(4)} at m = ${mMin}`); console.log(`# R(MCAP=${MCAP}) = ${(ms[MCAP] / (MCAP * mbar)).toFixed(4)}`); console.log(`# C OBSERVED over m<=x/ln^2x: ${Cobs.toFixed(3)} (at m=${CobsAt}); R(1)/ln x = ${(ms[1] / mbar / lnx).toFixed(3)}`); console.log(`# C GATE (p-2)/(4 mbar) = ${gateC.toFixed(2)} -> lemma hypothesis ${Cobs <= gateC ? 'HOLDS' : 'FAILS'} at m=1`); // DEFICIT LEMMA (elementary). maxsum_m >= m*mbar always, since the mean of the // D-m window sums is m*(s_last - s_0)/(D-m) >= m*mbar. So the merge hypothesis // maxsum_m <= (q-2)/4 caps m at about x/(4*mbar) NO MATTER WHAT C is. const capDeficit = Math.floor((pNext - 2) / (4 * mbar)); console.log(`# block length measured: max{m : maxsum_m <= (p-2)/4} = ${mBlockObs}` + ` vs deficit-lemma cap x/(4 mbar) = ${capDeficit}` + ` vs sec7 heuristic x/(9.6 ln^2x) = ${mBlock9}`); console.log(`# Deficit Lemma check: min_m R(m) = ${Rmin.toFixed(4)} (must be >= 1) -> ${Rmin >= 1 ? 'HOLDS' : 'VIOLATED'}`); // the LOCALIZED-GAP.md sec 3 caveat, measured: how far past Y does the optimal // window reach, and can an edge window (start in [Y-4096,Y)) ever beat it? let over = 0, overM = 0, edgeWorst = 0, edgeWorstM = 0; for (let m = 1; m <= MCAP; m++) { if (atEnd[m] > Y && atEnd[m] - Y > over) { over = atEnd[m] - Y; overM = m; } const e = msE[m] / ms[m]; if (e > edgeWorst) { edgeWorst = e; edgeWorstM = m; } } console.log(`# boundary: worst ratio (a)/(b) = ${worstAB.toFixed(4)}, (a)/(c) = ${worstAC.toFixed(4)}`); console.log(`# boundary: optimal window overshoots Y by at most ${over} (at m=${overM});` + ` edge windows (${iY - iE} of them, start in [Y-4096,Y)) reach at most ` + `${(100 * edgeWorst).toFixed(2)}% of maxsum (worst at m=${edgeWorstM})`); console.log(`# A5 Thm B: L <= 1 + max{m: maxsum_m >= 3p m} = ${Lbound} (p = ${pNext}); ${kap.join(', ')}`); // A9 (U-FRAME sec 11) fitted tail on the TILE: ln(1/tail) = -0.235 + 1.2992*(g/mbar). // Push it through an extreme-value argument over D gaps: R(1) = (lnD + 0.235)/1.2992. const R1_A9 = (lnD + 0.235) / 1.2992; console.log(`# A9 tail transplanted to the head: predicts R(1) = (lnD+0.235)/1.2992 = ${R1_A9.toFixed(2)}` + ` against measured ${(ms[1] / mbar).toFixed(2)} (ratio ${((ms[1] / mbar) / R1_A9).toFixed(3)});` + ` gaps >= 2p' observed: ${nAbove2p}, A9 expects ${(D * Math.exp(0.235 - 1.2992 * 2 * pNext / mbar)).toExponential(2)}`); // ---- THE CHAIN SURVIVAL TEST ------------------------------------------- // Telescoping the Localized Merge Lemma from base x gives // M(T_{q_m}, Y) <= maxsum_m(T_x, Y), q_m = m-th prime after x, // but ONLY while the hypothesis M(T_{q_j}, Y) <= (q_{j+1}-2)/4 holds at every // step j <= m. The proven bound at step j is maxsum_j, so the chain is valid // through fold m iff maxsum_j <= (q_{j+1}-2)/4 for all j < m. Measure it. const qi = ladder.indexOf(x); let nChain = 0, why = 'ran out of m'; for (let j = 1; j <= MCAP; j++) { const q1 = ladder[qi + j]; // level after j folds if (q1 === undefined) { why = 'ran out of ladder'; break; } if (ms[j] <= (q1 - 2) / 4) nChain = j; else { why = `hypothesis maxsum_${j}=${ms[j]} > (q-2)/4 = ${((q1 - 2) / 4).toFixed(1)} at q=${q1}`; break; } } const reach = ladder[qi + nChain]; // per-fold arithmetic: what the chain spends vs what the gate earns const mHi = Math.min(MCAP, 64), mLo = Math.min(MCAP, 32); const spend = mHi > mLo ? (ms[mHi] - ms[mLo]) / (mHi - mLo) : NaN; const earn = (ladder[qi + mHi] !== undefined && mHi > mLo) ? (ladder[qi + mHi] - ladder[qi + mLo]) / (4 * (mHi - mLo)) : NaN; console.log(`# CHAIN SURVIVAL from base x=${x}: valid through ${nChain} fold(s), reaching level ${reach}; stopped because ${why}`); console.log(`# per fold, chain SPENDS d(maxsum)/dm = ${spend.toFixed(2)} against gate EARNS d(q/4)/dm = ${earn.toFixed(3)}` + ` -> ratio ${(spend / earn).toFixed(1)} (predicted ~14.4 ln x = ${(14.4 * lnx).toFixed(1)})`); results.push({ x, k, D, mbar, MCAP, M: ms[1], R1: ms[1] / mbar, Rmin, mMin, Cobs, CobsAt, gateC, mBlockObs, mBlock9, mTarget, worstAB, worstAC, Lbound, nChain, reach, spend, earn, Rtarget: ms[Math.min(mTarget, MCAP)] / (Math.min(mTarget, MCAP) * mbar) }); } // ---- main pass ------------------------------------------------------------ let done = 0; for (const x of ladder) { strike(x); if (!cpSet.has(x)) continue; console.log(`\n# [${el()}s] folded to x=${x}, extracting twin slots ...`); const { arr, n } = slotList(x); console.log(`# [${el()}s] x=${x}: ${n} twin slots in [0,${YTOP.toExponential(4)})`); const r = curve(x, arr, n); if (r) report(r); done++; if (done === checkpoints.length) break; } console.log('\n\n#### SUMMARY ####'); console.log('x\tk\tmbar\tM=ms1\tR(1)\tR(1)/lnx\tRmin\tmMin\tR(mtgt)\tCgate\tblkObs\tblk9\tnChain\treach\tspend/earn\t(a)/(b)\tLbnd'); for (const r of results) { console.log(`${r.x}\t${r.k.toFixed(2)}\t${r.mbar.toFixed(1)}\t${r.M}\t${r.R1.toFixed(2)}\t` + `${(r.R1 / Math.log(r.x)).toFixed(3)}\t\t${r.Rmin.toFixed(3)}\t${r.mMin}\t${r.Rtarget.toFixed(3)}\t` + `${r.gateC.toFixed(1)}\t${r.mBlockObs}\t${r.mBlock9}\t${r.nChain}\t${r.reach}\t${(r.spend / r.earn).toFixed(1)}\t\t${r.worstAB.toFixed(4)}\t${r.Lbound}`); } console.log(`# total ${el()}s`); // =========================================================================== // REAL OUTPUT // --------------------------------------------------------------------------- // RE-VERIFIED 2026-08-18, closing a three-wave gap. This file had not been // executed since it was written, and three corrections applied elsewhere on // 2026-08-18 were checked against the block below rather than against a run. // A fresh run of the DEFAULT ladder (Y=1e9, checkpoints 61/127/251/499/997) // reproduces the x=997 block below to every digit: D(Y)=8775234, mbar=113.96, // ratio 0.996, M=2052, R(1)=18.007, M/x^2=2.064e-3, sd=101.61, // sd/mean=0.8917, lnD=15.99. The only difference is MCAP, which is a // command-line argument (192 by default, 1024 in the recorded invocation) and // not a computed value. // NOTE FOR ANYONE COMPARING: this script is ARGUMENT-DRIVEN, and the two // blocks below record specific invocations. A bare `node localized-04-...js` // runs a DIFFERENT configuration and will appear not to match. The adjudicator // made exactly that mistake before reading the header. // =========================================================================== // // --- CUSTODY. node research/localized-04-maxsum.js 28934443 307 256 -------- // Reproduces research/localized-01-ladder.js at the top of its k=3 ladder, by a // different engine (bitset + word-parallel extraction instead of a per-integer // scan). localized-01 reported M=870, mbar=79.3, M/x^2=0.00923, M/mbar=10.97. // // ================ x = 307 k = lnY/lnx = 3.00 ================ // # D(Y)=364749 mbar=Y/D=79.33 vs 2.4 ln^2 x = 78.71 (ratio 1.008) // # M(x,Y)=maxsum_1=870 M/mbar=R(1)=10.967 M/x^2=9.231e-3 // // --- GROWTH LAW. node research/localized-04-maxsum.js 1e9 997,16001 1024 16000 // // ================ x = 997 k = lnY/lnx = 3.00 ================ // # D(Y)=8775234 mbar=Y/D=113.96 vs 2.4 ln^2 x = 114.42 (ratio 0.996) // # M(x,Y)=maxsum_1=2052 M/mbar=R(1)=18.007 M/x^2=2.064e-3 // # chain m-range: x/ln^2x = 21, x/(9.6 ln^2x) = 2; MCAP = 1024 // # gap stats below Y: mean=113.96 sd=101.61 sd/mean=0.8917 lnD=15.99 // m maxsum_m R=ms/(m*mbar) R_EVmodel R/R_EV #win>=1.5mean #win>=2mean argmax slot // 1 2052 18.0068 6.0421 2.9802 1909342 1068872 397901849 // 2 2220 9.7405 4.5653 2.1336 1657711 636700 397901681 // 3 2520 7.3712 3.9111 1.8847 1305938 378743 397901849 // 4 2688 5.8970 3.5211 1.6748 1097844 231072 397901681 // 5 2778 4.8755 3.2549 1.4979 909256 138251 397901681 // 6 2820 4.1244 3.0584 1.3485 761439 82237 397901549 // 7 2910 3.6480 2.9057 1.2554 639790 49140 397901549 // 8 3072 3.3697 2.7827 1.2110 532190 29743 397901297 // 9 3162 3.0830 2.6807 1.1501 436150 18180 397901297 // 10 3480 3.0538 2.5945 1.1770 372898 11153 397900889 // 11 3570 2.8480 2.5203 1.1300 304217 6773 184968731 // 12 3780 2.7642 2.4555 1.1257 263119 3820 184968521 // 16 4242 2.3265 2.2605 1.0292 124800 520 489992357 // 20 5076 2.2272 2.1275 1.0469 64824 88 489992561 // 21 5280 2.2063 2.1003 1.0505 52834 53 489992357 // 24 5700 2.0841 2.0292 1.0271 33243 15 1203929 // 32 6888 1.8889 1.8913 0.9987 8779 0 341018369 // 48 9426 1.7232 1.7278 0.9974 730 0 681396071 // 64 11880 1.6289 1.6303 0.9992 135 0 802181 // 96 16620 1.5192 1.5146 1.0030 9 0 797591 // 128 21504 1.4742 1.4457 1.0198 0 0 1197407 // 192 30468 1.3925 1.3639 1.0210 0 0 1414319 // 256 39480 1.3533 1.3151 1.0290 0 0 1198607 // # EV model over m in [32, 1024]: R/R_EV in [0.981, 1.110]; R(1)/lnD = 1.126 // # R(m) monotone non-increasing in m: NO; min R = 1.2799 at m = 837 // # R(MCAP=1024) = 1.2841 // # C OBSERVED over m<=x/ln^2x: 18.007 (at m=1); R(1)/ln x = 2.608 // # C GATE (p-2)/(4 mbar) = 2.21 -> lemma hypothesis FAILS at m=1 // # block length measured: max{m : maxsum_m <= (p-2)/4} = 0 vs deficit-lemma // cap x/(4 mbar) = 2 vs sec7 heuristic x/(9.6 ln^2x) = 2 // # Deficit Lemma check: min_m R(m) = 1.2799 (must be >= 1) -> HOLDS // # boundary: worst ratio (a)/(b) = 1.0000, (a)/(c) = 1.0000 // # boundary: optimal window overshoots Y by at most 0 (at m=0); edge windows // (30 of them, start in [Y-4096,Y)) reach at most 80.19% of maxsum // # A5 Thm B: L <= 1 + max{m: maxsum_m >= 3p m} = 1 (p = 1009); // kappa(1)<=1, kappa(2)<=1, kappa(3)<=1, kappa(4)<=1, kappa(5)<=1, kappa(6)<=1 // # A9 tail transplanted to the head: predicts R(1) = (lnD+0.235)/1.2992 = 12.49 // against measured 18.01 (ratio 1.442); gaps >= 2p' observed: 1, A9 expects 1.13e-3 // # CHAIN SURVIVAL from base x=997: valid through 0 fold(s), reaching level 997; // stopped because hypothesis maxsum_1=2052 > (q-2)/4 = 251.8 at q=1009 // # per fold, chain SPENDS d(maxsum)/dm = 156.00 against gate EARNS // d(q/4)/dm = 1.844 -> ratio 84.6 (predicted ~14.4 ln x = 99.4) // // ================ x = 16001 k = lnY/lnx = 2.14 ================ // # D(Y)=3825712 mbar=Y/D=261.39 M(x,Y)=3804 R(1)=14.553 M/x^2=1.486e-5 // # gap stats below Y: mean=261.38 sd=248.05 sd/mean=0.9490 lnD=15.16 // # EV model over m in [31, 1024]: R/R_EV in [0.990, 1.064]; R(1)/lnD = 0.960 // # min R = 1.1868 at m = 1023 // # C GATE (p-2)/(4 mbar) = 15.31 -> lemma hypothesis HOLDS at m=1 // # block length measured: max{m : maxsum_m <= (p-2)/4} = 1 vs deficit-lemma // cap x/(4 mbar) = 15 vs sec7 heuristic x/(9.6 ln^2x) = 18 // # boundary: worst ratio (a)/(b) = 1.0000, (a)/(c) = 1.0000 // # A5 Thm B: L <= 1 ... kappa(1..6) <= 1 (p = 16007) // # CHAIN SURVIVAL from base x=16001: valid through 1 fold(s), reaching level // 16007; stopped because maxsum_2=4782 > (q-2)/4 = 4007.8 at q=16033 // # per fold, chain SPENDS 387.75 against gate EARNS 2.484 -> ratio 156.1 // // --- GATE SCAN. node research/localized-04-maxsum.js 1e9 scan 8 16000 (18 s) // // x k mbar M R(1) R(1)/lnx Rmin Cgate blkObs nChain reach (a)/(b) Lbnd // 661 3.19 102.3 1290 12.61 1.941 3.467 1.6 0 0 661 1.0000 1 // 1009 3.00 114.2 2052 17.97 2.598 3.363 2.2 0 0 1009 1.0000 1 // 1531 2.83 128.5 2220 17.28 2.356 3.246 3.0 0 0 1531 1.0000 1 // 2311 2.68 144.7 2220 15.35 1.981 3.624 4.0 0 0 2311 1.0000 1 // 3499 2.54 163.4 2430 14.87 1.823 3.599 5.4 0 0 3499 1.0000 1 // 5297 2.42 185.8 2430 13.08 1.525 3.713 7.1 0 0 5297 1.0000 1 // 8017 2.31 212.0 2832 13.36 1.486 3.860 9.5 0 0 8017 1.0000 1 // 10567 2.24 231.4 3072 13.28 1.433 3.598 11.4 0 0 10567 1.0000 1 // 12143 2.20 241.1 3474 14.41 1.532 3.919 12.6 0 0 12143 1.0000 1 // 13933 2.17 251.5 3474 13.81 1.448 3.757 13.9 1 1 13963 1.0000 1 // 16001 2.14 261.4 3804 14.55 1.503 3.776 15.3 1 1 16007 1.0000 1 // (rows for x = 769, 877, 1163, 1327, 1753, 2011, 2657, 3049, 4019, 4621, 6079, // 6983, 9209 elided for width; all have blkObs = nChain = 0 and (a)/(b) = 1.0000) // // --- Y DEPENDENCE. 1e7 scan (0.3 s) and 1e8 scan (1.9 s), R(1) columns: // Y=1e7, x = 89 .. 2153: R(1) range 9.00 to 11.92, R(1)/lnD in [0.756, 1.053] // Y=1e8, x = 283 .. 6803: R(1) range 10.22 to 13.75, R(1)/lnD in [0.736, 1.038] // Y=1e9, x = 661 ..16001: R(1) range 12.61 to 18.65, R(1)/lnD in [0.783, 1.170] // // =========================================================================== // READINGS // =========================================================================== // // 1. VERIFIED (custody). This engine reproduces localized-01-ladder.js at // x = 307, k = 3: M = 870, mbar = 79.33, M/x^2 = 9.231e-3, M/mbar = 10.967. // Digit for digit, by a different sieve. // // 2. MEASURED (the growth law, and it is the answer to the question asked). // maxsum_m = m*mbar + sigma*sqrt(2*m*lnD), i.e. // R(m) = 1 + (sigma/mbar)*sqrt(2*lnD/m), // with sigma/mbar = 0.892 (x=997), 0.920 (x=3499), 0.949 (x=16001) and // D = #twin slots below Y. The model is NOT fitted: sigma, mbar and D are // all measured independently. Over m >= 2*lnD it holds to R/R_EV in // [0.981, 1.110], [1.038, 1.119], [0.990, 1.064] at those three x. // // 3. REFUTED (the prediction on record, in its mechanism). R(m) does not drift // upward with m. It falls, from ~15 at m=1 to ~1.2 at m=1024, monotonically // except for noise, and it converges to 1 rather than to a constant C > 1. // There is no turnover and no plateau, so there is no "value of C" to report // as a plateau; sup_m R(m) is always attained at m = 1. // // 4. MEASURED (the two regimes). Below m ~ 2*lnD ~ 32 the curve is ONE TAIL // EVENT: at x = 997 the argmax window for every m from 1 to 10 lies in slots // 397,900,889 to 397,901,849, a single sparse patch. Above it the argmax // migrates and the curve is bulk sqrt(m) concentration. So the answer to // "drift, turnover, or tail event" is: tail event, then drift, joined at // m ~ 2 lnD. // // 5. MEASURED (R(1) is a window property, not a level property). R(1)/lnD // measures [0.756, 1.053] at Y=1e7 over x = 89..2153, [0.736, 1.038] at // Y=1e8 over x = 283..6803, and [0.783, 1.170] at Y=1e9 over x = 661..16001. // Three decades of Y, a factor 24 in x each, no trend in x. // R(1)/ln x, by contrast, falls // 2.61 -> 1.45 across the Y = 1e9 scan. So M(x,Y) ~ mbar * ln(Y/mbar), i.e. // M ~ 2.4 ln^2(x) * ln(Y). This is LOCALIZED-GAP.md sec 5's "M/(k ln^3 x) // flat in 1.2 to 1.6" with the k dependence made explicit. // // 6. VERIFIED (the gate). The Localized Merge Lemma's own hypothesis // M(T_x,Y) <= (p-2)/4 first holds at x = 13933 in the window Y = 1e9 // (k = 2.17). R(1) is flat at ~lnD and the gate grows like x/(9.6 ln^2 x), // so the crossing solves x* = 9.6 ln^2(x*) ln(Y/mbar), giving x* = 13630 // against the measured 13933, 2% out. At k = 3 the same equation gives // x* ~ 2.4e4, Y = x*^3 ~ 1.4e13: NOT reachable, by four decades. // // 7. CORRECTION to LOCALIZED-GAP.md sec 4. Its "condition first satisfied at // x = 1453" is the conclusion-side condition M(T_p,Y) < p-2, which is what // localized-03-merge-lemma.js line 74 tests (`const on = M_new < p - 2`). // It is 4x weaker than sec 3's hypothesis M(T_x,Y) <= (p-2)/4 and is // evaluated at the new level, so it cannot serve as a chain hypothesis. The // verification stands; the label is wrong. // // 8. PROVEN (Deficit Lemma). maxsum_m >= m*mbar*(1 - O(m/D)), by averaging: // summing s_{i+m}-s_i over i counts each interior gap exactly m times. // VERIFIED: min_m R(m) = 1.187, 1.280, 1.296 at x = 16001, 997, 3499. // Never below 1. // // 9. PROVEN (Traverse Bound, and this is what kills the chain). Telescoping // needs maxsum_j <= alpha*q_{j+1} at every fold j, alpha = 1/4. Reading 8 // forces j <= alpha*x/mbar ~ x/(9.6 ln^2 x), FOR ANY C, even C = 1. So the // telescope moves the level from x to x*(1 + 1/(9.6 ln x)) and no further. // LOCALIZED-GAP.md sec 6 prices the route at pi(x) ~ x/ln x folds, so the // cap is short by a factor 9.6 ln x, which is 93 at x = 16001. No sieve // theory enters; the u = 1 wall the prediction names is never reached. // // 10. REFUTED (LOCALIZED-GAP.md sec 7's block composition). Its geometric // series over ~6.7 ln x blocks ends at M ~ 3.3 x ln x while every block // requires M <= x/4 at its start. The blocks do not compose: M is // cumulative and the gate earns only (q_{j+1}-q_j)/4 ~ ln x/4 per fold // against a spend of at least mbar ~ 2.4 ln^2 x. MEASURED spend/earn: // 70.0 (x=499), 84.6 (997), 108.9 (3499), 156.1 (16001), growing like ln x. // // 11. VERIFIED (chain survival, end to end). Applying the lemma fold by fold // with the hypothesis checked against the running proven bound: 0 folds for // every x <= 12143 at Y = 1e9, and exactly 1 fold at x = 13933 and 16001. // It dies at m = 2 (maxsum_2 = 4782 against a gate of 4007.8 at x = 16001), // well short even of the Deficit Lemma's own ceiling of 15 to 18 folds. // Measured shortfall at x = 16001: 1 fold against pi(16001) = 1863. // // 12. MEASURED (A5, and it AGREES). Theorem C transplanted to the head gives // kappa(m) = 1 for all m <= 6 at every x >= 997, and Theorem B gives L <= 1 // from x = 211 (Y=1e7) / 331 (1e8) / 499 (1e9). So A5 reaches "one index // per fold" independently of Fact A + Fact B. What localization buys is not // a better argument but a moved ceiling: U-FRAME sec 11's structural floor // G2/(3p) ~ 0.18x becomes M(x,Y)/(3p) ~ 0.8 ln^2 x lnY / x, which drops // below 1 at x ~ 700 when Y = 1e9. A10's "safe band 2p/mbar >= 4" is // reached at x ~ 700 here instead of at a tile of width 1e57. // // 13. MEASURED (A9, and it DEPARTS by ~20%). U-FRAME sec 11's FIT // ln(1/tail) = -0.235 + 1.2992*(g/mbar), pushed through extreme value over D // gaps, predicts R(1) = (lnD+0.235)/1.2992 ~ 12.0 to 12.6 across the whole // Y = 1e9 scan. Measured R(1) is 12.6 to 18.7, ratio 1.00 to 1.50, mean // ~1.23. The head's tail rate is ~1.06/mbar, not 1.2992/mbar. Far-tail // corroboration: A9 predicts 1.1e-3 gaps of length >= 2p' below Y at // x = 997 and there is exactly one (M = 2052 vs 2p' = 2018); likewise one // each at x = 769 and 877 against 7.5e-2 and 1.1e-2. Do not extrapolate the // A9 fit past its fitted range. // (LEVEL CORRECTED 2026-08-18: this read "x = 1009". 2p' = 2018 forces // p' = 1009 and so x = 997; at x = 1009 the next prime is 1013 and // 2p' = 2026. M = 2052 clears both, so the count of one is unaffected.) // // 14. VERIFIED (the boundary caveat is empty). Rule (a) left endpoint < Y, // rule (b) whole window < Y, rule (c) list truncated at Y+4096, computed in // the same pass: (a)/(b) = 1.0000 and (a)/(c) = 1.0000 at every x, every // m <= 1024, at Y = 1e7, 1e8, 1e9. The optimal window overshoots Y by 0 in // every case and edge windows reach at most 76% to 83% of maxsum. // LOCALIZED-GAP.md sec 3's caveat is a hygiene issue, not a numerical one. // // 15. PROVEN (no fixed point, which kills the obvious repair). Weakening the // gate to M <= alpha*p for larger alpha does not help, because the gate feeds // back. If the chain proves M(T_x,Y) <= B(x), Fact B allows B(x)/(p-2)+1 ~ // B(x)/x kills per new gap, so the index cost per fold is B(x)/x, the // telescope index over pi(x) folds is J ~ B(x)/ln x, and the bound returned // is maxsum_J ~ 2.4*R*B(x)*ln x. Self-consistency needs ln x <= 1/(2.4 R). // The map B -> 2.4 R B ln x is EXPANDING for every x >= 2, at rate ~3.2 ln x // per round. The obstruction is not the size of the gate; it is that the // gate multiplies. // // 16. REFUTED (the increment repair). Bounding M(T_p,Y) - M(T_x,Y) instead of // M(T_p,Y) is also closed: localized-01 measured a mean increment of 14.16 at // x = 307 against a gate earning ln(x)/4 = 1.43 per fold. Even the TRUE // increments outrun the gate by an order of magnitude, so a perfect increment // bound would still not close the chain. // ============================================================================ // OUTPUT — EMBEDDED, do not hand-edit. Regenerate: // node research/qc/embed.js research/localized-04-maxsum.js // invocation: node research/localized-04-maxsum.js // code-sha256: f1c35d8c199a0338a81e556efc2177b2b50a488993132eea0e9ac512bfbc5724 // out-sha256: e8297e325f7b03b082ceb72dcb54895223cf9dfdee02ccfd37d24db62942c131 // body-lines: 235 // streams: stdout // node: v22.21.0 // embedded: 2026-08-29 // elapsed: 59.8 s // ============================================================================ // # localized-04-maxsum Y=1.000e+9 BUF=5000000 YTOP=1.0050e+9 // # ladder to x=4999 checkpoints: 61, 127, 251, 499, 997 // # k = lnY/lnx at each checkpoint: 5.04, 4.28, 3.75, 3.34, 3.00 // // # [3.2s] folded to x=61, extracting twin slots ... // # [3.4s] x=61: 23045499 twin slots in [0,1.0050e+9) // // ================ x = 61 k = lnY/lnx = 5.04 ================ // # D(Y)=22930800 mbar=Y/D=43.61 vs 2.4 ln^2 x = 40.56 (ratio 1.075) // # M(x,Y)=maxsum_1=468 M/mbar=R(1)=10.732 M/x^2=1.258e-1 // # chain m-range: x/ln^2x = 4, x/(9.6 ln^2x) = 1; MCAP = 192 // # gap stats below Y: mean=43.61 sd=34.14 sd/mean=0.7828 lnD=16.95 [EV model: R(1)~lnD=16.9, R(m)~1+(sd/mean)sqrt(2lnD/m)] // m maxsum_m R=ms/(m*mbar) R_EVmodel R/R_EV strict(b) buf4096(c) #win>=1.5mean #win>=2mean argmax slot // 1 468 10.7316 5.5576 1.9310 468 468 4997179 2537787 522354179 // 2 570 6.5353 4.2227 1.5477 570 570 4163268 1182196 431852459 // 3 636 4.8613 3.6313 1.3387 636 636 2906203 454734 670554551 // 4 672 3.8524 3.2788 1.1749 672 672 1877918 229008 247700069 // 5 762 3.4947 3.0382 1.1502 762 762 1693255 92845 951691799 // 6 828 3.1645 2.8606 1.1062 828 828 1079200 45979 533106599 // 7 918 3.0072 2.7226 1.1045 918 918 817726 20399 790415699 // 8 966 2.7689 2.6114 1.0603 966 966 634807 7576 404661821 // 9 1014 2.5835 2.5192 1.0255 1014 1014 446050 3369 731961317 // 10 1050 2.4077 2.4412 0.9863 1050 1050 334874 1027 539268209 // 11 1110 2.3139 2.3742 0.9746 1110 1110 267144 559 39223937 // 12 1164 2.2243 2.3157 0.9605 1164 1164 191449 173 533106527 // 16 1380 1.9778 2.1394 0.9245 1380 1380 50613 0 904388411 // 20 1692 1.9399 2.0191 0.9608 1692 1692 8644 0 904388099 // 24 1914 1.8287 1.9303 0.9474 1914 1914 2330 0 904388057 // 32 2286 1.6381 1.8057 0.9072 2286 2286 192 0 988753121 // 48 3024 1.4446 1.6578 0.8714 3024 3024 0 0 401085317 // 64 3876 1.3887 1.5697 0.8847 3876 3876 0 0 981332771 // 96 5274 1.2598 1.4652 0.8598 5274 5274 0 0 981332687 // 128 6768 1.2125 1.4028 0.8643 6768 6768 0 0 952529351 // 192 9840 1.1752 1.3289 0.8843 9840 9840 0 0 17378987 // # EV model over m in [34, 192]: R/R_EV in [0.860, 0.911]; R(1)/lnD = 0.633 // # R(m) monotone non-increasing in m: NO; min R = 1.1752 at m = 192 // # R(MCAP=192) = 1.1752 // # C OBSERVED over m<=x/ln^2x: 10.732 (at m=1); R(1)/ln x = 2.611 // # C GATE (p-2)/(4 mbar) = 0.37 -> lemma hypothesis FAILS at m=1 // # block length measured: max{m : maxsum_m <= (p-2)/4} = 0 vs deficit-lemma cap x/(4 mbar) = 0 vs sec7 heuristic x/(9.6 ln^2x) = 1 // # Deficit Lemma check: min_m R(m) = 1.1752 (must be >= 1) -> HOLDS // # boundary: worst ratio (a)/(b) = 1.0000, (a)/(c) = 1.0000 // # boundary: optimal window overshoots Y by at most 0 (at m=0); edge windows (88 of them, start in [Y-4096,Y)) reach at most 91.81% of maxsum (worst at m=144) // # A5 Thm B: L <= 1 + max{m: maxsum_m >= 3p m} = 4 (p = 67); kappa(1)<=4, kappa(2)<=4, kappa(3)<=5, kappa(4)<=5, kappa(5)<=6, kappa(6)<=6 // # A9 tail transplanted to the head: predicts R(1) = (lnD+0.235)/1.2992 = 13.23 against measured 10.73 (ratio 0.811); gaps >= 2p' observed: 595903, A9 expects 5.35e+5 // # CHAIN SURVIVAL from base x=61: valid through 0 fold(s), reaching level 61; stopped because hypothesis maxsum_1=468 > (q-2)/4 = 16.3 at q=67 // # per fold, chain SPENDS d(maxsum)/dm = 49.69 against gate EARNS d(q/4)/dm = 1.500 -> ratio 33.1 (predicted ~14.4 ln x = 59.2) // // # [25.6s] folded to x=127, extracting twin slots ... // # [25.9s] x=127: 17226455 twin slots in [0,1.0050e+9) // // ================ x = 127 k = lnY/lnx = 4.28 ================ // # D(Y)=17140745 mbar=Y/D=58.34 vs 2.4 ln^2 x = 56.32 (ratio 1.036) // # M(x,Y)=maxsum_1=720 M/mbar=R(1)=12.341 M/x^2=4.464e-2 // # chain m-range: x/ln^2x = 5, x/(9.6 ln^2x) = 1; MCAP = 192 // # gap stats below Y: mean=58.34 sd=48.02 sd/mean=0.8231 lnD=16.66 [EV model: R(1)~lnD=16.7, R(m)~1+(sd/mean)sqrt(2lnD/m)] // m maxsum_m R=ms/(m*mbar) R_EVmodel R/R_EV strict(b) buf4096(c) #win>=1.5mean #win>=2mean argmax slot // 1 720 12.3413 5.7507 2.1461 720 720 3741056 2079703 136875377 // 2 828 7.0963 4.3593 1.6279 828 828 2977897 970777 492127451 // 3 900 5.1422 3.7428 1.3739 900 900 2173455 516244 143152991 // 4 1038 4.4480 3.3754 1.3178 1038 1038 1773313 244338 143152991 // 5 1122 3.8464 3.1246 1.2310 1122 1122 1376629 136905 362429657 // 6 1242 3.5481 2.9395 1.2071 1242 1242 1113284 69832 244235027 // 7 1332 3.2616 2.7956 1.1667 1332 1332 844595 33602 244235027 // 8 1374 2.9439 2.6796 1.0986 1374 1374 683304 16509 244235027 // 9 1440 2.7425 2.5836 1.0615 1440 1440 539046 7532 750140399 // 10 1542 2.6431 2.5023 1.0563 1542 1542 405045 4196 492703919 // 11 1650 2.5711 2.4324 1.0570 1650 1650 318947 1804 666590711 // 12 1716 2.4511 2.3714 1.0336 1716 1716 232291 829 666590711 // 16 1992 2.1340 2.1877 0.9755 1992 1992 86146 48 492704237 // 20 2376 2.0363 2.0623 0.9874 2376 2376 30310 1 999585581 // 24 2616 1.8683 1.9697 0.9485 2616 2616 9505 0 502375691 // 32 3204 1.7162 1.8398 0.9328 3204 3204 1376 0 315768977 // 48 4290 1.5320 1.6857 0.9088 4290 4290 10 0 54328739 // 64 5388 1.4430 1.5938 0.9054 5388 5388 0 0 149866571 // 96 7470 1.3338 1.4849 0.8982 7470 7470 0 0 498333851 // 128 9600 1.2856 1.4199 0.9054 9600 9600 0 0 7559 // 192 13752 1.2277 1.3429 0.9143 13752 13752 0 0 12917 // # EV model over m in [34, 192]: R/R_EV in [0.892, 0.933]; R(1)/lnD = 0.741 // # R(m) monotone non-increasing in m: NO; min R = 1.2219 at m = 185 // # R(MCAP=192) = 1.2277 // # C OBSERVED over m<=x/ln^2x: 12.341 (at m=1); R(1)/ln x = 2.548 // # C GATE (p-2)/(4 mbar) = 0.55 -> lemma hypothesis FAILS at m=1 // # block length measured: max{m : maxsum_m <= (p-2)/4} = 0 vs deficit-lemma cap x/(4 mbar) = 0 vs sec7 heuristic x/(9.6 ln^2x) = 1 // # Deficit Lemma check: min_m R(m) = 1.2219 (must be >= 1) -> HOLDS // # boundary: worst ratio (a)/(b) = 1.0000, (a)/(c) = 1.0000 // # boundary: optimal window overshoots Y by at most 0 (at m=0); edge windows (67 of them, start in [Y-4096,Y)) reach at most 91.19% of maxsum (worst at m=174) // # A5 Thm B: L <= 1 + max{m: maxsum_m >= 3p m} = 3 (p = 131); kappa(1)<=3, kappa(2)<=3, kappa(3)<=3, kappa(4)<=4, kappa(5)<=4, kappa(6)<=4 // # A9 tail transplanted to the head: predicts R(1) = (lnD+0.235)/1.2992 = 13.00 against measured 12.34 (ratio 0.949); gaps >= 2p' observed: 58935, A9 expects 6.34e+4 // # CHAIN SURVIVAL from base x=127: valid through 0 fold(s), reaching level 127; stopped because hypothesis maxsum_1=720 > (q-2)/4 = 32.3 at q=131 // # per fold, chain SPENDS d(maxsum)/dm = 68.25 against gate EARNS d(q/4)/dm = 1.500 -> ratio 45.5 (predicted ~14.4 ln x = 69.8) // // # [37.9s] folded to x=251, extracting twin slots ... // # [38.1s] x=251: 13357443 twin slots in [0,1.0050e+9) // // ================ x = 251 k = lnY/lnx = 3.75 ================ // # D(Y)=13290913 mbar=Y/D=75.24 vs 2.4 ln^2 x = 73.27 (ratio 1.027) // # M(x,Y)=maxsum_1=990 M/mbar=R(1)=13.158 M/x^2=1.571e-2 // # chain m-range: x/ln^2x = 8, x/(9.6 ln^2x) = 1; MCAP = 192 // # gap stats below Y: mean=75.24 sd=64.13 sd/mean=0.8524 lnD=16.40 [EV model: R(1)~lnD=16.4, R(m)~1+(sd/mean)sqrt(2lnD/m)] // m maxsum_m R=ms/(m*mbar) R_EVmodel R/R_EV strict(b) buf4096(c) #win>=1.5mean #win>=2mean argmax slot // 1 990 13.1580 5.8822 2.2369 990 990 2946846 1531138 428120087 // 2 1182 7.8549 4.4522 1.7643 1182 1182 2251476 829450 428120087 // 3 1248 5.5290 3.8187 1.4479 1248 1248 1898757 443662 428119829 // 4 1440 4.7847 3.4411 1.3905 1440 1440 1429323 251542 428119829 // 5 1482 3.9394 3.1834 1.2375 1482 1482 1237213 143861 428119829 // 6 1758 3.8942 2.9931 1.3011 1758 1758 971206 75212 600149819 // 7 1878 3.5658 2.8453 1.2532 1878 1878 825520 41545 600149699 // 8 1968 3.2696 2.7261 1.1993 1968 1968 618709 23789 600149609 // 9 2088 3.0835 2.6274 1.1736 2088 2088 526377 11960 702474131 // 10 2208 2.9346 2.5439 1.1536 2208 2208 398860 6383 702474011 // 11 2298 2.7766 2.4720 1.1232 2298 2298 346932 3489 702473921 // 12 2418 2.6781 2.4094 1.1115 2418 2418 263298 1998 702473801 // 16 2658 2.2080 2.2205 0.9943 2658 2658 114699 156 600148919 // 20 3060 2.0335 2.0917 0.9722 3060 3060 47820 6 109583099 // 24 3498 1.9372 1.9966 0.9702 3498 3498 19528 0 59471 // 32 4284 1.7793 1.8631 0.9551 4284 4284 3307 0 722732837 // 48 5778 1.5999 1.7047 0.9385 5778 5778 82 0 59669 // 64 7278 1.5114 1.6103 0.9386 7278 7278 3 0 59471 // 96 10368 1.4354 1.4983 0.9580 10368 10368 0 0 58451 // 128 13182 1.3688 1.4315 0.9561 13182 13182 0 0 51479 // 192 19308 1.3366 1.3523 0.9883 19308 19308 0 0 59471 // # EV model over m in [33, 192]: R/R_EV in [0.913, 0.989]; R(1)/lnD = 0.802 // # R(m) monotone non-increasing in m: NO; min R = 1.3366 at m = 192 // # R(MCAP=192) = 1.3366 // # C OBSERVED over m<=x/ln^2x: 13.158 (at m=1); R(1)/ln x = 2.381 // # C GATE (p-2)/(4 mbar) = 0.85 -> lemma hypothesis FAILS at m=1 // # block length measured: max{m : maxsum_m <= (p-2)/4} = 0 vs deficit-lemma cap x/(4 mbar) = 0 vs sec7 heuristic x/(9.6 ln^2x) = 1 // # Deficit Lemma check: min_m R(m) = 1.3366 (must be >= 1) -> HOLDS // # boundary: worst ratio (a)/(b) = 1.0000, (a)/(c) = 1.0000 // # boundary: optimal window overshoots Y by at most 0 (at m=0); edge windows (50 of them, start in [Y-4096,Y)) reach at most 81.53% of maxsum (worst at m=147) // # A5 Thm B: L <= 1 + max{m: maxsum_m >= 3p m} = 2 (p = 257); kappa(1)<=2, kappa(2)<=2, kappa(3)<=2, kappa(4)<=2, kappa(5)<=3, kappa(6)<=3 // # A9 tail transplanted to the head: predicts R(1) = (lnD+0.235)/1.2992 = 12.81 against measured 13.16 (ratio 1.027); gaps >= 2p' observed: 2929, A9 expects 2.35e+3 // # CHAIN SURVIVAL from base x=251: valid through 0 fold(s), reaching level 251; stopped because hypothesis maxsum_1=990 > (q-2)/4 = 63.8 at q=257 // # per fold, chain SPENDS d(maxsum)/dm = 93.56 against gate EARNS d(q/4)/dm = 1.594 -> ratio 58.7 (predicted ~14.4 ln x = 79.6) // // # [46.7s] folded to x=499, extracting twin slots ... // # [46.9s] x=499: 10686876 twin slots in [0,1.0050e+9) // // ================ x = 499 k = lnY/lnx = 3.34 ================ // # D(Y)=10633926 mbar=Y/D=94.04 vs 2.4 ln^2 x = 92.63 (ratio 1.015) // # M(x,Y)=maxsum_1=1266 M/mbar=R(1)=13.463 M/x^2=5.084e-3 // # chain m-range: x/ln^2x = 13, x/(9.6 ln^2x) = 1; MCAP = 192 // # gap stats below Y: mean=94.04 sd=82.24 sd/mean=0.8745 lnD=16.18 [EV model: R(1)~lnD=16.2, R(m)~1+(sd/mean)sqrt(2lnD/m)] // m maxsum_m R=ms/(m*mbar) R_EVmodel R/R_EV strict(b) buf4096(c) #win>=1.5mean #win>=2mean argmax slot // 1 1266 13.4626 5.9748 2.2532 1266 1266 2288913 1285020 365647991 // 2 1470 7.8159 4.5177 1.7301 1470 1470 1837253 776586 594790487 // 3 1752 6.2102 3.8722 1.6038 1752 1752 1493402 432166 702474467 // 4 1920 5.1043 3.4874 1.4636 1920 1920 1296460 245275 523427477 // 5 2352 5.0022 3.2248 1.5512 2352 2352 1031213 142725 898313327 // 6 2490 4.4131 3.0310 1.4560 2490 2490 851899 78898 898313189 // 7 2598 3.9467 2.8803 1.3702 2598 2598 734388 46427 898313081 // 8 2838 3.7724 2.7589 1.3674 2838 2838 565112 26165 898312841 // 9 3060 3.6155 2.6583 1.3601 3060 3060 479406 14577 898312619 // 10 3108 3.3050 2.5732 1.2844 3108 3108 391259 8710 898312619 // 11 3270 3.1612 2.5000 1.2645 3270 3270 324670 5381 898312409 // 12 3318 2.9403 2.4361 1.2070 3318 3318 258216 3041 898312409 // 13 3402 2.7828 2.3798 1.1694 3402 3402 225394 1756 898312277 // 16 3930 2.6120 2.2437 1.1641 3930 3930 126173 370 898311749 // 20 4386 2.3320 2.1124 1.1040 4386 4386 56517 59 898311551 // 24 4662 2.0656 2.0155 1.0249 4662 4662 27764 12 211889 // 32 5538 1.8403 1.8794 0.9792 5538 5538 5990 0 489992099 // 48 7536 1.6695 1.7181 0.9718 7536 7536 346 0 681396491 // 64 9528 1.5831 1.6219 0.9761 9528 9528 28 0 681395969 // 96 13080 1.4489 1.5077 0.9610 13080 13080 0 0 248891 // 128 16800 1.3957 1.4397 0.9694 16800 16800 0 0 248291 // 192 24960 1.3824 1.3590 1.0172 24960 24960 0 0 237089 // # EV model over m in [33, 192]: R/R_EV in [0.949, 1.020]; R(1)/lnD = 0.832 // # R(m) monotone non-increasing in m: NO; min R = 1.3644 at m = 164 // # R(MCAP=192) = 1.3824 // # C OBSERVED over m<=x/ln^2x: 13.463 (at m=1); R(1)/ln x = 2.167 // # C GATE (p-2)/(4 mbar) = 1.33 -> lemma hypothesis FAILS at m=1 // # block length measured: max{m : maxsum_m <= (p-2)/4} = 0 vs deficit-lemma cap x/(4 mbar) = 1 vs sec7 heuristic x/(9.6 ln^2x) = 1 // # Deficit Lemma check: min_m R(m) = 1.3644 (must be >= 1) -> HOLDS // # boundary: worst ratio (a)/(b) = 1.0000, (a)/(c) = 1.0000 // # boundary: optimal window overshoots Y by at most 0 (at m=0); edge windows (37 of them, start in [Y-4096,Y)) reach at most 76.34% of maxsum (worst at m=157) // # A5 Thm B: L <= 1 + max{m: maxsum_m >= 3p m} = 1 (p = 503); kappa(1)<=1, kappa(2)<=1, kappa(3)<=2, kappa(4)<=2, kappa(5)<=2, kappa(6)<=2 // # A9 tail transplanted to the head: predicts R(1) = (lnD+0.235)/1.2992 = 12.63 against measured 13.46 (ratio 1.066); gaps >= 2p' observed: 25, A9 expects 1.24e+1 // # CHAIN SURVIVAL from base x=499: valid through 0 fold(s), reaching level 499; stopped because hypothesis maxsum_1=1266 > (q-2)/4 = 125.3 at q=503 // # per fold, chain SPENDS d(maxsum)/dm = 124.69 against gate EARNS d(q/4)/dm = 1.781 -> ratio 70.0 (predicted ~14.4 ln x = 89.5) // // # [53.9s] folded to x=997, extracting twin slots ... // # [54.0s] x=997: 8818946 twin slots in [0,1.0050e+9) // // ================ x = 997 k = lnY/lnx = 3.00 ================ // # D(Y)=8775234 mbar=Y/D=113.96 vs 2.4 ln^2 x = 114.42 (ratio 0.996) // # M(x,Y)=maxsum_1=2052 M/mbar=R(1)=18.007 M/x^2=2.064e-3 // # chain m-range: x/ln^2x = 21, x/(9.6 ln^2x) = 2; MCAP = 192 // # gap stats below Y: mean=113.96 sd=101.61 sd/mean=0.8917 lnD=15.99 [EV model: R(1)~lnD=16.0, R(m)~1+(sd/mean)sqrt(2lnD/m)] // m maxsum_m R=ms/(m*mbar) R_EVmodel R/R_EV strict(b) buf4096(c) #win>=1.5mean #win>=2mean argmax slot // 1 2052 18.0068 6.0421 2.9802 2052 2052 1909342 1068872 397901849 // 2 2220 9.7405 4.5653 2.1336 2220 2220 1657711 636700 397901681 // 3 2520 7.3712 3.9111 1.8847 2520 2520 1305938 378743 397901849 // 4 2688 5.8970 3.5211 1.6748 2688 2688 1097844 231072 397901681 // 5 2778 4.8755 3.2549 1.4979 2778 2778 909256 138251 397901681 // 6 2820 4.1244 3.0584 1.3485 2820 2820 761439 82237 397901549 // 7 2910 3.6480 2.9057 1.2554 2910 2910 639790 49140 397901549 // 8 3072 3.3697 2.7827 1.2110 3072 3072 532190 29743 397901297 // 9 3162 3.0830 2.6807 1.1501 3162 3162 436150 18180 397901297 // 10 3480 3.0538 2.5945 1.1770 3480 3480 372898 11153 397900889 // 11 3570 2.8480 2.5203 1.1300 3570 3570 304217 6773 184968731 // 12 3780 2.7642 2.4555 1.1257 3780 3780 263119 3820 184968521 // 16 4242 2.3265 2.2605 1.0292 4242 4242 124800 520 489992357 // 20 5076 2.2272 2.1275 1.0469 5076 5076 64824 88 489992561 // 21 5280 2.2063 2.1003 1.0505 5280 5280 52834 53 489992357 // 24 5700 2.0841 2.0292 1.0271 5700 5700 33243 15 1203929 // 32 6888 1.8889 1.8913 0.9987 6888 6888 8779 0 341018369 // 48 9426 1.7232 1.7278 0.9974 9426 9426 730 0 681396071 // 64 11880 1.6289 1.6303 0.9992 11880 11880 135 0 802181 // 96 16620 1.5192 1.5146 1.0030 16620 16620 9 0 797591 // 128 21504 1.4742 1.4457 1.0198 21504 21504 0 0 1197407 // 192 30468 1.3925 1.3639 1.0210 30468 30468 0 0 1414319 // # EV model over m in [32, 192]: R/R_EV in [0.981, 1.036]; R(1)/lnD = 1.126 // # R(m) monotone non-increasing in m: NO; min R = 1.3903 at m = 190 // # R(MCAP=192) = 1.3925 // # C OBSERVED over m<=x/ln^2x: 18.007 (at m=1); R(1)/ln x = 2.608 // # C GATE (p-2)/(4 mbar) = 2.21 -> lemma hypothesis FAILS at m=1 // # block length measured: max{m : maxsum_m <= (p-2)/4} = 0 vs deficit-lemma cap x/(4 mbar) = 2 vs sec7 heuristic x/(9.6 ln^2x) = 2 // # Deficit Lemma check: min_m R(m) = 1.3903 (must be >= 1) -> HOLDS // # boundary: worst ratio (a)/(b) = 1.0000, (a)/(c) = 1.0000 // # boundary: optimal window overshoots Y by at most 0 (at m=0); edge windows (30 of them, start in [Y-4096,Y)) reach at most 72.93% of maxsum (worst at m=188) // # A5 Thm B: L <= 1 + max{m: maxsum_m >= 3p m} = 1 (p = 1009); kappa(1)<=1, kappa(2)<=1, kappa(3)<=1, kappa(4)<=1, kappa(5)<=1, kappa(6)<=1 // # A9 tail transplanted to the head: predicts R(1) = (lnD+0.235)/1.2992 = 12.49 against measured 18.01 (ratio 1.442); gaps >= 2p' observed: 1, A9 expects 1.13e-3 // # CHAIN SURVIVAL from base x=997: valid through 0 fold(s), reaching level 997; stopped because hypothesis maxsum_1=2052 > (q-2)/4 = 251.8 at q=1009 // # per fold, chain SPENDS d(maxsum)/dm = 156.00 against gate EARNS d(q/4)/dm = 1.844 -> ratio 84.6 (predicted ~14.4 ln x = 99.4) // // // #### SUMMARY #### // x k mbar M=ms1 R(1) R(1)/lnx Rmin mMin R(mtgt) Cgate blkObs blk9 nChain reach spend/earn (a)/(b) Lbnd // 61 5.04 43.6 468 10.73 2.611 1.175 192 3.852 0.4 0 1 0 61 33.1 1.0000 4 // 127 4.28 58.3 720 12.34 2.548 1.222 185 3.846 0.6 0 1 0 127 45.5 1.0000 3 // 251 3.75 75.2 990 13.16 2.381 1.337 192 3.270 0.8 0 1 0 251 58.7 1.0000 2 // 499 3.34 94.0 1266 13.46 2.167 1.364 164 2.783 1.3 0 1 0 499 70.0 1.0000 1 // 997 3.00 114.0 2052 18.01 2.608 1.390 190 2.206 2.2 0 2 0 997 84.6 1.0000 1 // # total 59.7s // ============================================================================ // READINGS // ============================================================================