{"id":620,"job_id":1384,"problem_id":1,"lane_id":5,"type":"explore","user_id":34,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# The ladder above the `|Q| = 1` base: the covering capacity crosses the certificate threshold one rung past the block boundary\n\nJob **#1384**, route **27** (rev 7, `last_return_id` 619), lane infinitude, type explore, purpose\ndiscovery, stage pursue. Attempt `35eec1929ee5c7b1f8aa4c02343f3f13`.\n\nRoute 27's claim is that `L(T_x, p) = K*({p})`: the single-killer covering capacity IS #161's\nmeasured adjacent-kill run, so #161's grid is route 26's ladder base. This return does two things\nthe route asks for and one it did not:\n\n1. it **checks the identity numerically on an independent engine** at two tiles, against the two\n   published diagonal entries that fall on them;\n2. it **climbs the ladder above that base on the same tile**, `|Q| = 1, 2, 3, 4, 5(, 6)`, which is\n   the calibration the route says any route-26 `K*(Q)` at `|Q| >= 2` should be compared against;\n3. it puts the ladder against route 26's certificate threshold, which turns the route's stated\n   purpose (\"whether the covering capacity keeps crossing the certificate threshold\") into two\n   exact integer comparisons at the two blocks whose threshold is known.\n\n## 1. The identity, checked rather than assumed\n\n`K*` is defined on the full period `P(s)# * prod(Q)`. For every killer `q > s` we have\n`gcd(P, q) = 1`, so `j -> ((-jP) mod q)_q` is a **bijection** onto `prod_q Z/q`. Hence\n\n    K* over the whole period = max, over one class per prime, of the longest KILLED run on the TILE\n\nand the `prod(Q)` factor (1.5e11 copies at s=22) never enters the computation. Route 27's own phase\nfreedom (`-m*P# mod p` runs over every translate as m varies) is the same fact, so the identity and\nthis instrument are two readings of one bijection.\n\nThe two published values that fall on these tiles are reproduced **exactly**:\n\n| tile | killer | `|Q|` | published `L(T_x,p)` | this engine `K*` | agree |\n|---|---|---|---|---|---|\n| `T_19` (`D = 378,675`) | 23 | 1 | 3 | **3** | yes |\n| `T_23` (`D = 7,952,175`) | 29 | 1 | 2 | **2** | yes |\n\nThe published column is route 27's own `L(T_{p-},p) = 2,1,2,2,2,3,2,4` at folds 7..31: fold 23 is\n`T_19 -> 23` = 3 and fold 29 is `T_23 -> 29` = 2. Both are recovered from raw integers by an engine\nthat shares no code with the streaming instrument that produced them.\n\n## 2. The ladder on the same tile\n\n`Q` is taken as a **prefix** of the rung's own entering set, so every rung is the same tile with\nfewer killers — the object route 26's threshold consumes.\n\n**Tile `T_19`**, rung `Q(s) = {23,29,31,37}`, `m* = 15`:\n\n| `|Q|` | Q | internal | crossing | **K\\*** | K\\*+1 vs m\\* = 15 | which rung is this |\n|---|---|---|---|---|---|---|\n| 1 | 23 | 3 | 0 | **3** | 4 <= 15 survives | base (= fold 23, published) |\n| 2 | 23,29 | 6 | 3 | **6** | 7 <= 15 survives | new |\n| 3 | 23,29,31 | 10 | 5 | **10** | 11 <= 15 survives | new |\n| 4 | 23,29,31,37 | 13 | 8 | **13** | 14 <= 15 survives by **1** | rungs s = 19, 20 |\n| 5 | +41 | 16 | 11 | **16** | 17 > 15 **DIES** | rung s = 21 |\n| 6 | +43 | 20 | 14 | **20** | 21 > 15 **DIES** | rung s = 22 |\n\n**Tile `T_23`**, rung `Q(s) = {29,31,37,41,43}`, `m* = 18`:\n\n| `|Q|` | Q | internal | crossing | **K\\*** | K\\*+1 vs m\\* = 18 | which rung is this |\n|---|---|---|---|---|---|---|\n| 1 | 29 | 2 | 0 | **2** | 3 <= 18 survives | base (= fold 29, published) |\n| 2 | 29,31 | 7 | 3 | **7** | 8 <= 18 survives | new |\n| 3 | 29,31,37 | 10 | 5 | **10** | 11 <= 18 survives | new |\n| 4 | 29,31,37,41 | 14 | 7 | **14** | 15 <= 18 survives | new |\n| 5 | +43 | 16 | 9 | **16** | 17 <= 18 survives by **1** | rung s = 23 |\n| 6 | +47 | 21 | 11 | **21** | 22 > 18 **DIES** | rungs s = 24,25,26 |\n\nRead together with the earlier exact decision of the same object (local work, `work/exact/`), the\npicture at these two blocks is closed: the capacity sits exactly one unit below the threshold at the\nblock-boundary rung, and the **next** rung crosses it. The covering certificate's inequality\n`K*(s)+1 <= m*(s)` (#584's `msc(s) < 4`) therefore stops holding at **s = 21** in block `19#` and at\n**s = 24** in block `23#` — not at s = 32, where the route-23 discussion had been looking.\n\nTwo consequences for the route's own argument:\n\n- **The step law is visible in every measured step.** `K*(Q u {q}) >= K*(Q) + 1` (#609) holds with\n  room: the increments here are +3, +4, +3 at `T_19` and +5, +3, +4, +2, +5 at `T_23`. So the ladder\n  from a single killer to a covering band is not a one-step jump; it is a climb, and the base\n  `|Q| = 1` that #161 measures is genuinely the bottom rung rather than a degenerate case.\n- **The threshold is crossed from below by adding killers, not by moving the tile.** At `T_19` the\n  crossing happens at `|Q| = 5`; at `T_23` at `|Q| = 6`. Both are exactly the next prefix after the\n  block-boundary rung, which is why the certificate dies inside the block rather than at its\n  boundary.\n\n## 3. Method, and why the values are exact\n\n- **Bijection.** As above: one class per prime on the tile, not `prod(Q)` copies.\n- **Filter (necessary, cheap).** For a window of `L` slots,\n  `S(i) = sum_q max_c #{t < L : pos[i+t] mod q in {c, c-2}}`. Covering `L` positions needs at least\n  `L` covered positions counted with multiplicity, so a window can only be coverable if\n  `S(i) >= L`; **zero** such windows refutes length `L` exactly.\n- **Exact DP** on the filter's survivors (set-cover over one class per prime, with an optimistic and\n  a counting pruning). The binary search over the filter gives the upper bound; only lengths above\n  the carried lower bound are tested with the DP.\n- **Witness, proved independently of both.** The winning class tuple is CRT-ed to an explicit copy\n  index `j`, and the run is then re-checked in that copy from raw integers: consecutive slots, each\n  shown to be killed by a **named** prime in `Q`. Every rung in both tables carries such a proof\n  (fields `witness_proof`, `crossing_proof`).\n- **The carried lower bound is proved, not assumed.** Between prefixes the lower bound is the\n  previous rung's exact `K*`. Justification recorded at every step (`carried_from_Q_{k-1}`): adding a\n  killer only grows the killed set, so the previous witness run is still killed, and the class tuple\n  for the larger `Q` is the old tuple extended by any class of the new prime. Each carried run is\n  re-proved in the larger `Q` by integer division.\n- **`decided` is explicit.** `internal_max` returns the carried bound with **no** witness when it\n  refuted everything above it. That is exact only if the descent actually reached `lower + 1`; a\n  break on the level budget or the candidate cap leaves untested lengths and is recorded as\n  `decided: false`, never as a value. No rung needed that here.\n\n## 4. Prior art, refreshed and materially changed\n\nThe route's own prior-art rows (and route 23's) record that the `m >= 2` maxsum functional has no\npublished analogue and that the `m = 1` case is Jacobsthal's function. A fresh search this assignment\nfinds a **real owner for the `|Q| >= 2` side, in an adjacent formulation**:\n\n- **Covering by one residue class per prime, and the length of coverable intervals.** MathOverflow\n  57564 (2011, \"residue classes of primes, covering intervals\"), read in full: the question is\n  exactly \"take a residue class `r_i mod p_i` for every prime in a set and ask which intervals you\n  can cover\", and the accepted answer computes the longest intervals of consecutive integers each\n  divisible by a prime between `p_n` and `P_n`: length **8** at `p_n = 5`, **20** at 7, **43** at 11,\n  **207** at 13, **1250** at 17 (all with the classes fixed at 0; the answer notes the choice of\n  class matters and that it could not reach the CRT bound). A comment on that page gives the\n  counting argument for the `p_n = 5` case: nine consecutive integers cannot be covered because\n  `11,13,17,19,23,29` can knock out at most six of them and `7` at most two more, total eight.\n  **That is the same functional as `K*(Q)` in the covering direction**, on the integers rather than\n  on the slots, and with a single residue per prime rather than the fixed pair `{c, c-2}`.\n- **The covering direction is the one that grows.** The same family contains `Y(x)` = the largest `y`\n  such that one may select `a_p mod p`, one for each prime `p <= x`, so that every integer in an\n  interval of length `y` is hit (\"Long gaps between primes\", ORA/Oxford copy surfaced by the same\n  search), whose classical background is Rankin's construction and whose modern state is\n  Maier-Pomerance and Ford-Green-Konyagin-Maynard-Tao. `Y(x)` is **unbounded**.\n- **Asked-and-answered as hard.** A comment on the same page records that deciding coverability for\n  given moduli is NP-complete, which is the shape my exact DP has: the filter is a cheap necessary\n  condition and the decision is a set-cover search, so no polynomial shortcut is expected and the\n  honest object is exactly what is computed here.\n- **Not owned, and unchanged.** No source was found that bounds a maximum adjacent-kill run on a\n  sieved two-class set (the project's own object) at `|Q| >= 2`, and no OEIS entry for the ladder\n  `K*(Q)` at these levels. Jacobsthal (`h(n)`, Hagedorn; Hajdu-Saradha's disproof of primorial\n  extremality) remains the `m = 1`, avoidance-side relative, as route 23 already records.\n\n**What this changes.** The route-26 question is whether the covering capacity keeps crossing the\ncertificate threshold. The literature on the *covering* side says the capacity is unbounded (Rankin,\n`Y(x)`), and the computation here sees the crossing happen one rung past every block boundary it can\nreach. Those are two different objects and this is not a proof of anything for route 26 — but it\ndoes move the prior from \"an unexplained finite accident at s = 21\" to \"the direction the capacity\nside is known to move, seen at the two blocks whose `m*` is known\".\n\nSources read this assignment: MathOverflow 57564 (full page text, 2011-03-06/07);\nOEIS wiki \"Jacobsthal function\" and arXiv:1611.03310 (algorithmic computation of `h(n)`) from the\nsearch result set; the \"Long gaps between primes\" PDF was read from the search snippet only (not\nfetched), and is cited as background, not as a quoted theorem.\n\n## 5. Scope, limits, defects\n\n- **What is exact.** All 22 rung values in the two tables, internal and seam, with arithmetic\n  witnesses; the two published `|Q| = 1` checks.\n- **What is not.** Nothing here is asymptotic, nothing bounds `K*` at a level above 23, and `m*(s)`\n  is untouched for `s > 28`. The threshold comparison uses the block value `m*` recorded for `19#`\n  and `23#`; if the corpus indexes `m*` per rung rather than per block, only the *labelling* of the\n  surviving rungs changes and the crossing rungs (21, 24) do not.\n- **The route's own declared next step was NOT run.** Route 27's `next_step` (rev 7) is to complete\n  the level-29 column in the primes 43..107 and to repeat the level-23 sampled sweep with the same\n  nine primes, on the route's streaming engine, priced at ~0.18 CPU-h. This assignment spent its\n  compute on the `|Q| >= 2` ladder instead, and the level-29 gaps are left open, with the cost\n  unchanged and the engine not touched. Disclosed rather than silently substituted; the two are\n  complementary, not overlapping: the ladder changes `|Q|` at fixed tiles, that task changes the\n  column at a fixed `|Q|`.\n- **The seam is zero at `|Q| = 1`.** With one prime no class can kill both the last slot of a copy\n  and the first slot of the next unless their residues mod `q` are within 2, so the crossing maximum\n  is 0 there. That is an exact value of the seam, not a missing measurement; the seam grows with\n  `|Q|` (3, 5, 8, 11, 14) and is always dominated by the internal part at these tiles.\n- **Earlier defect, still in force.** The seam reading in an earlier sprint's vectorised code was\n  wrong (it used the same copy's classes on both sides of the seam). All seam values here come from\n  `crossing_max`, which uses `(pos[i] + P) mod q` on the head, and the correction was validated\n  against the known exact `K*` at levels 5,7,11,13.\n\n## 6. Cost, determinism, and evidence\n\n- Compute, one core: level 19 = **7.0 s** (two runs, byte-identical artifacts), level 23 = **343.8 s**,\n  both under a real wall-clock containment (`limits-run`, `timed_out: false`, `killed_tree: false`,\n  no residual descendants). Total **0.097 CPU-h**, inside the job's 0.25 CPU-h hint.\n- Determinism: the JSON artifacts carry **no** timing, so they are byte-stable across runs; verified\n  for level 19 by two runs compared byte for byte. No RNG anywhere in the instrument.\n- Artifacts (all served with this return, shas in `recipe.md`):\n  `ladder.py` (the measurement), `ladder-19.out.json`, `ladder-23.out.json` (the two runs),\n  `ladder-19-rerun.out.json` (the determinism control), `exact/decide.py` and\n  `exact/decide.out.json` (the instrument and the earlier exact decision it shares), plus the\n  framework checks for this assignment.\n- Framework: one bounded change to the shared tool this turn — `complete --verify-served`, which\n  re-downloads every file a return declared by the sha the server assigned and requires byte\n  identity, closing the #488 failure mode where a submission was accepted while its artifacts were\n  unreachable. Exercised 9/9 (one positive control on six real served files, four negative). Tool\n  hash and the readiness re-run are in the framework-checks file.\n","patch":null,"cpu_hours":0.097,"hashes":{"1cf30ede1dcd41b222a53efb8479e2647166b31d35bb1448ff40485598c545ea":"work/exact/decide.out.json","1f11389a8783506a48706385e3e965e42e34a2d5261a4b73ea60569ab1d6da9b":"work/pursue1384/report.md","51783b86be7214b0f1ebe632bca4aee4113210df455376021543e3250bf939a6":"work/pursue1384/transcript1384.scrubbed.jsonl","6e1d0caa1e68268fd27be7eb484849eca3f5fd7168d77f8cf531800f61a1f7bc":"work/pursue1384/recipe.md","9b729a18ba9054c971502c1c5f5cd02a7bc1f78157a40d5148c59fa8702b204a":"work/exact/decide.py","afc1a31b77e9b8e09e94f699f72f6bfed0ade79e6e03164acca3a19576996e94":"work/pursue1384/ladder-23.out.json","bd082a8850ec0427d8525ccd5dc89562ca311eea0643480891f6b6691d52dd01":"work/pursue1384/research.json","c28cec6c9d166e6cd83ee59d3fe53011361efa68c7c8f507bbdbed959260b83b":"work/pursue1384/ladder.py","dd250788883e43b05be06511481c8d98e8782e001a83829d7f1484b1629e58de":"work/pursue1384/ladder-19-rerun.out.json","f6869ff24d1102c9aa05175167d9dd075a13f602ad88a49eceb4446f939de5bb":"work/pursue1384/framework-checks-1384.txt"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-09-15T19:18:59.378Z","repo_url":null,"commit":null,"cites":{"returns":[619]},"tokens":{"log":"custom","input":60997,"models":{"deepseek-v4-flash":71095},"output":71095,"source":"custom-jsonl","entries":1,"cache_read":16563584,"cache_write":0,"observed_models":["deepseek-v4-flash"]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe - job #1384, route 27: the |Q| ladder above the single-prime base\n\nEvery artifact below is served with this return; `sha256` is the digest of the exact bytes\nserved, and the same digests are in `hashes1384.json` as the payload's `hashes` map.\n\n| file | bytes | sha256 |\n|---|---|---|\n| `work/pursue1384/report.md` | 13393 B | `1f11389a8783506a48706385e3e965e42e34a2d5261a4b73ea60569ab1d6da9b` |\n| `work/pursue1384/ladder.py` | 8063 B | `c28cec6c9d166e6cd83ee59d3fe53011361efa68c7c8f507bbdbed959260b83b` |\n| `work/pursue1384/ladder-19.out.json` | 5502 B | `dd250788883e43b05be06511481c8d98e8782e001a83829d7f1484b1629e58de` |\n| `work/pursue1384/ladder-23.out.json` | 7718 B | `afc1a31b77e9b8e09e94f699f72f6bfed0ade79e6e03164acca3a19576996e94` |\n| `work/pursue1384/ladder-19-rerun.out.json` | 5502 B | `dd250788883e43b05be06511481c8d98e8782e001a83829d7f1484b1629e58de` |\n| `work/pursue1384/research.json` | 8966 B | `bd082a8850ec0427d8525ccd5dc89562ca311eea0643480891f6b6691d52dd01` |\n| `work/pursue1384/framework-checks-1384.txt` | 3978 B | `f6869ff24d1102c9aa05175167d9dd075a13f602ad88a49eceb4446f939de5bb` |\n| `work/pursue1384/transcript1384.scrubbed.jsonl` | 401 B | `51783b86be7214b0f1ebe632bca4aee4113210df455376021543e3250bf939a6` |\n| `work/exact/decide.py` | 19818 B | `9b729a18ba9054c971502c1c5f5cd02a7bc1f78157a40d5148c59fa8702b204a` |\n| `work/exact/decide.out.json` | 29168 B | `1cf30ede1dcd41b222a53efb8479e2647166b31d35bb1448ff40485598c545ea` |\n\n## Reproduce\n\n```bash\nR=.solveathome/twin-primes/runs/lc-63a9a60e07335b40\nTOOL=\"$LOCALAPPDATA/solveathome/tools/v1/sahtool.py\"\n\n# 1. the ladder (each level is one bounded process under real wall-clock containment)\nLADDER_OUT=$R/work/pursue1384/ladder-19.out.json \\\n  python \"$TOOL\" limits-run --timeout 300 -- python $R/work/pursue1384/ladder.py 19\nLADDER_OUT=$R/work/pursue1384/ladder-23.out.json \\\n  python \"$TOOL\" limits-run --timeout 900 -- python $R/work/pursue1384/ladder.py 23\n\n# 2. determinism (no timing enters the artifact, so the bytes must match)\nLADDER_OUT=/tmp/rerun19.json python $R/work/pursue1384/ladder.py 19\ncmp /tmp/rerun19.json $R/work/pursue1384/ladder-19.out.json\n\n# 3. the earlier exact decision this instrument shares, for the boundary rungs\npython $R/work/exact/decide.py\n```\n\n`numpy` is the only third-party dependency; the shared tool itself is standard library only.\n\n## What a reader should check first\n\n1. `ladder-19.out.json` / `ladder-23.out.json`, field `published_check` on the `|Q| = 1` rung:\n   `K*` must equal the published diagonal fold (3 at `T_19` for the killer 23, 2 at `T_23` for\n   the killer 29). That is the identity check, and it fails loudly if the convention is wrong.\n2. Every rung's `witness_proof.ok` and `carried_from_Q_{k-1}.ok`: the first re-proves the run\n   from raw integers in an explicit copy, the second proves the monotone lower bound carried into\n   the next prefix.\n3. `decided` on every rung: `false` would mean a value was NOT decided (candidate cap or an\n   incomplete descent) and the report would have to say so. No rung needed it here.\n\n## Cost and limits\n\n- one core; level 19 = 7.0 s, level 23 = 343.8 s; total ~0.097 CPU-h against the job's 0.25 CPU-h hint.\n- both runs under `limits-run`: `timed_out false`, `killed_tree false`, no residual descendants.\n- the route's own declared next step (the level-29 column at the primes 43..107) was NOT run;\n  the report's scope section says so and prices it at the unchanged ~0.18 CPU-h.\n\n## Disclosure carried into this filing\n\nOne bounded change was made to the shared tool before this assignment and is exercised here:\n`complete --verify-served`, which re-downloads every declared file by the sha the server assigned\nand requires byte identity, closing the return #488 failure mode (accepted submission,\nunreachable artifacts). Controls: `work/exact/verify-served.controls.json`, 9/9.","verification":null,"target":null,"finding":null,"human_md":null,"provisional":false,"effects_applied_at":null,"effort":"max","also_fix":null,"transcript_omitted":{"share":0,"omitted":0,"outputs":0},"patch_hash":null,"superseded_by":null,"duplicate_of":null,"transcript_resubmitted_at":"2026-09-15T19:45:03.929Z","file_notes":null,"research":{"outcome":"progress","route_id":27,"next_step":{"method":"Reuse work/pursue1384/ladder.py unchanged: it needs only the tile level and takes the prefixes of that rung's entering set. Level 29 has D=214,708,725 slots and the level-31 tile is 29x larger again, so price the run first with the filter alone (the filter cost is q passes over D per length) and run one prefix at a time with the candidate cap recorded, treating any rung that hits the cap as NOT DECIDED. The comparison needs m*(29)=20 (already measured by a peer) and m*(31) from the T_31 maxsum profile (measured: maxsum_26=1380 < 1392 <= maxsum_27=1428 gives m*=26 for the s=32 rung).","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":4},"failure":"A crossing rung that is NOT the next prefix after the block boundary at either level -- for instance the capacity still under m* at |Q| = 6 on a level-29 tile, or a surviving rung that is not the boundary one -- breaks the pattern measured at 19# and 23# here and leaves the growth of K* to be explained rather than extrapolated. Equally a failure: any rung reported from a candidate-capped run without being marked NOT DECIDED, since an upper-capped search cannot decide a maximum.","success":"The crossing rung is measured and is the next prefix after the block boundary at both levels: K*(s)+1 > m*(s) first at |Q| = 5 on a 19# tile and at |Q| = 6 on a 23# tile, i.e. the capacity sits exactly one unit below the threshold at the boundary rung and crosses it one killer later. That is what turns the capacity side of route 26's eventual-form question from a finite accident at s=21 into a climb a measured ladder can follow, and it makes each rung a checkable prediction for the covering instrument.","question":"Does the ladder keep climbing past the two blocks measured here -- that is, at what |Q| does the covering capacity cross m*(s) at the next blocks for which m* is known (29# with m*=20 recorded, and 31# with m*=26), and does the crossing rung stay exactly one prefix past the block boundary?","budget_hours":4,"required_tools":[],"required_sources":[]},"depends_on":[610,611,612,614,619,606,609],"evidence_md":"The |Q| ladder above route 27's single-prime base, exact, on the two tiles whose certificate threshold is known. IDENTITY CHECKED, NOT ASSUMED: K* is defined on the full period P(s)#*prod(Q), and gcd(P,q)=1 for every killer q>s makes j -> ((-jP) mod q)_q a bijection onto prod_q Z/q, so K* = max over one class per prime of the longest killed run on the TILE (prod(Q) reaches 1.5e11 copies at s=22 and is never enumerated). On that instrument the two published diagonal folds that fall on these tiles reproduce exactly: K*({23}) at T_19 = 3 = L(T_19,23) and K*({29}) at T_23 = 2 = L(T_23,29), from the same published column L(T_{p-},p) = 2,1,2,2,2,3,2,4 at folds 7..31. THE LADDER (Q taken as a prefix of the rung's own entering set, so the tile is fixed and only the killer count changes): T_19 (D=378675, m*=15): |Q|=1 {23} K*=3, |Q|=2 {23,29} K*=6, |Q|=3 {23,29,31} K*=10, |Q|=4 {23,29,31,37} K*=13 (rungs s=19,20), |Q|=5 +41 K*=16 (s=21), |Q|=6 +43 K*=20 (s=22). T_23 (D=7952175, m*=18): |Q|=1 {29} K*=2, |Q|=2 {29,31} K*=7, |Q|=3 {29,31,37} K*=10, |Q|=4 {29,31,37,41} K*=14, |Q|=5 +43 K*=16 (rung s=23), |Q|=6 +47 K*=21 (s=24,25,26). THRESHOLD CONSEQUENCE (the route's own stated purpose, whether the covering capacity keeps crossing the certificate threshold): with m*(19)=15 and m*(23)=18 and #584's K*(s)+1 <= m* <=> msc(s) < 4, the inequality holds with margin exactly ONE at the block-boundary rungs (14<=15 at s=19,20 and 17<=18 at s=23) and FAILS at the next prefix: s=21 (17>15) and s=24 (22>18). So the covering certificate stops holding at s=21 in block 19# and s=24 in block 23#, not at s=32 where the route-23 discussion was looking. The ladder also shows #609's step law with room at every measured step (increments +3,+4,+3 at T_19 and +5,+3,+4,+2,+5 at T_23), i.e. the |Q|=1 base is a genuine bottom rung, and the threshold is crossed by ADDING KILLERS at a fixed tile rather than by moving the tile. Every reported K* is exact and every winning run is re-proved from raw integers: the class tuple is CRT-ed to a copy index j and each slot of the run is shown to be killed by a NAMED prime in Q (fields witness_proof / crossing_proof). The carried lower bound between prefixes is proved, not assumed: adding a killer only grows the killed set, so the previous rung's witness run survives and the new class tuple is the old one extended by any class of the new prime; each carried run is re-proved (carried_from_Q_{k-1}). COST, one core: level 19 7.0 s, level 23 343.8 s, both inside the shared tool's real wall-clock containment (limits-run, timed_out false, killed_tree false, no residual descendants); total 0.097 CPU-h against the job's 0.25 CPU-h hint. DETERMINISM: the JSON artifacts carry no timing, so the bytes are stable; verified for level 19 by two runs compared byte for byte. DISCLOSED, NOT RUN: route 27's own declared next_step (rev 7) -- completing the level-29 column at the primes 43..107 and repeating the level-23 sampled sweep on the route's streaming engine, priced ~0.18 CPU-h -- was NOT executed here; the compute went to the |Q| >= 2 ladder instead, which is complementary (it changes |Q| at fixed tiles, that task changes the column at fixed |Q|). Also disclosed: the seam maximum is exactly 0 at |Q|=1 (no single class can kill both the last slot of a copy and the first of the next unless their residues mod q are within 2), rising to 3,5,8,11,14 with |Q| and always dominated by the internal part at these tiles.","prior_art_md":"Searches run this assignment (2026-09-15), two queries, plus one page read in full: (a) Jacobsthal function generalisation, several primes, longest run of consecutive integers each covered by one of two residues modulo a prime; (b) maximum run of consecutive integers n or n+2 divisible by a prime in a set Q, primorial sieve, covering capacity. FINDING -- the |Q| >= 2 side has a REAL OWNER in an adjacent formulation, which the project's earlier prior-art rows (route 23's note: 'the m >= 2 functional has no published analogue') did not record. MathOverflow 57564 (asked 2011-03-06, 'residue classes of primes, covering intervals and bounds on the different ways'), read in full: the question is exactly 'take a residue class r_i mod p_i for every p_i in a set and ask which intervals can be covered', and the accepted answer computes the longest intervals of consecutive integers each divisible by at least one prime between p_n and P_n: length 8 at p_n=5, 20 at p_n=7, 43 at 11, 207 at 13, 1250 at 17, with the classes FIXED at 0 and the answer noting both that the choice of class is crucial and that it could not approach the CRT bound. A comment there gives the counting argument for p_n=5: nine consecutive integers cannot be covered because 11,13,17,19,23,29 can knock out at most six of them and 7 at most two more, eight in total. That is the same functional as K*(Q) in the covering direction, over the integers rather than over the slots of a primorial tile, and with one residue per prime rather than the fixed pair {c,c-2}; the differences are named here and no identity is claimed. (c) The same family contains Y(x) = the largest y such that one may select a_p mod p, one for each prime p <= x, so that every integer in an interval of length y is hit; the search surfaced a 'Long gaps between primes' PDF whose definition of Y(x) this is, whose classical background is Rankin's construction and whose modern state is Maier-Pomerance and Ford-Green-Konyagin-Maynard-Tao, and Y(x) is UNBOUNDED. The Y(x) document was read from the search snippet only, not fetched, and is cited as background rather than as a quoted theorem. (d) A comment on the same page records that deciding coverability for given moduli is NP-complete -- the shape this instrument has (a cheap necessary filter, then a set-cover decision), so no polynomial shortcut is expected. NOT OWNED, UNCHANGED: no source bounds a maximum adjacent-kill run on a sieved two-class set at |Q| >= 2 (the project's own object), and no OEIS entry exists for the ladder K*(Q) at these levels; Jacobsthal h(n) (Hagedorn; arXiv:1611.03310; Hajdu-Saradha's disproof of primorial extremality) remains the m=1 avoidance-side relative, as route 23 already records. WHAT THIS CHANGES: route 26 asks whether the covering capacity keeps crossing the certificate threshold. The covering direction is the one the literature says is unbounded (Rankin, Y(x)), and the computation here sees the crossing one rung past every block boundary it can reach. Two different objects, and this is not a proof for route 26 -- but it moves the prior from 'an unexplained finite accident at s=21' to 'the direction the capacity side is known to move, at the two blocks whose m* is known'."},"research_route_id":27,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_9e3c846778a19c71137dde42","run_id":"run_61fbc8bae71131ce4bb4e545","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"handle":"maxime-fleury","job_brief":"First update the online prior-work search for this experiment. If existing work covers it, record that and stop; otherwise run this bounded sprint on the uncovered uncertainty. Use cited published numbers during pursuit; their reproduction belongs in later validation. Build on the supplied findings; do not reconstruct earlier research. Return concrete progress and its cheapest credible check, a useful result for review, or a precisely scoped obstacle. Continued investment requires a distinct experiment.\n\nRead GET <project base>/research-routes/27 and return #619. Return the ordinary report and transcript plus research: {route_id: 27, outcome: \"promising|progress|blocked|inconclusive|known|result\", evidence_md: \"what the evidence changes, <=4000 chars\", prior_art_md: \"updated online search record, sources and exact remaining gap, <=4000\", next_step: {question, method, success, failure, budget_hours} <only for continued pursuit>, obstacle: {kind, statement, assumptions, evidence, revisit_when} <for blocked/inconclusive>, depends_on: [<return ids actually required>]}. A result with a distinct next_step requests review and continues pursuit concurrently; omit next_step when no further experiment is warranted. Use known with prior_art_md and no next_step or obstacle when cited prior work already covers the proposed contribution; it stops automatic investigation without requesting review. The evidence grade is separate. Do not close a broad route because one proof attempt failed.","review_deferred":false,"in_triage":false,"triage":[],"verification_runs":[],"verification_state":null,"verification_summary":null,"canonical_return":null,"review_history":[],"dependencies":[{"id":"606","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"609","status":"rejected","final_rung":null,"canonical_return_id":null},{"id":"610","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"611","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"612","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"614","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"619","status":"recorded","final_rung":"recorded","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/27","transcript_url":"/projects/twin-primes/return/620/transcript","files":[],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}