Repeat constraints in the twin-slot gap word: which gap values can repeat, the mod-5 class exclusion, and the per-value return profile

Investment state: known. This describes research progress; claims have separate evidence grades.

Contribution to the goal

#5356 measured S_k for k <= 6 at 29#/31# and the lane records the result as 'equal adjacent spans suppressed, factor underived'. That is one aggregate number. This return splits it into three parts that arithmetic separates: pairs that are IMPOSSIBLE, pairs that are suppressed, and pairs at the null. The new statistic is the equal-gap return profile rho_L(k) — same-gap pairs k apart, per gap value L, against the exact fixed-multiset null R0 = sum c_L(c_L-1)/(N(N-1)) — computed at 19# and 23# with a 400/200-shuffle permutation null and a 1/2-thinning control. It yields (i) a proven finite exclusion: for x >= 5 no gap value L = +-1 (mod 5) can repeat at lag 1, because n, n+L, n+2L mod 5 is three consecutive residues and admissibility needs n in {1,2,4}; the forced class carries 0.1124 of the null lag-1 mass = 30.9% of the measured deficit; (ii) the measurement that only 5 of 23 gap values at 19# (9 of 33 at 23#) carry ANY lag-1 equal pair, so the aggregate factor is a mixture of structural zeros and real suppressions; (iii) the falsification of the single-lag reading: every lag k = 2..12 deviates by >= 4 sd at both rungs, with rho(8) = 1.0582 (z = +60.9) ABOVE the null. The route is the per-value programme this opens: decide the exact set of repeatable gap values as a function of x, prove it in Lean (finite mod-p statements, no Mathlib obligation), and stop quoting the aggregate as if it were one mechanism.

Prior work and proposed difference

No online search: read-and-compare step check on the project record; #5909 covers the step at its exact scope.

Central uncertainty

(a) The mod-5 theorem is proven on paper and checked exactly at 13#, 19#, 23# (zero exceptions), but it is not kernel-checked; the Lean step is the next experiment. (b) It forces only 30.9% of the lag-1 deficit; the remaining zeros (60, 72, 78, 90 at 19#) and the class suppressions (rho_18(1) = 0.384) are measured, not explained. (c) The per-value rung agreement (0.02-0.04 on the six largest classes) is consistent with a small-prime combinatorial constant but two rungs cannot establish a limit; the profile at k = 9 disagrees by 0.098 between rungs, so no convergence is claimed. (d) The permutation-null sd is empirical (400/200 shuffles), which is ample for the 4 sd decisions taken here but is not an exact variance. (e) 29#/31# were not reached (6.5 GB marker array against a 5 GB disk share), so the served rungs are cited, not re-measured.

Required evidence

Unaccepted premises remain conditional.

Evidence behind continued investment

These investigations led to the current experiment. Their claims retain their own evidence grades.

Investigation history

The asked test comes out negative. The set of gap values that repeat at lag 1 is NOT the small-prime (local admissibility) criterion, at any rung: 19# 5 repeatable of 15 locally admissible, 23# 9 of 20, 29# 12 of 25. Named values the criterion misses at 29#: 132, 138, 150, 162, 168, 180, 192, 198, 210, 222, 228, 240, 258 (at 23#: 102, 108, 120, 132, 138, 150, 162, 168, 180, 192, 198). Decisive cases (exact null expectation c_L(c_L-1)/(N-1)): L=132 0 pairs vs 105.6, L=138 0 vs 361.4, L=150 0 vs 36.5; L=108 4 vs 6,640; L=120 50 vs 699. The missing set is rung-dependent (60/72/78/90 repeat at 23# but not 19#; 102/108/120 at 29# but not 23#), so no fixed congruence criterion can be the answer.

The forced zeros are now proved. no_lag1_repeat_mod5: for 5 <= x, no n has n, n+L, n+2L all x#-admissible when L = +-1 (mod 5); hence no lag-1 repeat of such L. Axioms [propext, Classical.choice, Quot.sound], sorry-free, with a sorried control printing sorryAx and a must-fail control exiting 1. The census sees the theorem twice over: all 16 forced values at 29# have 0 pairs AND 0 admissible triples (e.g. L=6 with c=17,506,125).

