Job #21 (explore, measure lane): X_small in a rescaled exponent frame, Möbius signs against random-sign, permutation and absolute-value controls
Decision, disposition, and what the result bears on
Decision informed. Whether the actual Möbius/von Mangoldt right coefficient b_u = A_right(gu) of research/grouped-divisor-moment.md (13) shows cancellation in the small-common-divisor kernel X_small of (21) beyond sign-randomised or sign-permuted versions of itself, when X_small is not degenerate. This bears on whether a signed estimate of the D-type moment (obligation D, research/RESEARCH-EXECUTION.md §3; return #154) is plausible, and on nothing else. It does not estimate an exponent, does not establish or refute (21), and does not move the sufficient margin of research/RESEARCH-HANDOFF.md §3.
Why a new statistic. The prior census research/kernel-sign-control.md (verdict MEASURED, negative, x = 2^18..2^30) says its measurement was weak where it matters: X_small carried 0.02 to 2.88% of the moment, J0 = ⌊x^{1/20}⌋ was 1 or 2, and Z = 2 collapsed the prime-power sector of (13) to the single r = 2, so on the top box A_1 was literally −μ(ℓ/2)·log 2. The 2^38 censuses of D_y and the shifted-prime Möbius sums do not carry X_small at all (research/data-reuse-audit.md; research/centered-discrepancy-measurement.md). Here the three degeneracies are removed and the same question asked again.
Result: no support, at these scales, in all four coefficient families and against both nulls. The pre-registered falsifier F1 (the record's §0 slope rule: mean slope of log₂ ρ_k plus its sd ≥ 0 ⟹ no support) fires in every family; the per-scale rule F2 fires (the actual value sits inside the eight-draw spread at every scale); the permutation-null rule F3 fires. Against the absolute-value control the geometric ratio is 0.342: signs beat no signs by about 3×; Möbius signs do not beat random or permuted signs. Rung: measured; a finite reading; "not refuted at these scales" applies to the hypothesis of no advantage, and "no support" to the hypothesis of extra Möbius cancellation.
What it does not bear on. Visibility was bought by shortening the m-average that (21) relies on (M = ⌊x^{1/5}⌋ in place of ⌊x^{14/25}⌋), and Z = W = J0 = 9 is a constant, not x^{1/20}; the frame emulates the asymptotic proportions of the kernel (several gcd classes, live proper prime powers, a visible kernel share) and not its exponent structure. Negative control (iv) fires only in part for the same reason (below).
Statistic and frame
Same object as the record: b_u = A_right(gu) of (13) at s = 0; X_small of (21) computed by the exact divisor sieve; ρ_k(x) = |X_small(actual)| / |X_small(random draw k)|, k = 1..8, seeded draws (seed formula as in the served producer); plus a permutation null: 8 seeded permutations of the actual signs over the support with magnitudes fixed; plus the absolute-value control |b_u| as the upper reference.
Frame: the record's four families and dyadic points j = 18, 20, 22, 24, 26, with exactly two exponents rescaled: Z = W = J0 = 9 constant (record: max(2, ⌊x^{1/20}⌋) = 2) and M = ⌊x^{1/5}⌋ (record: ⌊x^{14/25}⌋); E = ⌊x^{9/20}⌋ and A = max(1, round(x^{3/50})) unchanged. Non-degeneracy is printed by the script, not assumed: live prime powers r ∈ {5, 7, 8, 9} on every top-box row with the proper powers 8 and 9 present; 2 to 44 values of u receiving more than one r-term; nine live gcd classes; X_small share 1.14 to 37.87% of the moment (null-median share 5.46 to 27.35%, median 13.68%) against the record's 0.02 to 2.88%.
Pre-registration (written before the run; prereg.md, UTC timestamp inside; sha256 bdc3da72df2963ee109b6075b51ec6ed68d19c9a2d2dc20c19c9c57171670109)
Decision as above. Expected distinction: under H0 (no Möbius advantage) the actual |X_small| ranks like one more draw, mean rank 5 of 9 with sd 0.58 over the 20 rows, and the slope of log₂ ρ_k is 0 within its sd; under H1 (extra cancellation) the actual value sits below the draws at every scale and the slope is negative beyond its sd. Falsifiers: F1 (slope rule, verbatim from the record's §0) over the points sharing one J0 (here all five); F2 (per scale, actual within the eight-draw spread ⟹ no per-scale advantage); F3 (F1 and F2 against the permutation null). Controls: eight seeded random-sign draws, eight seeded permutations, the absolute-value coefficient, and the record's four negative controls (complete periods detected; conjugation load-bearing; both endpoints shifted under reciprocity; all-ones coefficients reproduce the zero-frequency size), all required to fire. Pilot plan: j = 18, 20 first, 15 minutes cap; one adjustment permitted if the primary family's X_small share fell below 10%, to be re-registered with a second timestamp before the full run.
Adjustment made: registered as M = ⌊x^{1/4}⌋; the pilot found the primary family below the 10% share floor at j = 18, 20 (share, not any sign statistic, was consulted); the single permitted adjustment 1/4 → 1/5 was taken and re-registered with a second timestamp; both texts are kept in prereg.md.
Result
Primary family (top box, g = 2, A ~ x^{3/50}):
| j | X_small share | |X_small| actual | random median [min, max] | rank of 9 | permutation median [min, max] | rank of 9 | ρ_rnd | ρ_perm |
|---|---|---|---|---|---|---|---|---|
| 18 | 20.44% | 8.08 | 4.29 [0.90, 18.4] | 7 | 5.37 [0.91, 19.6] | 7 | 1.885 | 1.504 |
| 20 | 11.83% | 9.66 | 21.7 [8.9, 96.2] | 3 | 12.0 [2.9, 30.3] | 4 | 0.445 | 0.808 |
| 22 | 11.65% | 24.5 | 18.1 [1.3, 43.1] | 7 | 35.6 [4.3, 74.9] | 5 | 1.351 | 0.688 |
| 24 | 2.33% | 5.27 | 26.8 [7.4, 62.8] | 1 | 28.3 [7.9, 73.2] | 1 | 0.196 | 0.186 |
| 26 | 20.19% | 108 | 127 [29.4, 367] | 4 | 71.0 [5.9, 174] | 8 | 0.849 | 1.525 |
F1 slope (random null) −0.1288 ± 0.1877; F3 slope (permutation null) −0.0626 ± 0.1962: mean + sd ≥ 0 in both. Other three families: F1 +0.1010 ± 0.2126, +0.0291 ± 0.1692, +0.3060 ± 0.3152; F3 −0.0893 ± 0.1523, −0.0868 ± 0.2862, +0.3118 ± 0.1878. Aggregate over the 20 rows: mean rank of the actual value 4.80 (random) and 5.00 (permuted) against the null 5.00 ± 0.58; 11 and 10 of 20 rows below the null median. Against |b|: geometric ratio 0.342.
Verdict in the record's language: no support for extra Möbius-sign cancellation in X_small when X_small is non-degenerate, at x = 2^18 to 2^26, in all four families, against both nulls. The hypothesis "Möbius signs behave like random signs in the kernel" is not refuted at these scales. A finite ratio cannot establish or refute a power saving (the record's own caveat, kept).
Controls
(i) Complete periods detected: fired. (ii) Conjugation load-bearing: fired (the unconjugated sum has nonzero imaginary part). (iii) Both endpoints shifted under reciprocity: fired (native equals shifted-left kernel; the unshifted variant disagrees). Four identity checks agree with literal enumeration on all five quantities; both emptiness certificates hold in all 20 rows. (iv) fires only in part: the (5) count bound and the class majorant hold, and the equal-frequency class is the dominant class, but at M = 12 and 16 it is 1716% and 4713% of the all-ones moment rather than about 100%: the short m-average lets the all-ones off-diagonal cancel the diagonal. That is the frame's cost, the same fact that makes X_small visible, and it is reported rather than repaired.
Compute
Single thread (cap 8), peak RSS 125 MB (cap 16 GB); pilot 0.14 s + 0.95 s; bound run 0.5 s; embed.js --check re-run 0.5 s; under five seconds of the 60-minute allowance. No enumeration allocation touched; the retained 2^38 JSONs were not needed (they carry no kernel data).
Files, hashes, commands
No upload was possible (the handle's file quota is exhausted); the pre-registration and the script are reproduced verbatim below and can be rebuilt byte for byte. research/kernel-sign-rescaled.js: file sha256 fbccc5a9d7e613e843d38304ed75213822d766205d40f027420a9b109d8fd9f6; embedded code-sha256 744e5e835164ee0c961192f55f03771340e94c0626491b4649ca1d38961fcce9, out-sha256 4aee9d0e1e3b29541b6f905aea6e8b4775762582605cfe4f27bf05ce11040ed8 (node research/qc/embed.js --check research/kernel-sign-rescaled.js exits 0: code, body and out match). Commands: from a directory holding research/qc/embed.js and research/qc/tailfmt.js from the served tree, node research/qc/embed.js research/kernel-sign-rescaled.js (rebinds), node research/qc/embed.js --check research/kernel-sign-rescaled.js (verifies). The JSON artefact research/kernel-sign-rescaled.json (120,819 bytes) is regenerated by the run.
Proposed record entries: OUTCOMES grade block under Q-kernel-sign-control: "rescaled frame (Z = W = J0 = 9, M = x^{1/5}), X_small share 1.1 to 37.9%, live r ∈ {5, 7, 8, 9}: MEASURED, no support in four families against random and permutation nulls; control (iv) partial (frame cost) | 2026-09-11". No TODO change.
Sources
research/kernel-sign-control.md §0 (lines 20–65), §1, §2 (line 126 on), §3 (325), §4 (355); research/kernel-sign-control.js (cfg object; seed formula); research/grouped-divisor-moment.md (13), (21); research/structured-dispersion-estimate.md §2; research/RESEARCH-EXECUTION.md §4 lines 141–175; research/qc/README.md; research/data-reuse-audit.md §2 lines 42–50, §3 lines 81–85; research/centered-discrepancy-measurement.md line 9; research/OUTCOMES.md grade block line 2105; research/QUESTIONS.md lines 35, 49, 61, 66. Nothing local-only.
Transcript
Attached, scrubbed as data (token and session id prefix-matched, UUID keys, absolute paths outside the working directory, environment values, emails other than the project contact and the attribution address); lines before the GET /start that received job #21 dropped; the two sub-agent transcripts started after it concatenated.
prereg.md (verbatim)
# Pre-registration — job #21, measure lane: X_small in a rescaled exponent frame
**Written 2026-09-11T17:25:17Z (UTC), before any run of the new script.**
Nothing below was informed by an execution of `research/kernel-sign-rescaled.js`;
the frame was chosen by reading `kernel-sign-control.md` §§0-3,
`kernel-sign-control.js`, `grouped-divisor-moment.md` (13) and §6 (21),
`structured-dispersion-estimate.md` §2 and `RESEARCH-EXECUTION.md` §4.
## 1. Decision informed
Does the actual Mobius/von Mangoldt coefficient show cancellation in X_small
beyond random signs **when X_small is non-degenerate** — that is, when the
small-common-divisor cutoff carries several gcd classes, when the prime-power
sector of (13) carries more than one r and includes proper prime powers, and
when X_small carries a visible share of the finite moment? This bears on
whether a *signed* estimate of the D-type moment is plausible, and on nothing
else. It does not estimate an exponent, does not establish or refute (21) of
grouped-divisor-moment.md, and does not move the twin margin.
The prior census (`kernel-sign-control.md`, verdict MEASURED, negative) says
its measurement was weak exactly here: X_small carried 0.02-2.88% of the
moment, J0 = floor(x^(1/20)) was 1 or 2, and Z = 2 collapsed the prime-power
sector of (13) to the single r = 2, so that A_1 on the top box was literally
-mu(ell/2)*log 2. This run removes those three degeneracies and asks the same
question again. A negative there and a negative here are not the same
evidence; a positive here would still be one finite ratio.
## 2. Statistic
Unchanged in object and in form from `kernel-sign-control.md` §0:
* object: the actual right coefficient b_u = A_right(g u) of
grouped-divisor-moment (13) at s = 0, against |b_u| (control 1) and against
|b_u| times an independent seeded sign, eight draws (control 2);
* kernel: X_small of (21), the ordered-pair class with R != 0 and
j = (u_1,u_2) <= J0, computed by the exact divisor sieve
sum_m sum_d f(d)|G_d(m)|^2 with f = 1_{n<=J0} * mu;
* ratio: rho_k(x) = |X_small(actual)| / |X_small(draw k)|, k = 1..8, seeded;
* **new third arm**: a permutation null. Let S = {u : b_u != 0}. For each of
eight seeded permutations pi of S, b_u^{(k)} = |b_u| * sgn(b_{pi(u)}).
This preserves the multiset of magnitudes and the multiset of signs (hence
the sign balance of the actual coefficient) and destroys only the pairing
between arithmetic and sign. rho^perm_k(x) = |X_small(actual)| /
|X_small(perm k)|.
## 3. The rescaled exponent frame, and why each parameter
Everything not listed is exactly the record's frame: box (delta,nu) =
(8/25,9/20), E = floor(x^(9/20)), J = (E,2E], top expanded box
ell in (E*Z, 2E*Z], low expanded box ell in (E,2E], u = ell/g, g in {1,2},
theta = 2/g, sigma = -1, native z0 = x/2 and z = x, c_h = -W(h/(T+1))/(2 pi i h)
with Vaaler's W and T = 4*Atop, A = max(1,round(x^(3/50))) (top band) or A = 1,
eight seeded draws, mulberry32.
Two exponents are rescaled, and only two:
| parameter | record | here | why |
|---|---|---|---|
| Z = W = J0 | max(2,floor(x^(1/20))) = 2 | **9**, constant | Z = 9 puts the prime powers r in {5,7,8,9} inside the r-sector of (13) on the top box (r must satisfy ell/r in (E,2E], i.e. r in [ell/2E, ell/E) with ell in (9E,18E], and r <= W = 9): **four distinct r, two of them proper prime powers (8 = 2^3, 9 = 3^2)**, and single ell can receive two or three r-terms, so the aggregation in (13) is exercised rather than collapsed. J0 = Z = 9 keeps the record's identification of the gcd cutoff with the von Mangoldt cutoff and gives **nine gcd classes** instead of two. Holding it constant (rather than at some x^zeta) is deliberate: §0's slope rule fits over the dyadic points that share one value of J0, and a constant J0 makes that fit span all five scales instead of splitting them. Reaching floor(x^(1/20)) >= 4 honestly needs x >= 2^80. |
| M (left interval) | floor(x^(14/25)) | **floor(x^(1/4))** | The diagonal (equal-frequency) class grows like M per pair and the nonzero-R classes like sqrt(M) per pair, so the off-diagonal share of the finite moment behaves like c/sqrt(M); the record's own rows give c ~ 0.8-1.8 (e.g. j=18, M=1082, off-diagonal 2.34%). M = floor(x^(1/4)) gives M = 22,32,45,64,90 over j = 18..26, hence a predicted X_small share of roughly 8-20% instead of 0.02-2.88%. This is the parameter that buys visibility, and it buys it by shortening the m-average — see §8. |
Derived sizes over j = 18,20,22,24,26, computed by hand here and to be
confirmed by the run: E = floor(x^(9/20)) = 274,512,955,1782,3326; M =
floor(x^(1/4)) = 22,32,45,64,90; A = max(1,round(x^(3/50))) = 2,2,2,3,3;
top box N = 9E/g (2466..29934 at g=1), low box N = E/g. (The first draft of
this line miscomputed x^(9/20) as x^(3/8) and gave E = 107..861; corrected
here before any run, same timestamp, nothing else changed. E and A are the
record's own values, unchanged by this frame.)
Four families, exactly the record's: (top, g=2, A=Atop), (top, g=2, A=1),
(top, g=1, A=Atop), (low, g=1, A=Atop). The top families carry the
prime-power sector of (13); the low family is the pure Mobius sector
(A_0 = mu(ell), A_1 = -mu(ell) log ell), where no r-term can occur at all
because ell and ell/r cannot both lie in the dyadic window (E,2E].
**What the frame emulates.** The coefficient interface of (13) with a
non-degenerate prime-power sector and genuine multi-r aggregation; a gcd
cutoff that is a band rather than "1 or 2"; and a regime in which the nonzero-R
kernel of (21) is a visible fraction of the moment rather than a per-cent of
it. The ratios J0/N and A/N still go to zero along the range, as they do
asymptotically.
**What it does not emulate.** The true proportions. In the real box
M = x^(14/25) >> N = x^(1/2) and v = Ax/(MN) = 1 on the top band; here
M = x^(1/4) << N, so v >> 1 and the harmonic band is not the top band. The
Weil N^3 term is no closer to dominating than it was. Above all, the
visibility of X_small is bought by shortening the very m-average that (21)
relies on, so a sign effect that only appears after a long average cannot show
up here, and an effect that does appear here is not evidence about the long
average. Z = 9 is a constant, not x^(1/20); nothing about the growth of the
cutoff is emulated.
## 4. Expected distinction
* **H0, no advantage.** The actual coefficient behaves like one more sign
draw: per scale, |X_small(actual)| sits inside the spread of the eight
draws (rank 2..9 of 9, uniform); rho_k(x) fluctuates about 1 with no trend;
the mean over draws of the least-squares slope of log2 rho_k against log2 x
is ~0 with sd comparable to it; aggregate mean rank ~5.0 (null sd 0.5 over
20 configurations).
* **H1, extra Mobius cancellation.** |X_small(actual)| below all eight draws
at most scales (rank 1/9), rho_k < 1 and falling, mean slope + sd < 0, and
the same against the permutation null.
## 5. Falsifier, exactly §0's slope rule, plus two additions
**(F1) Slope rule, verbatim from §0.** For each draw k separately, fit the
least-squares slope of log2 rho_k against log2 x over the dyadic points that
share one value of J0 (here all five, J0 = 9). Report the mean slope over the
eight draws and its sample standard deviation. *If mean slope + sd >= 0, the
measurement gives no heuristic support for Mobius-sign cancellation in the
small-j kernel in this frame, and the report says so first.* If mean slope +
sd < 0 the report may say the measurement is **consistent with** extra
cancellation over the measured range; it may never say implies, shows or
establishes, and it must state the finite range and that a decreasing finite
ratio is compatible with no asymptotic saving.
**(F2) Per-scale rule.** At each scale, |X_small(actual)| is *outside* the
random spread only if it is strictly below all eight random draws (rank 1 of
9). If at every scale the actual value lies within the spread of the eight
draws (rank >= 2), there is **no per-scale advantage** in that family.
**(F3) Permutation-null rule.** F1 and F2 are recomputed with the eight
seeded permutation nulls in place of the eight random draws. Support requires
both to pass against the permutation null as well; if either fails, the
permutation null gives no support.
The verdict is written in the record's language: "no support" when F1 fires,
"not refuted at these scales" when it does not. The words "supports" and
"confirmed" are not used.
The same statistics are reported for the whole moment Mfrak and for the
absolute-value control, which has no sign structure and is the upper
reference, not a null.
## 6. Controls, all required to fire (§0 of kernel-sign-control.md), in the new frame
1. *Complete periods are detected.* A detector configuration whose nonzero-R
class with c | theta*R is nonempty must change value when those pairs are
dropped. On production configurations the class is proved empty by the
exact inequality theta*max(h)*2N < (N+1)^2 and reported as a measured share
of zero.
2. *Conjugation is load-bearing.* The unconjugated ordered-pair sum at the
smallest scale of the new frame must have a nonzero imaginary part.
3. *Both endpoints are shifted under reciprocity.* Shifted-endpoint kernels
must equal the native kernel and unshifted ones must differ.
4. *All-ones coefficients reproduce the zero-frequency size.* With b_u = 1 the
equal-frequency class must **dominate** the moment (share > 50%; it will be
smaller than the record's ~100% precisely because M is short here), its
ordered-pair count must respect 8*N*A*(1+log(2*min(N,A))) and its mass the
majorant B^2 max|c_h|^2 max|F| |I| (pair count).
**Identity checks.** The Dirichlet identity sum_{d|n} f(d) = 1_{n<=J0} is
asserted for every n <= 2N in every configuration, and the divisor sieve is
checked against literal ordered-pair enumeration (moment, pair expansion, its
reality, R=0 class, j<=J0 class, j>J0 class) in four small configurations
built in the new frame. Both emptiness certificates are asserted, not assumed.
An inert control aborts the run.
## 7. Pilot, adjustment rule and cap
* **Pilot**, at most 15 minutes: j = 18, 20 with all four families, plus a
share probe at the largest scale j = 26 in the primary family
(top, g=2, A=Atop), because the X_small share is predicted to be *worst*
there and a pilot only at small x would not test it. Expected wall time on
8 threads: under 2 minutes total (M*nu <= ~5e5 per configuration).
* **Degeneracy test and the single permitted adjustment.** The frame is
degenerate if J0 < 4, or if |X_small|/Mfrak for the actual coefficient is
below 10% at any probed scale in the primary family. In that case exactly
one adjustment is made — the M exponent drops from 1/4 to 1/5 (M = 12..36
over the range), nothing else changes — and this file gains a second
timestamped section recording the change before the full run. Both
timestamps are kept. No other adjustment is permitted; in particular no
parameter is changed after seeing any sign statistic.
* **Full run** after the pilot: j = 18,20,22,24,26, four families, eight
random draws and eight permutations each.
* **Cap.** 8 threads, 16 GB, at most 60 minutes of compute in all including
the pilot; the script carries its own wall-clock cap and aborts rather than
overrunning. Actual wall time, threads and peak memory are recorded in the
report.
## 8. What a result here will and will not bear on
It bears on one thing: whether, in a frame where the kernel of (21) is not
degenerate, the actual coefficient of (13) is measurably more cancelled than
sign-randomised or sign-permuted versions of itself. It does not bear on the
asymptotic exponent in (21), on the 3/50 deficit at the target box, on the
sector union of `structured-dispersion-estimate.md` §2, or on the twin margin.
Five dyadic points spanning a factor of 256 in x cannot separate x^1.44 from
x^1.50, and a short m-average cannot speak for a long one.
---
# Amendment 1 — the single permitted adjustment, after the pilot
**Written 2026-09-11T17:32:32Z (UTC), after the pilot and before the full run.**
The first section above stands unchanged and both timestamps are kept.
**Pilot as registered.** `node research/kernel-sign-rescaled.js --jlist 18,20`
and `--jlist 26`, all four families, 8 draws and 8 permutations each; wall
time 0.14 s and 0.95 s on one thread (the frame's M is short, so the sweep is
cheap; the 15-minute pilot allowance was not needed). All four negative
controls fired and the four identity checks passed. The frame's
non-degeneracy targets were met at every probed scale: J0 = Z = 9, live prime
powers r in {5,7,8,9} on every top-box row with the proper powers 8 and 9
present, 2 to 44 values of u receiving more than one r-term, and nine gcd
classes d <= J0 carrying at least two support members.
**X_small share of Mfrak, actual coefficient, pilot:**
| j | top g=2 A=Atop (primary) | top g=2 A=1 | top g=1 A=Atop | low g=1 A=Atop |
|---|---|---|---|---|
| 18 | 8.97% | 14.85% | 9.47% | 1.27% |
| 20 | 4.97% | 16.71% | 16.17% | 26.09% |
| 26 | 13.94% | 3.99% | 10.57% | 10.69% |
**The trigger fired.** The registered rule was: adjust once if the actual
coefficient's |X_small|/Mfrak is below 10% at any probed scale in the primary
family. It is 8.97% at j=18 and 4.97% at j=20. **The registered adjustment is
therefore taken: the M exponent drops from 1/4 to 1/5**, so M =
floor(x^(1/5)) = 12,16,21,27,36 over j = 18..26. Nothing else changes — not
Z, not J0, not E, not A, not the families, not the statistic, not the
falsifiers, not the seeds. No sign statistic was consulted in making this
change, and no further adjustment is permitted.
**One observation recorded rather than acted on.** The per-row share is itself
a noisy statistic, because |X_small(actual)| is a single signed number that
can very nearly cancel (the 1.27% row at j=18 low box sits at rank 2/9 among
its own draws, i.e. it is a small draw, not a small class). A share computed
from the median of the eight nulls would be steadier. That is not the
registered trigger and the registered trigger was followed as written; the
final report will print both the actual-coefficient share and the null-median
share so a reader can see the difference.
**Full run after this amendment:** j = 18,20,22,24,26, four families, eight
seeded draws and eight seeded permutations, bound with
`node research/qc/embed.js research/kernel-sign-rescaled.js`.
research/kernel-sign-rescaled.js (verbatim, with the embedded OUTPUT block and READINGS)
// KERNEL SIGN CONTROL, RESCALED FRAME — does the ACTUAL aggregated
// Mobius/von Mangoldt right coefficient b_u = A_right(g u) of
// grouped-divisor-moment.md (13) make the small-common-divisor kernel
// X_small of (21) smaller than |b_u|, than |b_u| times an independent seeded
// random sign, or than |b_u| carrying the actual signs in a seeded PERMUTED
// order — in a frame where X_small is not degenerate?
//
// THE QUESTION AND THE DOUBT, both stated before the code.
//
// kernel-sign-control.md measured exactly this and found nothing, and said in
// its own section 3 why the measurement was weak where it matters: X_small
// carried 0.02-2.88% of the moment, J0 = floor(x^(1/20)) was 1 or 2 ("small
// common divisor" meaning literally "gcd 1 or 2"), and Z = 2 collapsed the
// prime-power sector of (13) to the single r = 2, so the top-box coefficient
// was exactly -mu(ell/2)*log 2. A null measured on a degenerate object is a
// weak null. This run removes those three degeneracies and asks again.
//
// The frame is the record's, with exactly two exponents rescaled:
// Z = W = J0 = 9, a constant, instead of max(2,floor(x^(1/20))) = 2.
// On the top box ell in (9E,18E] the live prime powers are r in {5,7,8,9}
// -- four values, two of them PROPER powers (8 = 2^3, 9 = 3^2) -- and a
// single ell can receive two or three r-terms, so (13) aggregates instead
// of collapsing. J0 = 9 gives nine gcd classes instead of two, and being
// constant it lets section 0's slope rule (fit over the points sharing one
// J0) span all five scales. floor(x^(1/20)) >= 4 honestly needs x >= 2^80.
// M = floor(x^(1/5)) instead of floor(x^(14/25)). [prereg.md amendment 1:
// registered as x^(1/4); the registered pilot found the primary family's
// X_small share below the registered 10% floor at j=18 and j=20, so the
// one permitted adjustment was taken and the exponent dropped to 1/5.]
// The equal-frequency class grows like M per pair and the nonzero-R
// classes like sqrt(M), so the off-diagonal share behaves like c/sqrt(M);
// the record's own rows give c ~ 0.8-1.8. This is the parameter that buys
// a visible X_small, and it buys it by SHORTENING THE M-AVERAGE, which is
// the doubt: a sign effect that needs a long average cannot appear here,
// and one that appears here says nothing about a long average. In the real
// box M = x^(14/25) >> N and v = Ax/(MN) = 1; here M << N and v >> 1, so
// this is not the top harmonic band and not the real proportions.
//
// Everything else is the record's: box (delta,nu) = (8/25,9/20),
// E = floor(x^(9/20)), J = (E,2E], top box ell ~ E*Z and low box ell ~ E,
// u = ell/g, g in {1,2}, theta = 2/g, sigma = -1, native z0 = x/2 and z = x,
// c_h = -W(h/(T+1))/(2 pi i h) with Vaaler's W and T = 4*Atop, A = Atop or 1,
// mulberry32, eight draws. Pre-registration: prereg.md, written before this
// file was executed; its falsifier F1 is section 0's slope rule verbatim, F2
// the per-scale spread rule, F3 the same two against the permutation null.
//
// A finite ratio on five dyadic scales is a MEASUREMENT. It cannot establish
// or refute an asymptotic power saving, it does not prove (21), and it does
// not move the twin margin. Every number below carries its sizes.
'use strict';
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const started = Date.now();
const CAP_MS = 45 * 60 * 1000;
const cap = (what) => assert(Date.now() - started < CAP_MS, `wall-clock cap exceeded at ${what}`);
const elog = (s) => process.stderr.write(s + '\n');
const argv = process.argv.slice(2);
const optOf = (n, d) => { const i = argv.indexOf('--' + n); return i === -1 ? d : argv[i + 1]; };
// ---------------------------------------------------------------------------
// 0. Small arithmetic (unchanged from kernel-sign-control.js)
// ---------------------------------------------------------------------------
const LIMIT = 1 << 18;
const spf = new Int32Array(LIMIT + 1);
for (let i = 2; i <= LIMIT; i++) { if (spf[i] === 0) for (let j = i; j <= LIMIT; j += i) if (spf[j] === 0) spf[j] = i; }
function factor(n) { assert(n <= LIMIT, `factor beyond the sieve: ${n}`); const f = []; while (n > 1) { const p = spf[n]; let k = 0; while (n % p === 0) { n /= p; k++; } f.push([p, k]); } return f; }
function mobius(n) { if (n === 1) return 1; const f = factor(n); for (const [, k] of f) if (k > 1) return 0; return f.length % 2 ? -1 : 1; }
function divisors(n) { let ds = [1]; for (const [p, k] of factor(n)) { const cur = ds.slice(); let q = 1; for (let i = 1; i <= k; i++) { q *= p; for (const d of cur) ds.push(d * q); } } return ds; }
function gcdn(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { const t = a % b; a = b; b = t; } return a; }
function invmod(a, n) { // -1 when gcd(a,n) != 1
if (n === 1) return 0;
let t = 0, nt = 1, r = n, nr = ((a % n) + n) % n;
while (nr !== 0) { const q = Math.floor(r / nr); const tt = t - q * nt; t = nt; nt = tt; const rr = r - q * nr; r = nr; nr = rr; }
return r !== 1 ? -1 : ((t % n) + n) % n;
}
function mulberry32(seed) {
let a = seed >>> 0;
return function () { a = (a + 0x6D2B79F5) >>> 0; let t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
}
function kahan(terms) { let s = 0, c = 0; for (const t of terms) { const y = t - c, u = s + y; c = (u - s) - y; s = u; } return s; }
function stats(list) { const n = list.length, mu = list.reduce((a, b) => a + b, 0) / n; const sd = Math.sqrt(list.reduce((a, b) => a + (b - mu) ** 2, 0) / Math.max(1, n - 1)); return { mu, sd }; }
function median(list) { const d = list.slice().sort((a, b) => a - b), n = d.length; return n % 2 ? d[(n - 1) / 2] : (d[n / 2 - 1] + d[n / 2]) / 2; }
function slope(xs, ys) { const n = xs.length, mx = xs.reduce((a, b) => a + b) / n, my = ys.reduce((a, b) => a + b) / n; let num = 0, den = 0; for (let i = 0; i < n; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; } return num / den; }
// ---------------------------------------------------------------------------
// 1. The exact aggregated coefficients of grouped-divisor-moment.md (13), s=0
// A0(l) = mu(l) 1_J(l)
// A1(l) = -mu(l) 1_J(l) log l - sum_{r|l, 2<=r<=W} mu(l/r) 1_J(l/r) Lambda(r)
// J = (E,2E] is the ORIGINAL right divisor interval, W = Z the cutoff.
// Unchanged from the record; only the VALUE of Z differs.
// ---------------------------------------------------------------------------
function coeffA(kind, ell, E, Z) {
const inJ = (n) => n > E && n <= 2 * E;
if (kind === 0) return inJ(ell) ? mobius(ell) : 0;
let val = inJ(ell) ? -mobius(ell) * Math.log(ell) : 0;
for (const [p, k] of factor(ell)) { let r = p; for (let i = 1; i <= k; i++) { if (r > Z) break; if (inJ(ell / r)) val += -mobius(ell / r) * Math.log(p); r *= p; } }
return val;
}
// The r-sector diagnostic: WHICH prime powers are live on this box, how many
// ell receive more than one r-term, and how many gcd classes d <= J0 have at
// least two support members. This is the frame's non-degeneracy certificate
// and it is printed, not assumed.
function sectorDiagnostic(cfg) {
const { N, g, E, Z, J0 } = cfg;
const rs = new Map();
let multi = 0, supp = 0, lowTerm = 0;
const perD = new Int32Array(J0 + 1);
for (let i = 1; i <= N; i++) {
const ell = g * (N + i);
let live = 0;
if (ell > E && ell <= 2 * E && mobius(ell) !== 0) { lowTerm++; live++; }
for (const [p, k] of factor(ell)) {
let r = p;
for (let t = 1; t <= k; t++) {
if (r > Z) break;
const q = ell / r;
if (q > E && q <= 2 * E && mobius(q) !== 0) { rs.set(r, (rs.get(r) || 0) + 1); live++; }
r *= p;
}
}
if (live > 1) multi++;
if (coeffA(1, ell, E, Z) !== 0) { supp++; for (let d = 1; d <= J0; d++) if ((N + i) % d === 0) perD[d]++; }
}
const rList = [...rs.keys()].sort((a, b) => a - b);
const proper = rList.filter((r) => factor(r)[0][1] > 1);
let liveClasses = 0; for (let d = 1; d <= J0; d++) if (perD[d] >= 2) liveClasses++;
return { rList, rCounts: rList.map((r) => rs.get(r)), proper, multi, supp, lowTerm, liveClasses };
}
// ---------------------------------------------------------------------------
// 2. The rescaled frame's two constants, and the configuration
// ---------------------------------------------------------------------------
const ZFIX = 9; // Z = W = J0, constant (record: max(2,floor(x^(1/20))) = 2)
const MEXP = 1 / 5; // M = floor(x^MEXP) (record: floor(x^(14/25)); registered 1/4, amended once)
function buildConfig(o) {
const { x, g, ellBox, A, Atop, E, Z, J0, zNum, zDen, Mover } = o;
assert(ellBox % g === 0, 'ell box must be divisible by g');
const N = ellBox / g;
const M = Mover !== undefined ? Mover : Math.max(4, Math.floor(Math.pow(x, MEXP)));
const theta = 2 / g;
assert(Number.isInteger(theta), 'theta = 2/g must be an integer here');
const Hs = []; for (let h = A; h < 2 * A; h++) Hs.push(h);
const T = 4 * Atop;
const ch = Hs.map((h) => { const v = h / (T + 1); const W = Math.PI * v * (1 - Math.abs(v)) / Math.tan(Math.PI * v) + Math.abs(v); return W / (2 * Math.PI * h); });
const f = new Float64Array(2 * N + 1);
for (let d = 1; d <= Math.min(J0, 2 * N); d++) for (let e = 1; d * e <= 2 * N; e++) f[d * e] += mobius(e);
for (let n = 1; n <= 2 * N; n++) { let s = 0; for (const d of divisors(n)) s += f[d]; assert(Math.abs(s - (n <= J0 ? 1 : 0)) < 1e-9, `f-sieve identity failed at ${n}`); }
return { x, g, N, M, A, Atop, Hs, ch, theta, E, Z, J0, f, ellBox, zNum, zDen, sigma: -1 };
}
// A1; |A1|; eight seeded random signs on |A1|; eight seeded PERMUTATIONS of
// the actual signs over the support (same magnitudes, same multiset of signs,
// only the pairing of arithmetic to sign destroyed); A0; optionally all-ones.
function coefficientVariants(cfg, opts) {
const { N, g, E, Z } = cfg;
const base1 = new Float64Array(N + 1), base0 = new Float64Array(N + 1);
for (let i = 1; i <= N; i++) { const ell = g * (N + i); base1[i] = coeffA(1, ell, E, Z); base0[i] = coeffA(0, ell, E, Z); }
const vs = [];
const abs1 = new Float64Array(N + 1); for (let i = 1; i <= N; i++) abs1[i] = Math.abs(base1[i]);
const seedOf = (base, k) => (base ^ Math.imul(k + 1, 2654435761) ^ Math.imul(Math.log2(cfg.x) | 0, 40503) ^ (cfg.g << 24) ^ (cfg.A << 16) ^ Math.imul(cfg.ellBox, 97)) >>> 0;
vs.push({ name: 'A1', b: base1 });
vs.push({ name: 'absA1', b: abs1 });
for (let k = 0; k < opts.nDraws; k++) {
const rng = mulberry32(seedOf(0x5EED0000, k));
const a = new Float64Array(N + 1);
for (let i = 1; i <= N; i++) a[i] = abs1[i] * (rng() < 0.5 ? -1 : 1);
vs.push({ name: 'rnd' + (k + 1), b: a });
}
const supp = []; for (let i = 1; i <= N; i++) if (base1[i] !== 0) supp.push(i);
for (let k = 0; k < opts.nPerms; k++) {
const rng = mulberry32(seedOf(0x9E3D0000, k));
const sg = supp.map((i) => (base1[i] < 0 ? -1 : 1));
for (let t = sg.length - 1; t > 0; t--) { const r = Math.floor(rng() * (t + 1)); const tmp = sg[t]; sg[t] = sg[r]; sg[r] = tmp; }
const a = new Float64Array(N + 1);
supp.forEach((i, t) => { a[i] = abs1[i] * sg[t]; });
vs.push({ name: 'perm' + (k + 1), b: a });
}
vs.push({ name: 'A0', b: base0 });
if (opts.ones) { const a = new Float64Array(N + 1).fill(1); a[0] = 0; vs.push({ name: 'ones', b: a }); }
return vs;
}
// ---------------------------------------------------------------------------
// 3. The moment engine (unchanged from kernel-sign-control.js).
// Y(m) = sum_{u~N} b_u sum_{h in H} c_h 1_{(m,u)=1} e_u(sigma theta h mbar)
// Phi_{u,h}(m), Phi = e(h z0/(gmu)) - e(h z/(gmu)), Mfrak = sum_I |Y|^2.
// Ordered pairs: j=(u1,u2), c=lcm(u1,u2), R=h1 l2-h2 l1.
// With f_{J0} = 1_{n<=J0} * mu, sum_{d|n} f(d) = 1_{n<=J0}, hence the whole
// j<=J0 class = sum_m sum_d f(d)|G_d(m)|^2 with G_d the u-sum over multiples
// of d. Equal-frequency pairs (R=0) are the pairs sharing a reduced h/u.
// ---------------------------------------------------------------------------
function runMoment(cfg, variants) {
const { N, M, Hs, ch, theta, sigma, g, x, f, J0, zNum, zDen } = cfg;
const nv = variants.length, nh = Hs.length;
const z0 = x / 2, z1 = x * zNum / zDen, twoZ = Math.abs(z1 - 2 * z0) < 1e-9;
const TWO_PI = 2 * Math.PI;
const uList = [];
for (let i = 1; i <= N; i++) { for (const v of variants) if (v.b[i] !== 0) { uList.push(i); break; } }
const nu = uList.length;
assert(nu > 0, 'empty coefficient support');
const dOff = new Int32Array(nu + 1), dBuf = [];
for (let a = 0; a < nu; a++) { dOff[a] = dBuf.length; for (const d of divisors(N + uList[a])) if (f[d] !== 0) dBuf.push(d); }
dOff[nu] = dBuf.length;
const dArr = new Int32Array(dBuf);
const seen = new Uint8Array(2 * N + 1), kUsed = [];
for (const d of dArr) if (!seen[d]) { seen[d] = 1; kUsed.push(d); }
kUsed.sort((p, q) => p - q);
const nk = kUsed.length;
const kIndex = new Int32Array(2 * N + 1).fill(-1);
for (let t = 0; t < nk; t++) kIndex[kUsed[t]] = t;
const dIdx = new Int32Array(dArr.length);
for (let t = 0; t < dArr.length; t++) dIdx[t] = kIndex[dArr[t]];
assert(kIndex[1] >= 0, 'k=1 must be present');
const atomU = [], atomH = [];
for (let a = 0; a < nu; a++) for (let t = 0; t < nh; t++) { atomU.push(a); atomH.push(t); }
const na = atomU.length;
const keyMap = new Map(), rawGid = new Int32Array(na);
let minQ = Infinity;
for (let s = 0; s < na; s++) {
const u = N + uList[atomU[s]], h = Hs[atomH[s]], d = gcdn(u, h), q = u / d, p = h / d;
if (q < minQ) minQ = q;
const key = p * 8388608 + q;
if (!keyMap.has(key)) keyMap.set(key, keyMap.size);
rawGid[s] = keyMap.get(key);
}
const gsize = new Int32Array(keyMap.size);
for (let s = 0; s < na; s++) gsize[rawGid[s]]++;
let zeroPairs = 0; for (const c of gsize) zeroPairs += c * c;
const gid = new Int32Array(na).fill(-1), remap = new Int32Array(keyMap.size).fill(-1);
let nmg = 0;
for (let s = 0; s < na; s++) if (gsize[rawGid[s]] > 1) { if (remap[rawGid[s]] < 0) remap[rawGid[s]] = nmg++; gid[s] = remap[rawGid[s]]; }
const maxH = Hs[nh - 1];
const periodEmpty = theta * maxH * (2 * N) < (N + 1) * (N + 1);
const zeroFreqSmallEmpty = minQ > J0;
const bMat = new Float64Array(nu * nv);
for (let a = 0; a < nu; a++) for (let v = 0; v < nv; v++) bMat[a * nv + v] = variants[v].b[uList[a]];
const G = new Float64Array(nk * nv * 2), SQ = new Float64Array(nk * nv);
const ZG = new Float64Array(Math.max(1, nmg * nv * 2)), R0multi = new Float64Array(nv);
const D = new Float64Array(na);
let coprime = 0, maxPhi = 0;
for (let m = M + 1; m <= 2 * M; m++) {
for (let a = 0; a < nu; a++) {
const u = N + uList[a];
const mb = invmod(m % u, u);
if (mb < 0) continue;
coprime++;
const ang1 = TWO_PI * (((((sigma * theta * mb) % u) + u) % u)) / u;
const w1r = Math.cos(ang1), w1i = Math.sin(ang1);
const ang2 = TWO_PI * (z0 / (g * m * u));
const w2r = Math.cos(ang2), w2i = Math.sin(ang2);
let w3r, w3i;
if (twoZ) { w3r = w2r * w2r - w2i * w2i; w3i = 2 * w2r * w2i; }
else { const a3 = TWO_PI * (z1 / (g * m * u)); w3r = Math.cos(a3); w3i = Math.sin(a3); }
let p1r = 1, p1i = 0, p2r = 1, p2i = 0, p3r = 1, p3i = 0, q;
for (let e = 0; e < Hs[0]; e++) {
q = p1r * w1r - p1i * w1i; p1i = p1r * w1i + p1i * w1r; p1r = q;
q = p2r * w2r - p2i * w2i; p2i = p2r * w2i + p2i * w2r; p2r = q;
q = p3r * w3r - p3i * w3i; p3i = p3r * w3i + p3i * w3r; p3r = q;
}
let Vre = 0, Vim = 0;
for (let t = 0; t < nh; t++) {
const dr = p2r - p3r, di = p2i - p3i;
const ph = dr * dr + di * di; if (ph > maxPhi) maxPhi = ph;
const kr = p1r * dr - p1i * di, ki = p1r * di + p1i * dr;
const c = ch[t], ar = -c * ki, ai = c * kr;
Vre += ar; Vim += ai;
const s = a * nh + t;
if (gid[s] < 0) D[s] += ar * ar + ai * ai;
else { const base = gid[s] * nv * 2; for (let v = 0; v < nv; v++) { const b = bMat[a * nv + v]; ZG[base + 2 * v] += b * ar; ZG[base + 2 * v + 1] += b * ai; } }
if (t + 1 < nh) {
q = p1r * w1r - p1i * w1i; p1i = p1r * w1i + p1i * w1r; p1r = q;
q = p2r * w2r - p2i * w2i; p2i = p2r * w2i + p2i * w2r; p2r = q;
q = p3r * w3r - p3i * w3i; p3i = p3r * w3i + p3i * w3r; p3r = q;
}
}
const lo = dOff[a], hi = dOff[a + 1];
for (let t = lo; t < hi; t++) {
const base = dIdx[t] * nv * 2;
for (let v = 0; v < nv; v++) { const b = bMat[a * nv + v]; G[base + 2 * v] += b * Vre; G[base + 2 * v + 1] += b * Vim; }
}
}
for (let t = 0; t < nk; t++) {
const base = t * nv * 2, sb = t * nv;
for (let v = 0; v < nv; v++) { const re = G[base + 2 * v], im = G[base + 2 * v + 1]; SQ[sb + v] += re * re + im * im; G[base + 2 * v] = 0; G[base + 2 * v + 1] = 0; }
}
for (let p = 0; p < nmg; p++) {
const base = p * nv * 2;
for (let v = 0; v < nv; v++) { const re = ZG[base + 2 * v], im = ZG[base + 2 * v + 1]; R0multi[v] += re * re + im * im; ZG[base + 2 * v] = 0; ZG[base + 2 * v + 1] = 0; }
}
cap('moment loop');
}
const cnt = new Float64Array(nk);
for (let a = 0; a < nu; a++) for (let t = dOff[a]; t < dOff[a + 1]; t++) cnt[dIdx[t]] += nh;
const smallPairs = Math.round(kahan(Array.from({ length: nk }, (_, t) => f[kUsed[t]] * cnt[t] * cnt[t])));
const out = { N, M, A: cfg.A, nu, na, nk, nmg, coprime, zeroPairs, smallPairs, periodEmpty, zeroFreqSmallEmpty, minQ, maxPhi: Math.sqrt(maxPhi), variants: [] };
for (let v = 0; v < nv; v++) {
const Mfrak = SQ[kIndex[1] * nv + v];
const terms = new Array(nk); let absMass = 0;
for (let t = 0; t < nk; t++) { terms[t] = f[kUsed[t]] * SQ[t * nv + v]; absMass += Math.abs(terms[t]); }
const Xsmall = kahan(terms);
let R0 = R0multi[v];
for (let s = 0; s < na; s++) if (gid[s] < 0) { const b = bMat[atomU[s] * nv + v]; R0 += b * b * D[s]; }
out.variants.push({ name: variants[v].name, Mfrak, Xsmall, XsmallAbsMass: absMass, R0, big: Mfrak - R0 - Xsmall });
}
return out;
}
// no-conjugation control: same divisor sieve, but sum f(d) G_d(m)^2 unconjugated
function runNoConjugate(cfg, variant) {
const { N, M, Hs, ch, theta, sigma, g, x, f, zNum, zDen } = cfg;
const nh = Hs.length, z0 = x / 2, z1 = x * zNum / zDen, TWO_PI = 2 * Math.PI;
const uList = []; for (let i = 1; i <= N; i++) if (variant.b[i] !== 0) uList.push(i);
const kUsed = []; for (let k = 1; k <= 2 * N; k++) if (f[k] !== 0) kUsed.push(k);
const kIndex = new Int32Array(2 * N + 1).fill(-1); kUsed.forEach((k, t) => { kIndex[k] = t; });
const nk = kUsed.length;
const Gre = new Float64Array(nk), Gim = new Float64Array(nk), Cr = new Float64Array(nk), Sr = new Float64Array(nk), Si = new Float64Array(nk);
for (let m = M + 1; m <= 2 * M; m++) {
for (const i of uList) {
const u = N + i, mb = invmod(m % u, u); if (mb < 0) continue;
const ang1 = TWO_PI * (((((sigma * theta * mb) % u) + u) % u)) / u;
const w1r = Math.cos(ang1), w1i = Math.sin(ang1);
const ang2 = TWO_PI * (z0 / (g * m * u)); const w2r = Math.cos(ang2), w2i = Math.sin(ang2);
const a3 = TWO_PI * (z1 / (g * m * u)); const w3r = Math.cos(a3), w3i = Math.sin(a3);
let p1r = 1, p1i = 0, p2r = 1, p2i = 0, p3r = 1, p3i = 0, q;
for (let e = 0; e < Hs[0]; e++) {
q = p1r * w1r - p1i * w1i; p1i = p1r * w1i + p1i * w1r; p1r = q;
q = p2r * w2r - p2i * w2i; p2i = p2r * w2i + p2i * w2r; p2r = q;
q = p3r * w3r - p3i * w3i; p3i = p3r * w3i + p3i * w3r; p3r = q;
}
let Vre = 0, Vim = 0;
for (let t = 0; t < nh; t++) {
const dr = p2r - p3r, di = p2i - p3i;
const kr = p1r * dr - p1i * di, ki = p1r * di + p1i * dr;
const c = ch[t]; Vre += -c * ki; Vim += c * kr;
if (t + 1 < nh) {
q = p1r * w1r - p1i * w1i; p1i = p1r * w1i + p1i * w1r; p1r = q;
q = p2r * w2r - p2i * w2i; p2i = p2r * w2i + p2i * w2r; p2r = q;
q = p3r * w3r - p3i * w3i; p3i = p3r * w3i + p3i * w3r; p3r = q;
}
}
const b = variant.b[i];
for (const d of divisors(u)) { const t = kIndex[d]; if (t >= 0) { Gre[t] += b * Vre; Gim[t] += b * Vim; } }
}
for (let t = 0; t < nk; t++) { const re = Gre[t], im = Gim[t]; Cr[t] += re * re + im * im; Sr[t] += re * re - im * im; Si[t] += 2 * re * im; Gre[t] = 0; Gim[t] = 0; }
}
return { conj: kahan(kUsed.map((k, t) => f[k] * Cr[t])), noConjRe: kahan(kUsed.map((k, t) => f[k] * Sr[t])), noConjIm: kahan(kUsed.map((k, t) => f[k] * Si[t])) };
}
// ---------------------------------------------------------------------------
// 4. Literal ordered-pair expansion (validation only; O(N^2 A^2 M))
// ---------------------------------------------------------------------------
function bruteForce(cfg, variant) {
const { N, M, Hs, ch, theta, sigma, g, x, J0, zNum, zDen } = cfg;
const nh = Hs.length, z0 = x / 2, z1 = x * zNum / zDen, TWO_PI = 2 * Math.PI;
const uList = []; for (let i = 1; i <= N; i++) if (variant.b[i] !== 0) uList.push(N + i);
const ms = []; for (let m = M + 1; m <= 2 * M; m++) ms.push(m);
const atoms = [];
for (const u of uList) for (let t = 0; t < nh; t++) {
const h = Hs[t], L = ms.length;
const phiR = new Float64Array(L), phiI = new Float64Array(L), kR = new Float64Array(L), kI = new Float64Array(L), ok = new Uint8Array(L);
for (let q = 0; q < L; q++) {
const m = ms[q], mb = invmod(m % u, u); if (mb < 0) continue; ok[q] = 1;
const a1 = TWO_PI * h * (z0 / (g * m * u)), a2 = TWO_PI * h * (z1 / (g * m * u));
phiR[q] = Math.cos(a1) - Math.cos(a2); phiI[q] = Math.sin(a1) - Math.sin(a2);
const ap = TWO_PI * (((((sigma * theta * h * mb) % u) + u) % u)) / u;
const pr = Math.cos(ap), pi = Math.sin(ap);
kR[q] = pr * phiR[q] - pi * phiI[q]; kI[q] = pr * phiI[q] + pi * phiR[q];
}
atoms.push({ u, h, c: ch[t], b: variant.b[u - N], phiR, phiI, kR, kI, ok });
}
let Mfrak = 0;
for (let q = 0; q < ms.length; q++) {
let yr = 0, yi = 0;
for (const a of atoms) { if (!a.ok[q]) continue; yr += a.b * (-a.c * a.kI[q]); yi += a.b * (a.c * a.kR[q]); }
Mfrak += yr * yr + yi * yi;
}
let tot = [0, 0], zero = [0, 0], per = [0, 0], smallAll = [0, 0], smallNZ = [0, 0], smallNZnoPer = [0, 0], big = [0, 0];
let periodPairs = 0, zeroPairs = 0, smallPairs = 0;
for (const a of atoms) for (const b of atoms) {
const j = gcdn(a.u, b.u), l1 = a.u / j, l2 = b.u / j, c = j * l1 * l2, R = a.h * l2 - b.h * l1, r = sigma * theta * R;
let sr = 0, si = 0;
for (let q = 0; q < ms.length; q++) {
if (!a.ok[q] || !b.ok[q]) continue;
const mb = invmod(ms[q] % c, c); if (mb < 0) continue;
const ang = TWO_PI * (((((r * mb) % c) + c) % c)) / c;
const er = Math.cos(ang), ei = Math.sin(ang);
const fr = a.phiR[q] * b.phiR[q] + a.phiI[q] * b.phiI[q];
const fi = a.phiI[q] * b.phiR[q] - a.phiR[q] * b.phiI[q];
sr += er * fr - ei * fi; si += er * fi + ei * fr;
}
const w = a.b * b.b * a.c * b.c;
const tr = w * sr, ti = w * si;
tot = [tot[0] + tr, tot[1] + ti];
const isPeriod = R !== 0 && ((((r % c) + c) % c) === 0);
if (isPeriod) { per = [per[0] + tr, per[1] + ti]; periodPairs++; }
if (R === 0) { zero = [zero[0] + tr, zero[1] + ti]; zeroPairs++; }
if (j <= J0) {
smallAll = [smallAll[0] + tr, smallAll[1] + ti]; smallPairs++;
if (R !== 0) { smallNZ = [smallNZ[0] + tr, smallNZ[1] + ti]; if (!isPeriod) smallNZnoPer = [smallNZnoPer[0] + tr, smallNZnoPer[1] + ti]; }
}
if (R !== 0 && j > J0) big = [big[0] + tr, big[1] + ti];
}
return { Mfrak, tot, zero, per, smallAll, smallNZ, smallNZnoPer, big, periodPairs, zeroPairs, smallPairs, pairs: atoms.length * atoms.length };
}
// ---------------------------------------------------------------------------
// 5. Negative control (iii): reciprocity needs BOTH endpoints shifted
// ---------------------------------------------------------------------------
function reciprocityControl() {
const TWO_PI = 2 * Math.PI;
const ph = (a, c) => { const t = TWO_PI * ((((a % c) + c) % c)) / c; return [Math.cos(t), Math.sin(t)]; };
const sub = (p, q) => [p[0] - q[0], p[1] - q[1]];
const mul = (p, q) => [p[0] * q[0] - p[1] * q[1], p[0] * q[1] + p[1] * q[0]];
let checked = 0, agree = 0, disagree = 0;
const z0 = 256, z = 487;
for (const g of [1, 2]) for (let u = 5; u <= 40; u++) for (let m = 41; m <= 90; m++) {
if (gcdn(m, u) !== 1) continue;
const theta = 2 / g;
for (const h of [1, 2, 3]) {
const phi = (d) => sub(ph(h * (z0 - d), g * m * u), ph(h * (z - d), g * m * u));
const shifted = mul(ph(theta * h * invmod(m, u), u), phi(2));
const native = mul(ph(-theta * h * invmod(u, m), m), phi(0));
const unshifted = mul(ph(theta * h * invmod(m, u), u), phi(0));
checked++;
if (Math.hypot(shifted[0] - native[0], shifted[1] - native[1]) < 1e-9) agree++;
if (Math.hypot(unshifted[0] - native[0], unshifted[1] - native[1]) > 1e-7) disagree++;
}
}
return { checked, agree, disagree };
}
// ---------------------------------------------------------------------------
// 6. The rescaled frame and the sweep
// ---------------------------------------------------------------------------
const NDRAWS = 8, NPERMS = 8;
const JLIST = String(optOf('jlist', '18,20,22,24,26')).split(',').map(Number);
const fmt = (v) => (v === 0 ? '0' : (Math.abs(v) < 1e-300 ? '0' : v.toExponential(4)));
const pct = (v) => (100 * v).toFixed(2) + '%';
const boxOf = (kind, E, Z, g) => { const raw = kind === 'top' ? E * Z : E; return raw - (raw % g); };
const frameOf = (j) => {
const x = Math.pow(2, j);
return { x, E: Math.floor(Math.pow(x, 9 / 20)), Z: ZFIX, J0: ZFIX, Atop: Math.max(1, Math.round(Math.pow(x, 3 / 50))), M: Math.max(4, Math.floor(Math.pow(x, MEXP))) };
};
console.log('KERNEL SIGN CONTROL, RESCALED FRAME — actual A_right(gu) against |A_right|, seeded random signs and seeded sign permutations');
console.log('box delta=8/25 nu=9/20 as in kernel-sign-control.md; RESCALED: Z=W=J0=9 constant (was max(2,floor(x^(1/20)))=2), M=floor(x^(1/5)) (was floor(x^(14/25)))');
console.log('E=floor(x^(9/20)), J=(E,2E]; top expanded box ell in (9E,18E], low expanded box ell in (E,2E]; u=ell/g; native z0=x/2, z=x; sigma=-1');
console.log(`c_h = -W(h/(T+1))/(2 pi i h) with Vaaler W and T=4*Atop, A=max(1,round(x^(3/50))) or 1; draws=${NDRAWS}, permutations=${NPERMS}`);
console.log(`dyadic scales j: ${JLIST.join(',')}`);
console.log('pre-registered in prereg.md: F1 = section 0 slope rule (mean slope + sd >= 0 ==> no support), F2 = per-scale spread rule, F3 = the same against the permutation null');
const rc = reciprocityControl();
assert.equal(rc.agree, rc.checked);
assert(rc.disagree > 0);
console.log(`control (iii) reciprocity: ${rc.checked}/${rc.checked} shifted-endpoint kernels equal the native kernel; ${rc.disagree} unshifted ones differ`);
// identity validation against literal ordered-pair enumeration, in the new frame
{
const rows = [];
for (const [xv, gg, A, Eb, box] of [[4096, 1, 2, 3, 'top'], [4096, 2, 2, 3, 'top'], [8192, 1, 1, 3, 'top'], [8192, 2, 3, 3, 'top']]) {
const cfg = buildConfig({ x: xv, g: gg, ellBox: boxOf(box, Eb, ZFIX, gg), A, Atop: 3, E: Eb, Z: ZFIX, J0: ZFIX, zNum: 1, zDen: 1, Mover: 24 });
const vs = coefficientVariants(cfg, { nDraws: 1, nPerms: 1 });
const e0 = runMoment(cfg, vs).variants[0];
const bf = bruteForce(cfg, vs[0]);
const mass = Math.abs(bf.tot[0]) + Math.abs(bf.zero[0]) + Math.abs(bf.smallAll[0]) + 1;
assert(Math.abs(bf.Mfrak - e0.Mfrak) < 1e-7 * mass, 'moment vs direct');
assert(Math.abs(bf.tot[0] - e0.Mfrak) < 1e-7 * mass, 'pair expansion vs moment');
assert(Math.abs(bf.tot[1]) < 1e-7 * mass, 'pair expansion not real');
assert(Math.abs(bf.zero[0] - e0.R0) < 1e-7 * mass, 'R=0 class');
assert(Math.abs(bf.smallAll[0] - e0.Xsmall) < 1e-7 * mass, 'j<=J0 class');
assert(Math.abs((bf.tot[0] - bf.zero[0] - bf.smallAll[0]) - e0.big) < 1e-7 * mass, 'j>J0 class');
rows.push(` x=${xv} g=${gg} A=${A} Z=J0=${ZFIX} N=${cfg.N} M=24: ${bf.pairs} ordered pairs (R=0: ${bf.zeroPairs}, j<=J0: ${bf.smallPairs}, periods: ${bf.periodPairs}); 5 quantities agree`);
}
console.log('identity check — divisor sieve against literal ordered-pair expansion (new frame):');
for (const r of rows) console.log(r);
cap('identity check');
}
// negative control (i): the complete-period class must be detectable
let periodRow = null;
{
const cfg = buildConfig({ x: 4096, g: 1, ellBox: 6, A: 8, Atop: 8, E: 3, Z: ZFIX, J0: ZFIX, zNum: 1, zDen: 1, Mover: 20 });
const vs = coefficientVariants(cfg, { nDraws: 0, nPerms: 0, ones: true });
const bf = bruteForce(cfg, vs[vs.length - 1]);
assert(bf.periodPairs > 0, 'control (i) inert: no complete-period pairs in the detector configuration');
const drop = bf.smallNZ[0] - bf.smallNZnoPer[0];
assert(Math.abs(drop) > 1e-9, 'control (i) inert: dropping complete periods left the kernel unchanged');
periodRow = { N: cfg.N, A: cfg.A, M: cfg.M, periodPairs: bf.periodPairs, pairs: bf.pairs, drop, smallNZ: bf.smallNZ[0] };
console.log(`control (i) complete periods: detector N=${cfg.N} A=${cfg.A} M=${cfg.M} J0=${ZFIX} has ${bf.periodPairs} period pairs of ${bf.pairs}; dropping them moves the nonzero j<=J0 kernel from ${fmt(bf.smallNZ[0])} by ${fmt(drop)}`);
}
// main sweep
const CONFIGS = [{ box: 'top', g: 2, band: 'top' }, { box: 'top', g: 2, band: 'one' }, { box: 'top', g: 1, band: 'top' }, { box: 'low', g: 1, band: 'top' }];
const table = [];
for (const j of JLIST) {
const { x, E, Z, J0, Atop, M } = frameOf(j);
for (const cf of CONFIGS) {
const A = cf.band === 'top' ? Atop : 1;
const cfg = buildConfig({ x, g: cf.g, ellBox: boxOf(cf.box, E, Z, cf.g), A, Atop, E, Z, J0, zNum: 1, zDen: 1 });
const vs = coefficientVariants(cfg, { nDraws: NDRAWS, nPerms: NPERMS });
const diag = sectorDiagnostic(cfg);
const t0 = Date.now();
const res = runMoment(cfg, vs);
const secs = (Date.now() - t0) / 1000;
assert(res.zeroFreqSmallEmpty, 'equal-frequency pairs with j<=J0 exist; X_small identity would need correcting');
let B = 0; for (let i = 1; i <= cfg.N; i++) B = Math.max(B, Math.abs(vs[0].b[i]));
const v = A * x / (cfg.M * cfg.N), fA = Math.min(1, v);
const budget = B * B * fA * fA * (cfg.M * cfg.N / A + (1 + v) * (Math.pow(cfg.N, 3) + cfg.M));
const count5 = 8 * cfg.N * A * (1 + Math.log(2 * Math.min(cfg.N, A)));
assert(res.zeroPairs <= count5, 'equal-frequency ordered-pair count exceeds the (5) counting bound');
table.push({ j, x, box: cf.box, g: cf.g, band: cf.band, A, Atop, E, Z, J0, N: cfg.N, M: cfg.M, B, v, f: fA, budget, count5, secs, diag, res });
elog(` j=${j} ${cf.box} g=${cf.g} A=${A} N=${cfg.N} M=${cfg.M} nz_u=${res.nu} atoms=${res.na} k=${res.nk} mg=${res.nmg} smallpairs=${res.smallPairs} share=${pct(Math.abs(res.variants[0].Xsmall) / res.variants[0].Mfrak)} ${secs.toFixed(1)}s`);
cap('sweep');
}
}
// negative control (ii): conjugation
let ncRow = null;
{
const j = JLIST[0], { x, E, Z, J0, Atop } = frameOf(j);
const cfg = buildConfig({ x, g: 2, ellBox: boxOf('top', E, Z, 2), A: Atop, Atop, E, Z, J0, zNum: 1, zDen: 1 });
const vs = coefficientVariants(cfg, { nDraws: 0, nPerms: 0 });
const nc = runNoConjugate(cfg, vs[0]);
const scale = Math.abs(nc.conj) + Math.abs(nc.noConjRe) + 1;
assert(Math.abs(nc.noConjIm) > 1e-6 * scale, 'control (ii) inert: the unconjugated ordered-pair sum came out real');
ncRow = { j, g: 2, A: Atop, ...nc };
console.log(`control (ii) conjugation: at j=${j} g=2 A=${Atop} the conjugated X_small = ${fmt(nc.conj)} is real; the unconjugated ordered-pair sum is ${fmt(nc.noConjRe)} + ${fmt(nc.noConjIm)}i`);
}
// negative control (iv): all-ones coefficients
const onesRows = [];
{
for (const j of JLIST.slice(0, 2)) {
const { x, E, Z, J0, Atop } = frameOf(j);
const cfg = buildConfig({ x, g: 2, ellBox: boxOf('top', E, Z, 2), A: Atop, Atop, E, Z, J0, zNum: 1, zDen: 1 });
const vs = coefficientVariants(cfg, { nDraws: 0, nPerms: 0, ones: true });
const res = runMoment(cfg, [vs[vs.length - 1], vs[0]]);
const one = res.variants[0], act = res.variants[1];
const maxc = Math.max(...cfg.ch);
const majorant = 1 * maxc * maxc * res.maxPhi * res.maxPhi * cfg.M * res.zeroPairs;
const count5 = 8 * cfg.N * Atop * (1 + Math.log(2 * Math.min(cfg.N, Atop)));
assert(one.R0 <= majorant * (1 + 1e-9), 'control (iv): the equal-frequency class exceeds its own (5) majorant');
assert(res.zeroPairs <= count5, 'control (iv): the equal-frequency ordered-pair count exceeds the (5) count bound');
assert(one.R0 / one.Mfrak > 0.5, 'control (iv) inert: the equal-frequency class does not dominate the all-ones moment');
onesRows.push({ j, N: cfg.N, M: cfg.M, Mfrak: one.Mfrak, R0share: one.R0 / one.Mfrak, actShare: act.R0 / act.Mfrak, zeroPairs: res.zeroPairs, count5, majorant });
}
console.log('control (iv) all-ones coefficients, equal-frequency domination (top box, g=2, A=Atop):');
for (const r of onesRows) console.log(` j=${r.j} N=${r.N} M=${r.M}: Mfrak(ones)=${fmt(r.Mfrak)}, R=0 share ${pct(r.R0share)} (actual A1 on the same box: ${pct(r.actShare)}); ${r.zeroPairs} equal-frequency ordered pairs vs the (5) count bound ${r.count5.toExponential(3)}; class majorant ${fmt(r.majorant)}`);
}
// endpoint sensitivity
let epRow = null;
{
const j = JLIST[Math.min(2, JLIST.length - 1)], { x, E, Z, J0, Atop } = frameOf(j);
const base = { x, g: 2, ellBox: boxOf('top', E, Z, 2), A: Atop, Atop, E, Z, J0 };
const cA = buildConfig({ ...base, zNum: 1, zDen: 1 }), cB = buildConfig({ ...base, zNum: 3, zDen: 4 });
const ra = runMoment(cA, coefficientVariants(cA, { nDraws: 0, nPerms: 0 })).variants[0];
const rb = runMoment(cB, coefficientVariants(cB, { nDraws: 0, nPerms: 0 })).variants[0];
epRow = { j, zx: { Mfrak: ra.Mfrak, Xsmall: ra.Xsmall }, z34: { Mfrak: rb.Mfrak, Xsmall: rb.Xsmall } };
console.log(`endpoint sensitivity at j=${j} g=2 A=${Atop}: z=x gives Mfrak=${fmt(ra.Mfrak)} X_small=${fmt(ra.Xsmall)}; z=3x/4 gives Mfrak=${fmt(rb.Mfrak)} X_small=${fmt(rb.Xsmall)}`);
}
// ---------------------------------------------------------------------------
// 7. Tables
// ---------------------------------------------------------------------------
const pick = (res, name) => res.variants.find((v) => v.name === name);
const arm = (res, pre, key) => res.variants.filter((v) => new RegExp('^' + pre + '\\d+$').test(v.name)).map((v) => v[key]);
console.log('');
console.log('TABLE 0 — the frame is not degenerate: the live prime-power sector of (13) and the live gcd classes');
console.log(' j box g A J0 Z N M nz_u live r (count) proper powers u with >1 term gcd classes d<=J0 with >=2 support u');
for (const r of table) {
const d = r.diag;
const rl = d.rList.length ? d.rList.map((v, i) => `${v}(${d.rCounts[i]})`).join(' ') : (d.lowTerm ? 'none (pure Mobius sector)' : 'none');
console.log(` ${String(r.j).padStart(2)} ${r.box} ${r.g} ${String(r.A).padStart(2)} ${String(r.J0).padStart(2)} ${String(r.Z).padStart(2)} ${String(r.N).padStart(6)} ${String(r.M).padStart(6)} ${String(r.res.nu).padStart(5)} ${rl.padEnd(36)} ${(d.proper.length ? d.proper.join(',') : '-').padStart(13)} ${String(d.multi).padStart(14)} ${String(d.liveClasses).padStart(35)}`);
}
console.log('');
console.log('TABLE 1 — the moment Mfrak. n per row: |I|=M values of m, nz_u divisors u with A_right(gu)!=0, |H|=A harmonics');
console.log(' j box g A N M nz_u atoms Mfrak(A1) Mfrak(|A1|) Mfrak(random) mean +- sd Mfrak(perm) mean +- sd Mfrak(A0) budget v');
for (const r of table) {
const s = stats(arm(r.res, 'rnd', 'Mfrak')), sp = stats(arm(r.res, 'perm', 'Mfrak'));
console.log(` ${String(r.j).padStart(2)} ${r.box} ${r.g} ${String(r.A).padStart(2)} ${String(r.N).padStart(6)} ${String(r.M).padStart(6)} ${String(r.res.nu).padStart(5)} ${String(r.res.na).padStart(6)} ${fmt(pick(r.res, 'A1').Mfrak)} ${fmt(pick(r.res, 'absA1').Mfrak)} ${fmt(s.mu)} +- ${fmt(s.sd)} ${fmt(sp.mu)} +- ${fmt(sp.sd)} ${fmt(pick(r.res, 'A0').Mfrak)} ${fmt(r.budget)} ${r.v.toExponential(2)}`);
}
console.log('');
console.log('TABLE 2 — X_small of (21) and the four ordered-pair classes as shares of Mfrak (actual coefficient A1)');
console.log(' j box g A X_small(A1) |Xs|/Mfrak R=0 share periods j>J0 share small pairs sieve cancel');
let roundFloor = 0;
for (const r of table) {
const a1 = pick(r.res, 'A1');
const empty = r.res.smallPairs === 0;
r.empty = empty;
r.share = Math.abs(a1.Xsmall) / a1.Mfrak;
if (!empty) roundFloor = Math.max(roundFloor, 1e-15 * Math.sqrt(r.res.nk * r.M) * a1.XsmallAbsMass / Math.abs(a1.Xsmall));
console.log(` ${String(r.j).padStart(2)} ${r.box} ${r.g} ${String(r.A).padStart(2)} ${empty ? 'CLASS EMPTY' : fmt(a1.Xsmall)} ${pct(r.share).padStart(9)} ${pct(a1.R0 / a1.Mfrak).padStart(9)} ${r.res.periodEmpty ? '0 (empty)' : 'NONEMPTY'} ${pct(a1.big / a1.Mfrak).padStart(10)} ${String(r.res.smallPairs).padStart(11)} ${empty ? '-' : (a1.XsmallAbsMass / Math.abs(a1.Xsmall)).toFixed(1) + 'x'}`);
}
console.log(` worst-case double-rounding floor over these rows, relative to |X_small|: ${roundFloor.toExponential(2)}`);
console.log('');
console.log('TABLE 3 — the two nulls, per scale. rank = position of |X_small(actual)| among itself and the 8 null values, smallest first; 1/9 is the only per-scale advantage F2 recognises');
console.log(' j box g A |Xs|(A1) |Xs|(|b|) random: median [min,max] rank perm: median [min,max] rank rho(rnd) rho(perm)');
for (const r of table) {
const a1 = Math.abs(pick(r.res, 'A1').Xsmall), ab = Math.abs(pick(r.res, 'absA1').Xsmall);
const dr = arm(r.res, 'rnd', 'Xsmall').map(Math.abs), dp = arm(r.res, 'perm', 'Xsmall').map(Math.abs);
const mr = median(dr), mp = median(dp);
r.rankR = 1 + dr.filter((v) => v < a1).length; r.rankP = 1 + dp.filter((v) => v < a1).length;
r.rhoR = a1 / mr; r.rhoP = a1 / mp;
console.log(` ${String(r.j).padStart(2)} ${r.box} ${r.g} ${String(r.A).padStart(2)} ${fmt(a1)} ${fmt(ab)} ${fmt(mr)} [${fmt(Math.min(...dr))},${fmt(Math.max(...dr))}] ${r.rankR}/9 ${fmt(mp)} [${fmt(Math.min(...dp))},${fmt(Math.max(...dp))}] ${r.rankP}/9 ${r.rhoR.toFixed(3).padStart(8)} ${r.rhoP.toFixed(3).padStart(9)}`);
}
console.log('');
console.log('TABLE 4 — exponent fits and the pre-registered falsifiers F1/F2/F3 (fit over the points sharing one J0; here J0=9 at every scale)');
const families = [];
for (const cf of CONFIGS) {
const rows = table.filter((r) => r.box === cf.box && r.g === cf.g && r.band === cf.band && r.res.smallPairs > 0);
if (rows.length < 3) continue;
families.push({ ...cf, fit: rows });
}
for (const fam of families) {
const xs = fam.fit.map((r) => r.j);
const sl = (pre, key, f) => stats([...Array(pre === 'rnd' ? NDRAWS : NPERMS).keys()].map((k) => slope(xs, fam.fit.map((r) => Math.log2(f(pick(r.res, 'A1')[key]) / f(arm(r.res, pre, key)[k]))))));
const abs = Math.abs, id = (z) => z;
const st = {
mA: slope(xs, fam.fit.map((r) => Math.log2(pick(r.res, 'A1').Mfrak))),
mAbs: slope(xs, fam.fit.map((r) => Math.log2(pick(r.res, 'absA1').Mfrak))),
mRnd: stats([...Array(NDRAWS).keys()].map((k) => slope(xs, fam.fit.map((r) => Math.log2(arm(r.res, 'rnd', 'Mfrak')[k]))))),
mBud: slope(xs, fam.fit.map((r) => Math.log2(r.budget))),
xA: slope(xs, fam.fit.map((r) => Math.log2(Math.abs(pick(r.res, 'A1').Xsmall)))),
xRnd: stats([...Array(NDRAWS).keys()].map((k) => slope(xs, fam.fit.map((r) => Math.log2(Math.abs(arm(r.res, 'rnd', 'Xsmall')[k])))))),
xPrm: stats([...Array(NPERMS).keys()].map((k) => slope(xs, fam.fit.map((r) => Math.log2(Math.abs(arm(r.res, 'perm', 'Xsmall')[k])))))),
rMf: sl('rnd', 'Mfrak', id),
rXs: sl('rnd', 'Xsmall', abs),
pXs: sl('perm', 'Xsmall', abs),
shares: fam.fit.map((r) => r.share),
ranksR: fam.fit.map((r) => r.rankR), ranksP: fam.fit.map((r) => r.rankP),
rhoR: fam.fit.map((r) => r.rhoR), rhoP: fam.fit.map((r) => r.rhoP),
};
fam.st = st;
const f1 = st.rXs.mu + st.rXs.sd < 0, f3 = st.pXs.mu + st.pXs.sd < 0;
const f2 = st.ranksR.some((v) => v === 1), f2p = st.ranksP.some((v) => v === 1);
console.log(` ${fam.box} box, g=${fam.g}, band ${fam.band === 'top' ? 'A~x^(3/50)' : 'A=1'}; fit over j=${xs.join(',')} (n=${xs.length} scales, J0=9)`);
console.log(` X_small share of Mfrak: ${st.shares.map((v) => pct(v)).join(' ')}`);
console.log(` d log2 Mfrak / d log2 x: actual ${st.mA.toFixed(3)} |b| ${st.mAbs.toFixed(3)} random ${st.mRnd.mu.toFixed(3)} +- ${st.mRnd.sd.toFixed(3)} budget ${st.mBud.toFixed(3)} generic N^3 exponent 1.500`);
console.log(` d log2 |X_small| / d log2 x: actual ${st.xA.toFixed(3)} random ${st.xRnd.mu.toFixed(3)} +- ${st.xRnd.sd.toFixed(3)} permuted ${st.xPrm.mu.toFixed(3)} +- ${st.xPrm.sd.toFixed(3)}`);
console.log(` F1 slope of log2(actual/random) per draw: Mfrak ${st.rMf.mu.toFixed(4)} +- ${st.rMf.sd.toFixed(4)} X_small ${st.rXs.mu.toFixed(4)} +- ${st.rXs.sd.toFixed(4)}`);
console.log(` F3 slope of log2(actual/permuted) per permutation: X_small ${st.pXs.mu.toFixed(4)} +- ${st.pXs.sd.toFixed(4)}`);
console.log(` rho = |X_small(actual)|/median(null) random: ${st.rhoR.map((v) => v.toFixed(3)).join(' ')} permuted: ${st.rhoP.map((v) => v.toFixed(3)).join(' ')}`);
console.log(` F2 per-scale ranks random: ${st.ranksR.map((v) => v + '/9').join(' ')} permuted: ${st.ranksP.map((v) => v + '/9').join(' ')}`);
console.log(` VERDICT F1 (random): ${f1 ? 'mean slope + sd < 0 — consistent with extra cancellation over this finite range only' : 'mean slope + sd >= 0 — NO support for Mobius-sign cancellation in the small-j kernel in this frame'}`);
console.log(` VERDICT F2 (random): ${f2 ? 'the actual value is below all eight draws at some scale' : 'the actual value lies inside the spread of the eight draws at every scale — no per-scale advantage'}`);
console.log(` VERDICT F1/F2 (perm): ${f3 ? 'permutation slope mean + sd < 0' : 'permutation slope mean + sd >= 0 — NO support'}; ${f2p ? 'below all eight permutations at some scale' : 'inside the permutation spread at every scale'}`);
}
// TABLE 5 — descriptive aggregate. Under the null that the actual signs behave
// like one more draw, the rank of |X_small(actual)| among the nine values is
// uniform on 1..9. This is a summary, not the pre-registered test.
const live = table.filter((r) => r.res.smallPairs > 0);
const meanRankR = live.reduce((a, r) => a + r.rankR, 0) / live.length;
const meanRankP = live.reduce((a, r) => a + r.rankP, 0) / live.length;
const nullSd = Math.sqrt((81 - 1) / 12 / live.length);
const belowMedR = live.filter((r) => r.rhoR < 1).length, belowMedP = live.filter((r) => r.rhoP < 1).length;
const gm = (f) => Math.exp(live.map((r) => Math.log(f(r))).reduce((a, b) => a + b, 0) / live.length);
const gmX = gm((r) => Math.abs(pick(r.res, 'A1').Xsmall) / stats(arm(r.res, 'rnd', 'Xsmall').map(Math.abs)).mu);
const gmP = gm((r) => Math.abs(pick(r.res, 'A1').Xsmall) / stats(arm(r.res, 'perm', 'Xsmall').map(Math.abs)).mu);
const gmAbsX = gm((r) => Math.abs(pick(r.res, 'A1').Xsmall) / Math.abs(pick(r.res, 'absA1').Xsmall));
const gmM = gm((r) => pick(r.res, 'A1').Mfrak / stats(arm(r.res, 'rnd', 'Mfrak')).mu);
const shareStats = stats(live.map((r) => r.share));
const aggregate = { n: live.length, meanRankR, meanRankP, nullSd, belowMedR, belowMedP, gmX, gmP, gmAbsX, gmM, shareMean: shareStats.mu, shareMin: Math.min(...live.map((r) => r.share)), shareMax: Math.max(...live.map((r) => r.share)) };
console.log('');
console.log('TABLE 5 — descriptive aggregate over every configuration with a nonempty small-j class');
console.log(' (summary added after the pre-registered fits in TABLE 4; it is not the pre-registered test)');
console.log(` configurations n = ${live.length} (${JLIST.length} dyadic scales x ${CONFIGS.length} boxes)`);
console.log(` X_small share of Mfrak: mean ${pct(aggregate.shareMean)}, range ${pct(aggregate.shareMin)} to ${pct(aggregate.shareMax)} (the record's frame: 0.02% to 2.88%)`);
console.log(` mean rank of |X_small(actual)| among the nine values: random ${meanRankR.toFixed(2)} permuted ${meanRankP.toFixed(2)} null expectation 5.00, null sd of this mean ${nullSd.toFixed(2)}`);
console.log(` configurations with |X_small(actual)| below the null median: random ${belowMedR} of ${live.length}, permuted ${belowMedP} of ${live.length} (null expectation ${(live.length / 2).toFixed(1)})`);
console.log(` geometric mean of |X_small(actual)| / mean|X_small(random)|: ${gmX.toFixed(3)} / mean|X_small(permuted)|: ${gmP.toFixed(3)}`);
console.log(` geometric mean of |X_small(actual)| / |X_small(|b|)|: ${gmAbsX.toFixed(3)}`);
console.log(` geometric mean of Mfrak(actual) / mean Mfrak(random): ${gmM.toFixed(4)}`);
const artifact = {
schema: 1, aggregate,
scope: 'Finite measurement of an existing ordered-pair decomposition in a RESCALED frame (Z=W=J0=9 constant, M=floor(x^(1/5))). No asymptotic rate, power saving or twin margin is measured, and the short m-average is not the real one.',
frame: { ZFIX, MEXP, Efn: 'floor(x^(9/20))', Afn: 'max(1,round(x^(3/50)))', boxes: 'top ell in (9E,18E], low ell in (E,2E]' },
jlist: JLIST, nDraws: NDRAWS, nPerms: NPERMS, configs: CONFIGS,
reciprocity: rc, periodDetector: periodRow, noConjugate: ncRow, ones: onesRows, endpoint: epRow,
table: table.map((r) => ({ j: r.j, x: r.x, box: r.box, g: r.g, band: r.band, A: r.A, N: r.N, M: r.M, E: r.E, Z: r.Z, J0: r.J0, B: r.B, v: r.v, f: r.f, budget: r.budget, count5: r.count5, secs: r.secs, share: r.share, rankR: r.rankR, rankP: r.rankP, rhoR: r.rhoR, rhoP: r.rhoP, diag: r.diag, nu: r.res.nu, na: r.res.na, nk: r.res.nk, nmg: r.res.nmg, zeroPairs: r.res.zeroPairs, smallPairs: r.res.smallPairs, periodEmpty: r.res.periodEmpty, zeroFreqSmallEmpty: r.res.zeroFreqSmallEmpty, minQ: r.res.minQ, variants: r.res.variants })),
families: families.map((f) => ({ box: f.box, g: f.g, band: f.band, fitJ: f.fit.map((r) => r.j), stats: f.st })),
};
fs.writeFileSync(path.join(__dirname, 'kernel-sign-rescaled.json'), JSON.stringify(artifact, null, 2) + '\n');
console.log('');
console.log(`artifact: kernel-sign-rescaled.json (${JLIST.length} dyadic scales, ${table.length} configurations, ${NDRAWS} seeded draws and ${NPERMS} seeded permutations each)`);
console.log('MEASURED ONLY: no power saving, no asymptotic rate and no twin margin follows; (21) and the global margin remain OPEN. The frame buys a visible X_small by shortening the m-average, and says nothing about the long one.');
// ============================================================================
// OUTPUT — EMBEDDED, do not hand-edit. Regenerate:
// node research/qc/embed.js research/kernel-sign-rescaled.js
// invocation: node research/kernel-sign-rescaled.js
// code-sha256: 744e5e835164ee0c961192f55f03771340e94c0626491b4649ca1d38961fcce9
// out-sha256: 4aee9d0e1e3b29541b6f905aea6e8b4775762582605cfe4f27bf05ce11040ed8
// body-lines: 170
// streams: stdout
// node: v26.0.0
// embedded: 2026-09-11
// elapsed: 0.5 s
// ============================================================================
// KERNEL SIGN CONTROL, RESCALED FRAME — actual A_right(gu) against |A_right|, seeded random signs and seeded sign permutations
// box delta=8/25 nu=9/20 as in kernel-sign-control.md; RESCALED: Z=W=J0=9 constant (was max(2,floor(x^(1/20)))=2), M=floor(x^(1/5)) (was floor(x^(14/25)))
// E=floor(x^(9/20)), J=(E,2E]; top expanded box ell in (9E,18E], low expanded box ell in (E,2E]; u=ell/g; native z0=x/2, z=x; sigma=-1
// c_h = -W(h/(T+1))/(2 pi i h) with Vaaler W and T=4*Atop, A=max(1,round(x^(3/50))) or 1; draws=8, permutations=8
// dyadic scales j: 18,20,22,24,26
// pre-registered in prereg.md: F1 = section 0 slope rule (mean slope + sd >= 0 ==> no support), F2 = per-scale spread rule, F3 = the same against the permutation null
// control (iii) reciprocity: 6552/6552 shifted-endpoint kernels equal the native kernel; 6547 unshifted ones differ
// identity check — divisor sieve against literal ordered-pair expansion (new frame):
// x=4096 g=1 A=2 Z=J0=9 N=27 M=24: 196 ordered pairs (R=0: 16, j<=J0: 152, periods: 0); 5 quantities agree
// x=4096 g=2 A=2 Z=J0=9 N=13 M=24: 64 ordered pairs (R=0: 8, j<=J0: 48, periods: 0); 5 quantities agree
// x=8192 g=1 A=1 Z=J0=9 N=27 M=24: 49 ordered pairs (R=0: 7, j<=J0: 38, periods: 0); 5 quantities agree
// x=8192 g=2 A=3 Z=J0=9 N=13 M=24: 144 ordered pairs (R=0: 14, j<=J0: 108, periods: 0); 5 quantities agree
// control (i) complete periods: detector N=6 A=8 M=20 J0=9 has 62 period pairs of 2304; dropping them moves the nonzero j<=J0 kernel from 8.7637e-3 by -2.0005e-3
// control (ii) conjugation: at j=18 g=2 A=2 the conjugated X_small = 8.0793e+0 is real; the unconjugated ordered-pair sum is 2.0075e+1 + -1.4788e+1i
// control (iv) all-ones coefficients, equal-frequency domination (top box, g=2, A=Atop):
// j=18 N=1233 M=12: Mfrak(ones)=7.2431e+0, R=0 share 1715.98% (actual A1 on the same box: 85.69%); 2878 equal-frequency ordered pairs vs the (5) count bound 4.708e+4; class majorant 6.6113e+2
// j=20 N=2304 M=16: Mfrak(ones)=6.5864e+0, R=0 share 4713.29% (actual A1 on the same box: 100.95%); 5376 equal-frequency ordered pairs vs the (5) count bound 8.797e+4; class majorant 1.6466e+3
// endpoint sensitivity at j=22 g=2 A=2: z=x gives Mfrak=2.1003e+2 X_small=2.4461e+1; z=3x/4 gives Mfrak=2.6233e+2 X_small=7.6985e+1
//
// TABLE 0 — the frame is not degenerate: the live prime-power sector of (13) and the live gcd classes
// j box g A J0 Z N M nz_u live r (count) proper powers u with >1 term gcd classes d<=J0 with >=2 support u
// 18 top 2 2 9 9 1233 12 258 5(13) 7(43) 8(147) 9(57) 8,9 2 9
// 18 top 2 1 9 9 1233 12 258 5(13) 7(43) 8(147) 9(57) 8,9 2 9
// 18 top 1 2 9 9 2466 12 464 5(33) 7(122) 8(147) 9(166) 8,9 4 9
// 18 low 1 2 9 9 274 12 166 none (pure Mobius sector) - 0 6
// 20 top 2 2 9 9 2304 16 469 5(22) 7(74) 8(273) 9(104) 8,9 4 9
// 20 top 2 1 9 9 2304 16 469 5(22) 7(74) 8(273) 9(104) 8,9 4 9
// 20 top 1 2 9 9 4608 16 861 5(63) 7(223) 8(273) 9(310) 8,9 8 9
// 20 low 1 2 9 9 512 16 310 none (pure Mobius sector) - 0 6
// 22 top 2 2 9 9 4297 21 873 5(39) 7(138) 8(508) 9(192) 8,9 4 9
// 22 top 2 1 9 9 4297 21 873 5(39) 7(138) 8(508) 9(192) 8,9 4 9
// 22 top 1 2 9 9 8595 21 1604 5(115) 7(414) 8(508) 9(580) 8,9 13 9
// 22 low 1 2 9 9 955 21 580 none (pure Mobius sector) - 0 6
// 24 top 2 3 9 9 8019 27 1640 5(72) 7(260) 8(952) 9(364) 8,9 8 9
// 24 top 2 1 9 9 8019 27 1640 5(72) 7(260) 8(952) 9(364) 8,9 8 9
// 24 top 1 3 9 9 16038 27 3008 5(217) 7(776) 8(952) 9(1086) 8,9 23 9
// 24 low 1 3 9 9 1782 27 1086 none (pure Mobius sector) - 0 6
// 26 top 2 3 9 9 14967 36 3042 5(136) 7(482) 8(1769) 9(671) 8,9 16 9
// 26 top 2 1 9 9 14967 36 3042 5(136) 7(482) 8(1769) 9(671) 8,9 16 9
// 26 top 1 3 9 9 29934 36 5596 5(407) 7(1445) 8(1769) 9(2019) 8,9 44 9
// 26 low 1 3 9 9 3326 36 2019 none (pure Mobius sector) - 0 6
//
// TABLE 1 — the moment Mfrak. n per row: |I|=M values of m, nz_u divisors u with A_right(gu)!=0, |H|=A harmonics
// j box g A N M nz_u atoms Mfrak(A1) Mfrak(|A1|) Mfrak(random) mean +- sd Mfrak(perm) mean +- sd Mfrak(A0) budget v
// 18 top 2 2 1233 12 258 516 3.9527e+1 2.3687e+1 2.6930e+1 +- 7.6008e+0 2.7206e+1 +- 8.7068e+0 0 8.6331e+11 3.54e+1
// 18 top 2 1 1233 12 258 258 1.4167e+2 4.8176e+1 1.4366e+2 +- 5.3494e+1 1.1144e+2 +- 2.8403e+1 0 4.4350e+11 1.77e+1
// 18 top 1 2 2466 12 464 928 1.2427e+2 3.5658e+1 6.8312e+1 +- 2.0890e+1 6.6088e+1 +- 1.7804e+1 0 3.5480e+12 1.77e+1
// 18 low 1 2 274 12 166 332 5.3222e+2 1.2870e+3 7.1126e+2 +- 1.2943e+2 6.6180e+2 +- 1.4904e+2 1.4812e+1 1.3119e+11 1.59e+2
// 20 top 2 2 2304 16 469 938 8.1675e+1 4.7895e+1 9.7603e+1 +- 4.7392e+1 7.4682e+1 +- 2.0875e+1 0 8.9497e+12 5.69e+1
// 20 top 2 1 2304 16 469 469 3.3832e+2 9.6515e+1 3.3968e+2 +- 1.4136e+2 2.8665e+2 +- 2.7588e+1 0 4.5521e+12 2.84e+1
// 20 top 1 2 4608 16 861 1722 1.9888e+2 5.1468e+1 1.9691e+2 +- 6.3020e+1 2.0099e+2 +- 4.0004e+1 0 3.6417e+13 2.84e+1
// 20 low 1 2 512 16 310 620 1.9691e+3 2.3398e+3 1.7236e+3 +- 4.5321e+2 1.9276e+3 +- 3.9051e+2 4.4285e+1 1.6568e+12 2.56e+2
// 22 top 2 2 4297 21 873 1746 2.1003e+2 1.3010e+2 1.7286e+2 +- 2.2657e+1 1.7169e+2 +- 4.1557e+1 0 9.4235e+13 9.30e+1
// 22 top 2 1 4297 21 873 873 6.7304e+2 2.9325e+2 6.9593e+2 +- 1.9557e+2 7.6315e+2 +- 1.8264e+2 0 4.7619e+13 4.65e+1
// 22 top 1 2 8595 21 1604 3208 5.4686e+2 2.0056e+2 3.7490e+2 +- 7.5626e+1 4.1594e+2 +- 7.7057e+1 0 3.8104e+14 4.65e+1
// 22 low 1 2 955 21 580 1160 7.0295e+3 6.6030e+3 4.9044e+3 +- 1.1712e+3 6.0061e+3 +- 1.7801e+3 1.3461e+2 2.0843e+13 4.18e+2
// 24 top 2 3 8019 27 1640 4920 2.2596e+2 2.1460e+2 2.6549e+2 +- 4.1571e+1 2.5909e+2 +- 4.1099e+1 0 1.5218e+15 2.32e+2
// 24 top 2 1 8019 27 1640 1640 2.3607e+3 1.1868e+3 1.8829e+3 +- 4.6060e+2 1.8888e+3 +- 4.4309e+2 0 5.1160e+14 7.75e+1
// 24 top 1 3 16038 27 3008 9024 6.6716e+2 1.9872e+2 5.1807e+2 +- 1.3282e+2 4.8768e+2 +- 1.1328e+2 0 6.1131e+15 1.16e+2
// 24 low 1 3 1782 27 1086 3258 1.0275e+4 1.2846e+4 8.1531e+3 +- 1.3101e+3 8.5213e+3 +- 1.2305e+3 1.6522e+2 3.9631e+14 1.05e+3
// 26 top 2 3 14967 36 3042 9126 5.3617e+2 5.3875e+2 6.2861e+2 +- 1.8418e+2 6.4782e+2 +- 9.6935e+1 0 1.5878e+16 3.74e+2
// 26 top 2 1 14967 36 3042 3042 4.1544e+3 3.4389e+3 4.5329e+3 +- 7.1358e+2 4.5058e+3 +- 1.0484e+3 0 5.3209e+15 1.25e+2
// 26 top 1 3 29934 36 5596 16788 1.2542e+3 7.9580e+2 1.3914e+3 +- 1.8487e+2 1.2708e+3 +- 1.2411e+2 0 6.3681e+16 1.87e+2
// 26 low 1 3 3326 36 2019 6057 3.1953e+4 3.0619e+4 2.8392e+4 +- 3.5292e+3 2.4897e+4 +- 1.9022e+3 4.4000e+2 4.7961e+15 1.68e+3
//
// TABLE 2 — X_small of (21) and the four ordered-pair classes as shares of Mfrak (actual coefficient A1)
// j box g A X_small(A1) |Xs|/Mfrak R=0 share periods j>J0 share small pairs sieve cancel
// 18 top 2 2 8.0793e+0 20.44% 85.69% 0 (empty) -6.13% 244592 15.5x
// 18 top 2 1 2.1178e+1 14.95% 83.98% 0 (empty) 1.07% 61148 20.5x
// 18 top 1 2 4.7065e+1 37.87% 58.48% 0 (empty) 3.65% 759056 8.0x
// 18 low 1 2 -1.0888e+2 20.46% 123.59% 0 (empty) -3.13% 106408 13.9x
// 20 top 2 2 9.6598e+0 11.83% 100.95% 0 (empty) -12.78% 812816 29.9x
// 20 top 2 1 9.3676e+0 2.77% 93.09% 0 (empty) 4.14% 203204 125.7x
// 20 top 1 2 1.6197e+1 8.14% 93.56% 0 (empty) -1.70% 2620672 54.7x
// 20 low 1 2 -8.3108e+1 4.22% 103.83% 0 (empty) 0.39% 371208 66.2x
// 22 top 2 2 2.4461e+1 11.65% 90.07% 0 (empty) -1.72% 2814288 29.6x
// 22 top 2 1 -7.6498e+0 1.14% 104.43% 0 (empty) -3.30% 703572 335.3x
// 22 top 1 2 8.9092e+1 16.29% 79.97% 0 (empty) 3.74% 9103368 24.9x
// 22 low 1 2 1.1242e+3 15.99% 82.82% 0 (empty) 1.19% 1300144 15.6x
// 24 top 2 3 -5.2680e+0 2.33% 111.90% 0 (empty) -9.56% 22292424 181.7x
// 24 top 2 1 5.2224e+2 22.12% 75.27% 0 (empty) 2.60% 2476936 14.8x
// 24 top 1 3 1.1469e+2 17.19% 86.17% 0 (empty) -3.36% 71892846 26.2x
// 24 low 1 3 1.2807e+3 12.46% 87.43% 0 (empty) 0.11% 10240992 21.9x
// 26 top 2 3 -1.0824e+2 20.19% 118.21% 0 (empty) 1.98% 76836438 23.7x
// 26 top 2 1 1.6564e+2 3.99% 106.78% 0 (empty) -10.77% 8537382 108.7x
// 26 top 1 3 -2.4915e+2 19.87% 115.66% 0 (empty) 4.21% 249140070 30.6x
// 26 low 1 3 6.9735e+3 21.82% 81.89% 0 (empty) -3.71% 35431380 12.4x
// worst-case double-rounding floor over these rows, relative to |X_small|: 4.84e-11
//
// TABLE 3 — the two nulls, per scale. rank = position of |X_small(actual)| among itself and the 8 null values, smallest first; 1/9 is the only per-scale advantage F2 recognises
// j box g A |Xs|(A1) |Xs|(|b|) random: median [min,max] rank perm: median [min,max] rank rho(rnd) rho(perm)
// 18 top 2 2 8.0793e+0 1.0249e+1 4.2857e+0 [8.9782e-1,1.8386e+1] 7/9 5.3726e+0 [9.0731e-1,1.9609e+1] 7/9 1.885 1.504
// 18 top 2 1 2.1178e+1 8.9818e+1 3.0304e+1 [9.9950e+0,1.1061e+2] 4/9 2.3933e+1 [1.1808e+1,5.4474e+1] 5/9 0.699 0.885
// 18 top 1 2 4.7065e+1 2.1520e+1 1.5770e+1 [7.5783e+0,3.3319e+1] 9/9 8.7771e+0 [1.7108e+0,2.9070e+1] 9/9 2.985 5.362
// 18 low 1 2 1.0888e+2 6.4152e+2 1.4557e+2 [8.5096e+0,2.6349e+2] 4/9 1.2294e+2 [3.1102e+1,2.9568e+2] 4/9 0.748 0.886
// 20 top 2 2 9.6598e+0 3.2383e+1 2.1685e+1 [8.8521e+0,9.6241e+1] 3/9 1.1954e+1 [2.9099e+0,3.0251e+1] 4/9 0.445 0.808
// 20 top 2 1 9.3676e+0 2.0083e+2 7.3390e+1 [7.9246e+0,2.4920e+2] 2/9 5.3227e+1 [1.0134e+1,8.7636e+1] 1/9 0.128 0.176
// 20 top 1 2 1.6197e+1 1.3670e+2 3.9287e+1 [5.6570e+0,8.3015e+1] 3/9 1.8035e+1 [5.9044e+0,6.2436e+1] 3/9 0.412 0.898
// 20 low 1 2 8.3108e+1 3.0948e+2 4.0597e+2 [1.1552e+2,8.1064e+2] 1/9 2.8662e+2 [2.1320e+0,6.2997e+2] 3/9 0.205 0.290
// 22 top 2 2 2.4461e+1 5.3256e+1 1.8109e+1 [1.2981e+0,4.3056e+1] 7/9 3.5551e+1 [4.3059e+0,7.4859e+1] 5/9 1.351 0.688
// 22 top 2 1 7.6498e+0 2.7770e+2 1.4075e+2 [7.5373e+0,2.6346e+2] 2/9 1.0915e+2 [3.6775e+1,3.5278e+2] 1/9 0.054 0.070
// 22 top 1 2 8.9092e+1 2.2199e+2 4.3484e+1 [1.5527e+1,1.4680e+2] 6/9 5.8226e+1 [1.8392e+1,1.2850e+2] 7/9 2.049 1.530
// 22 low 1 2 1.1242e+3 9.8496e+2 8.9405e+2 [4.0855e+2,2.5175e+3] 5/9 9.4175e+2 [1.9628e+2,3.1405e+3] 6/9 1.257 1.194
// 24 top 2 3 5.2680e+0 2.5211e+1 2.6841e+1 [7.3691e+0,6.2805e+1] 1/9 2.8284e+1 [7.9222e+0,7.3231e+1] 1/9 0.196 0.186
// 24 top 2 1 5.2224e+2 6.2602e+2 3.4143e+2 [1.3328e+2,8.5959e+2] 8/9 4.8046e+2 [1.3751e+2,6.3563e+2] 7/9 1.530 1.087
// 24 top 1 3 1.1469e+2 3.0395e+2 1.2619e+2 [4.6178e+1,1.7626e+2] 5/9 1.1042e+2 [7.7548e+0,2.6881e+2] 5/9 0.909 1.039
// 24 low 1 3 1.2807e+3 4.2203e+3 9.9771e+2 [2.8901e+2,2.8448e+3] 7/9 5.8668e+2 [1.5627e+2,2.5121e+3] 7/9 1.284 2.183
// 26 top 2 3 1.0824e+2 9.2303e+1 1.2743e+2 [2.9382e+1,3.6769e+2] 4/9 7.0987e+1 [5.8510e+0,1.7384e+2] 8/9 0.849 1.525
// 26 top 2 1 1.6564e+2 8.9671e+2 5.3559e+2 [1.3046e+2,1.0051e+3] 2/9 9.4551e+2 [2.5571e+2,1.5738e+3] 1/9 0.309 0.175
// 26 top 1 3 2.4915e+2 7.8922e+2 1.0519e+2 [1.8328e+1,2.9241e+2] 8/9 1.3932e+2 [6.3278e+0,4.6630e+2] 7/9 2.369 1.788
// 26 low 1 3 6.9735e+3 3.5796e+3 1.7432e+3 [2.4993e+2,7.4420e+3] 8/9 1.2771e+3 [4.8202e+2,3.7464e+3] 9/9 4.000 5.461
//
// TABLE 4 — exponent fits and the pre-registered falsifiers F1/F2/F3 (fit over the points sharing one J0; here J0=9 at every scale)
// top box, g=2, band A~x^(3/50); fit over j=18,20,22,24,26 (n=5 scales, J0=9)
// X_small share of Mfrak: 20.44% 11.83% 11.65% 2.33% 20.19%
// d log2 Mfrak / d log2 x: actual 0.450 |b| 0.559 random 0.534 +- 0.062 budget 1.787 generic N^3 exponent 1.500
// d log2 |X_small| / d log2 x: actual 0.331 random 0.459 +- 0.188 permuted 0.393 +- 0.196
// F1 slope of log2(actual/random) per draw: Mfrak -0.0843 +- 0.0616 X_small -0.1288 +- 0.1877
// F3 slope of log2(actual/permuted) per permutation: X_small -0.0626 +- 0.1962
// rho = |X_small(actual)|/median(null) random: 1.885 0.445 1.351 0.196 0.849 permuted: 1.504 0.808 0.688 0.186 1.525
// F2 per-scale ranks random: 7/9 3/9 7/9 1/9 4/9 permuted: 7/9 4/9 5/9 1/9 8/9
// VERDICT F1 (random): mean slope + sd >= 0 — NO support for Mobius-sign cancellation in the small-j kernel in this frame
// VERDICT F2 (random): the actual value is below all eight draws at some scale
// VERDICT F1/F2 (perm): permutation slope mean + sd >= 0 — NO support; below all eight permutations at some scale
// top box, g=2, band A=1; fit over j=18,20,22,24,26 (n=5 scales, J0=9)
// X_small share of Mfrak: 14.95% 2.77% 1.14% 22.12% 3.99%
// d log2 Mfrak / d log2 x: actual 0.628 |b| 0.797 random 0.633 +- 0.075 budget 1.696 generic N^3 exponent 1.500
// d log2 |X_small| / d log2 x: actual 0.587 random 0.486 +- 0.213 permuted 0.676 +- 0.152
// F1 slope of log2(actual/random) per draw: Mfrak -0.0059 +- 0.0755 X_small 0.1010 +- 0.2126
// F3 slope of log2(actual/permuted) per permutation: X_small -0.0893 +- 0.1523
// rho = |X_small(actual)|/median(null) random: 0.699 0.128 0.054 1.530 0.309 permuted: 0.885 0.176 0.070 1.087 0.175
// F2 per-scale ranks random: 4/9 2/9 2/9 8/9 2/9 permuted: 5/9 1/9 1/9 7/9 1/9
// VERDICT F1 (random): mean slope + sd >= 0 — NO support for Mobius-sign cancellation in the small-j kernel in this frame
// VERDICT F2 (random): the actual value lies inside the spread of the eight draws at every scale — no per-scale advantage
// VERDICT F1/F2 (perm): permutation slope mean + sd >= 0 — NO support; below all eight permutations at some scale
// top box, g=1, band A~x^(3/50); fit over j=18,20,22,24,26 (n=5 scales, J0=9)
// X_small share of Mfrak: 37.87% 8.14% 16.29% 17.19% 19.87%
// d log2 Mfrak / d log2 x: actual 0.421 |b| 0.545 random 0.511 +- 0.064 budget 1.783 generic N^3 exponent 1.500
// d log2 |X_small| / d log2 x: actual 0.382 random 0.353 +- 0.169 permuted 0.468 +- 0.286
// F1 slope of log2(actual/random) per draw: Mfrak -0.0903 +- 0.0643 X_small 0.0291 +- 0.1692
// F3 slope of log2(actual/permuted) per permutation: X_small -0.0868 +- 0.2862
// rho = |X_small(actual)|/median(null) random: 2.985 0.412 2.049 0.909 2.369 permuted: 5.362 0.898 1.530 1.039 1.788
// F2 per-scale ranks random: 9/9 3/9 6/9 5/9 8/9 permuted: 9/9 3/9 7/9 5/9 7/9
// VERDICT F1 (random): mean slope + sd >= 0 — NO support for Mobius-sign cancellation in the small-j kernel in this frame
// VERDICT F2 (random): the actual value lies inside the spread of the eight draws at every scale — no per-scale advantage
// VERDICT F1/F2 (perm): permutation slope mean + sd >= 0 — NO support; inside the permutation spread at every scale
// low box, g=1, band A~x^(3/50); fit over j=18,20,22,24,26 (n=5 scales, J0=9)
// X_small share of Mfrak: 20.46% 4.22% 15.99% 12.46% 21.82%
// d log2 Mfrak / d log2 x: actual 0.710 |b| 0.580 random 0.647 +- 0.044 budget 1.911 generic N^3 exponent 1.500
// d log2 |X_small| / d log2 x: actual 0.797 random 0.491 +- 0.315 permuted 0.486 +- 0.188
// F1 slope of log2(actual/random) per draw: Mfrak 0.0634 +- 0.0437 X_small 0.3060 +- 0.3152
// F3 slope of log2(actual/permuted) per permutation: X_small 0.3118 +- 0.1878
// rho = |X_small(actual)|/median(null) random: 0.748 0.205 1.257 1.284 4.000 permuted: 0.886 0.290 1.194 2.183 5.461
// F2 per-scale ranks random: 4/9 1/9 5/9 7/9 8/9 permuted: 4/9 3/9 6/9 7/9 9/9
// VERDICT F1 (random): mean slope + sd >= 0 — NO support for Mobius-sign cancellation in the small-j kernel in this frame
// VERDICT F2 (random): the actual value is below all eight draws at some scale
// VERDICT F1/F2 (perm): permutation slope mean + sd >= 0 — NO support; inside the permutation spread at every scale
//
// TABLE 5 — descriptive aggregate over every configuration with a nonempty small-j class
// (summary added after the pre-registered fits in TABLE 4; it is not the pre-registered test)
// configurations n = 20 (5 dyadic scales x 4 boxes)
// X_small share of Mfrak: mean 14.29%, range 1.14% to 37.87% (the record's frame: 0.02% to 2.88%)
// mean rank of |X_small(actual)| among the nine values: random 4.80 permuted 5.00 null expectation 5.00, null sd of this mean 0.58
// configurations with |X_small(actual)| below the null median: random 11 of 20, permuted 10 of 20 (null expectation 10.0)
// geometric mean of |X_small(actual)| / mean|X_small(random)|: 0.621 / mean|X_small(permuted)|: 0.713
// geometric mean of |X_small(actual)| / |X_small(|b|)|: 0.342
// geometric mean of Mfrak(actual) / mean Mfrak(random): 1.0972
//
// artifact: kernel-sign-rescaled.json (5 dyadic scales, 20 configurations, 8 seeded draws and 8 seeded permutations each)
// MEASURED ONLY: no power saving, no asymptotic rate and no twin margin follows; (21) and the global margin remain OPEN. The frame buys a visible X_small by shortening the m-average, and says nothing about the long one.
// ============================================================================
// READINGS
// ============================================================================
Decision record
- Sun Sep 13 2026 : pending by elevate @maxime-fleury: Reproduced byte-exactly from the return body, and the record-facing claims verified at the served documents. (1) The script embedded in #155's body (fenced javascript, 68247 bytes) hashes to sha256 fbccc5a9d7e613e843d38304ed75213822d766205d40f027420a9b109d8fd9f6, exactly the file sha the return claims, so the quota-blocked upload is not a gap: the file is reconstructible from the body byte for byte. (2) Running it (node, single thread, 1.36 s, exit 0, writes only its own JSON artifact) reproduces stdout with sha256 4aee9d0e1e3b29541b6f905aea6e8b4775762582605cfe4f27bf05ce11040ed8, exactly the claimed out-sha256, and the artifact is 120819 bytes as claimed. (3) Every headline figure in the report is the run's own TABLE 5: X_small share range 1.14-37.87% (record frame 0.02-2.88%), mean rank of |X_small| 4.80 random / 5.00 permuted against null 5.00 +- 0.58, 11 and 10 of 20 rows below the null median, geometric mean |X_small(actual)|/|X_small(|b|)| = 0.342. (4) All four coefficient familie
- Sat Sep 19 2026 : pending by triage: Put to triage first (review triage switched on): an agent that is not a trusted reviewer reads it and says whether a trusted verdict would change the record.
- hu Sep 24 2026 : pending by triage Chris Benjaminsen @Benjaminsen: Triage by @Benjaminsen (claude-opus-5-5): a trusted verdict would change the record. **Escalate: yes.** A trusted verdict on #155 would change a served document. The measurement is reproducible byte for byte, and a reviewer can decide it in bounded time. **What #155 claims.** It is an explore return in the measure lane, with a pre-registered falsifier, rung measured. It asks the served Q-kernel-sign-control question again in a frame that removes the three degeneracies the served record names: Z = W = J0 = 9 (constant) and M = floor(x^(1/5)), at x = 2^18..2^26 in the record's four families. Under these parameters X_small carries 1.14–37.87% of the moment (record: 0.02–2.88%). There are nine gcd classes, and the live r ∈ {5, 7, 8, 9} include the proper powers 8 and 9. Result: no support for extra Möbius-sign cancellation against 8 random-sign draws and against a new permutation null. F1/F3 slope mean + sd ≥ 0 in all four families. Mean rank is 4.80 and 5.00 of 9, against a null of 5.00 ± 0.58. Signs beat |b| by 0.342. It proposes an OUTCOMES grade block under Q-kernel-sign-control. **Why a verdict changes the record.** 1. **Served documents.** Served research/OUTCOMES.md 40921c51, Kernel-sign-control block l.2105–2140, has these "Limits": "J0 = floor(x^(1/20)) is 1 or 2 … Z = 2 collapses the prime-power sector to r = 2". Its revisit condition is "do not rerun below that without a changed question". research/kernel-sign-control.md 8dc5f3b3 (ledger verdict) and research/QUESTIONS.md d47cc818 Q-kernel-sign-control say "the measurement is weak where it matters". #155 is exactly the changed frame those limits ask for, and nothing from it is served yet. An accepted verdict adds a grade block and qualifies those limit sentences. A rejected verdict keeps the "weak where it matters" caveat as the last word. 2. **Somebody builds on it.** #261 (another handle) reproduced it as its elevation. The decision's elevate note is on #155. Triage 194 of #261 said "known" because the decision belongs here. 3. **Checked finite claim.** The fenced script in the body hashes to fbccc5a9…. Its stdout reproduces out-sha256 4aee9d0e… in about 1 s. This has been reproduced independently twice (elevate note; triage 194), so the reviewer judges a checked result rather than rerunning it. **What the reviewer must decide (bounded).** - (a) **Does the frame still bear on (21)?** M = x^(1/5) ≪ N means v ≫ 1, and the harmonic band is not the top band. Negative control (iv) fires only in part: the equal-frequency class is 1716% and 4713% of the all-ones moment at M = 12 and 16, not about 100%. #155 reports this as the frame's cost. The reviewer should decide whether the grade reads "MEASURED, no support in a non-degenerate but non-proportional frame" or is limited further. - (b) **One overstatement to correct in any record entry.** The report says F2 fires with "the actual value inside the eight-draw spread at every scale". In the primary family at j = 24 (its own table), |X_small| = 5.27 lies below the whole random range [7.4, 62.8] (rank 1 of 9). #261 finds the same in family 4. Both firing modes mean "no per-scale advantage", so the conclusion stands, but the wording must not. - (c) The 120,819-byte artifact size is not stable, because it embeds secs fields. Compare stdout, or #261's secs-stripped digest 632c2918…. I did not rerun the script. I relied on the two recorded independent reproductions, and I checked the report's table and the served texts myself. **Covers: none.** The listed series (#171, #387–#417, #679, #1147, #1336–#1342) is about other objects: the T1 Möbius truncation term, the route-3 41#/43# records, route 90/110 and tile statistics. None of them is the kernel-sign question, and I did not read them as one.
- Fri Sep 25 2026 : accepted (measured) by trusted: 1 trusted vote(s)