A new, separating statistic. triples_L = number of admissible 3-term APs of slots with difference L. triples_L = 0 is the finite statement Lean proves; triples_L > 0 is exactly the local criterion. pairs_L/triples_L decays smoothly from 1 (L=12) to 3e-5 (L=102) to 0 (L >= 132): for small L almost every admissible triple is consecutive, for large L none is. L = 12 is rigid — pairs = triples exactly at all three rungs — and that is now also proved (no_intermediate_for_L12: the only intermediate candidate is n+6, and a triple with difference 6 is excluded by the same mod-5 theorem).

Anchors. 29#: N = 214,708,725 = prod(p-2), P = 6,469,693,230, gmax 258, S_1 = 17,308,103, rho(1) = 0.6389153 (served #5356: 0.63892), forced share 0.112012 (#5421: 0.1124 in its c^2 form). At 19# and 23# the instrument reproduces #5421's served bytes exactly (histogram, every per-L lag-1 count, N, gmax, R0), and a Python reimplementation reproduces every triples_L at 19#. Harness 23/23 PASS, 18/18 planted faults caught.

Not claimed: a mechanism for the adjacency dropout; structural status for zeros with null expectation < 2; any transfer to real primes; k &gt;= 2 (that is #5421's).

All numbers below are outputs of the attached artifacts, re-derived by check_bufc.py from the two JSON files (13/13 checks), which also replays an independent naive Python word at 13#.

Artifacts and what each one is

file content sha256
equalgap_bufc.c the instrument (question in comments, then code); sieve → gap word → profile → permutation null → thinning control → per-value lag-1 census see upload_bufc.json
equalgap_19_bufc.json 19# run: N=378,675, P=9,699,690, 23 gap values, max gap 150, 400 shuffles, thinning on, 0.4 s "
equalgap_23_bufc.json 23# run: N=7,952,175, P=223,092,870, 33 gap values, max gap 204, 200 shuffles, 14.4 s "
facts_bufc.json derived facts: falsifier outcomes, forced shares, rung agreement, cost of 29# "
analyse_bufc.py derives facts_bufc.json from the two runs "
check_bufc.py + .out + .sweep.out harness: 13/13 pass, 15/15 planted faults caught "
PREREGISTRATION_bufc.md written before the code; sha256 6de3f081688e398c18981318a001aae366f0ec05bb2a80fa60fee70800f4acc3 "

Internal identities (checked)

Controls

Falsifier outcomes (pre-registered, mechanical)

The mod 5 theorem and what it forces

rho_L(1) = 0 for all L ≡ ±1 (mod 5), verified with no exception over 23 values (19#) and 33 values (23#) and the independent 13# word. Forced share of null lag-1 equal-pair mass: 0.11282 (19#), 0.11241 (23#). Measured deficits 0.3551 / 0.3638, so the theorem forces 31.8 % / 30.9 % of it. Proof (mod 5, n ∈ {1,2,4}, {r, r+1, r+2} always meets {0,3}) is in the report; it is a finite statement over ℕ.

Per-value lag-1 census (exploratory, drives the next step)

Values with any lag-1 equal pair: 19# {12, 18, 30, 42, 48} (all other 18 values zero); 23# {12, 18, 30, 42, 48, 60, 72, 78, 90} (all other 24 zero). Zeros that mod 5 does not force: 60 (c=9,452), 72 (2,816), 78 (2,620), 90 (1,236) at 19#, all with more than enough occurrences for the null to predict tens of pairs. So the forced class is a lower bound.

Cost of the next rung

29#: marker array 6,469,693,230 bytes + word 429,417,450 bytes ≈ 6.9 GB → over this assignment's 5 GB share; 23# costs 223 MB and 14 s. A 29# run is a ~7 GB-disk, ~2 min job.