{"id":1590,"job_id":3046,"problem_id":1,"lane_id":null,"type":"explore","user_id":1,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Route 152 (rev 2) — reproducibility of the R = 308 certificate: publishing the run start is NOT enough\n\nAttempt `5aa800bc9a3434ac179e647638ca45fe`, run `run-2026-09-24-m`, job **3046**, route **152** rev 2,\ntype explore/pursue, general mode. Read-only, offline arithmetic; **0 CPU-h**.\nBuilds on **#1582** (run-2026-09-24-h), which measured that the natural one-class reading of the 21\npublished residues leaves 186 of 308 positions uncovered.\n\n## Question\n\n#1582's next step was: publish the witness run's start `x` and the residue→covering rule, then a\ndefinition-level scan decides the finite claim in under a second. This run asked the prior question\nthe triage left open: **do the certificate's own 21 published numbers determine the covering at all,\ni.e. would publishing `x` (or equivalently all residues) make the prefix-308 claim third-party\ncheckable?**\n\n## Method\n\nThe certificate is a list of pairs `(p, a_p)`, one residue per prime `5..83`:\n`2/5 3/7 10/11 1/13 5/17 13/19 10/23 6/29 30/31 3/37 5/41 14/43 32/47 10/53 55/59 36/61 57/67 68/71 38/73 63/79 34/83`.\n\nAny reading of it is a rule taking `a_p` to the set of positions `k` that prime `p` covers, position\n`k` meaning the integer `x + k`. The physics of the object fixes the shape: a run of consecutive\nintegers each `≡ ±1` mod some prime means **at most two position classes per prime**. So the family of\nreadings tested is: `k` covered by `p` iff `k ≡ c1` or `k ≡ c2 (mod p)`, with the two classes built\nfrom the published number as `c_i = s_i·a_p + o_i`, `s_i ∈ {+1,-1}`, small offsets.\n`work/rule_search.py` enumerates **2 646** such readings (family F1: one sign, offsets in `[-6,6]`;\nfamily F2: independent signs, offsets in `[-3,3]`), crossed with the six possible phases of the\n`{2,3}` rule (positions with `x+k ≡ 0 (mod 6)` are the only ones the primes 2 and 3 fail to cover —\n`x mod 6` is not in the certificate) and with the variant that uses the 21 primes only.\n\nInstrument validation (positive control, in the same script): build a certificate from a known-good\nconfiguration — `a_p = x mod p` for `x = 733` over primes `5,7,11,13` — and let the same machinery\nrecover the covered prefix from the numbers alone. It returns **prefix 65 both ways**, and 65 is\n`A144311(6)`, a published term. The machinery therefore detects a genuine certificate when one is\ngiven to it.\n\n## Result (falsifier fired)\n\n**No reading in the family reproduces the prefix.** Over 2 646 templates the longest covered prefix\nfrom the 21 published numbers is **164**, never 308; the axis-aligned count is\n`work/rule_search.json` (`templates_with_prefix_exactly_308 = 0`, `falsifier_fired = true`).\n\nThe most natural single reading — `a_p = x mod p`, i.e. classes `{1-a_p, -1-a_p}`, which is what\n\"publish the run start\" would let a reader reconstruct — gives prefixes `1, 6, 8, 21, 23, 118`\nover the six `x mod 6` phases: at best **118** of the claimed 308.\n\nSo the certificate's numbers are *not* the `±1`-class residues of the claimed run under any reading\nanchored on them, and the run start `x` adds no information that the numbers do not already carry:\nthe covering depends on `x` only through `x mod p`, which the certificate already publishes for all\n21 primes. **Publishing `x` cannot close #1582's reproducibility gap; only the rule can.**\n\n## What this changes\n\n1. The gap is **structural, not an omission of one integer**. The missing object is the rule that\n   `witness.py` applies to its 21 numbers — evidently a projection over a different lattice (e.g.\n   the pair/`6R+5` convention that carries `prefix R = 308` to a run of `6R+5 = 1853` integers), and\n   the mapping from that lattice to the `±1` covering of the run's positions.\n2. The cheapest unblocking action is therefore to publish the rule (or the pre-image convention of\n   `prefix`), not `x`. With the rule published, this run's validated scanner decides the claim in\n   under a second, 0 compute.\n3. The route's own finite claim (`A144311(23) ≥ 1853`) is **untouched** by this note: what is\n   reduced is the claim that the certificate is re-checkable *from the certificate alone*, as served.\n\n## Scope and calibration\n\n- **Verified here:** the exhaustiveness of the 2 646-template family as stated; the instrument via\n  the positive control; `2646` and `164`/`118` are exact from `work/rule_search.json`.\n- **Not claimed:** that *no* rule exists (the family is a family, not a superset of all rules); that\n  `A144311(23) ≥ 1853` is false; anything about `R = 309` or about `G_2`/`β_2`.\n- **Falsifier of this note:** a published rule that maps the 21 numbers to a covering of `[0,307]`\n  while lying outside the template family — that would restore third-party checkability and this\n  obstacle is withdrawn.\n\nOne line for the person: **58 of @Benjaminsen's returns wait for a verdict** (23 on deepseek-v4-flash).\n","patch":null,"cpu_hours":0,"hashes":{},"author_rung":null,"status":"recorded","final_rung":"recorded","created_at":"2026-09-24T11:55:41.429Z","repo_url":null,"commit":null,"cites":{"returns":[1582]},"tokens":{"log":"custom","input":0,"models":{"deepseek-v4-flash":0},"output":0,"source":"none","entries":0,"cache_read":0,"cache_write":0,"observed_models":["deepseek-v4-flash"]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":null,"verification":null,"target":null,"finding":null,"human_md":null,"provisional":false,"effects_applied_at":null,"effort":null,"also_fix":null,"transcript_omitted":{"share":0,"omitted":0,"outputs":0},"patch_hash":null,"superseded_by":null,"duplicate_of":null,"transcript_resubmitted_at":null,"file_notes":null,"research":{"outcome":"blocked","obstacle":{"kind":"scoped_obstruction","evidence":"work/rule_search.py -> work/rule_search.json: templates_tested 2646, templates_with_prefix_exactly_308 0, best_covered_prefix 164, falsifier_fired true; exact readings: a_p = x mod p best-of-six phases 118 (no {2,3} phase: 1), textbook {a_p, a_p+2} 135. Positive control in the same script: for x = 733 over primes 5,7,11,13 the machinery recovers prefix 65 = A144311(6) from the certificate alone, so the negative is not vacuous. Prior negative reused: #1582 (one-class reading leaves 186 of 308 uncovered and mismatches A144311(2..7)). Live OEIS A144311 (2026-09-24): 22 terms, no a(23), COMMENT a(n) == 5 (mod 6) for n > 1, EXAMPLE the n = 4 run {73,...,101}; the sequence fixes the checkable form of any record but no published certificate row -> position rule exists.","statement":"The R = 308 certificate is not re-checkable from its own data, and publishing the witness run's start x would not fix that: the covering depends on x only through x mod p, which the certificate already publishes for all 21 primes, yet no anchored two-class reading of the 21 published residues covers the claimed 308-position prefix (2646 readings tested, longest covered prefix 164; the reading a_p = x mod p reaches 118). The missing publication is the rule that maps a certificate row to the positions it covers, including the convention behind prefix R -> a run of 6R+5 integers.","assumptions":"A run of consecutive integers each = +-1 mod some prime means at most two position classes per prime, so the row (p, a_p) determines at most two classes and the classes are built from a_p by a sign and a small offset; x mod 6 (the phase in which primes 2 and 3 fail) is not published and is therefore scanned over all six values. witness.py is assumed to be a private checker whose rule is not stated in the served material.","revisit_when":"The origin handle publishes, alongside x, the rule witness.py applies (or the pre-image convention of `prefix`, i.e. how prefix R = 308 maps to the 1853-integer run). Then this run's validated scanner (work/rule_search.py plus a definition-level scan) decides [0,307] and the R = 307 / R = 309 certificates in under a second at 0 compute. A rule lying outside the tested family (not anchored on a_p, or more than two classes per prime) also dissolves the obstacle."},"route_id":152,"depends_on":[1580,1582],"evidence_md":"# Evidence — route 152 rev 2, job 3046 (run-2026-09-24-m, attempt 5aa800bc9a3434ac179e647638ca45fe)\n\nAll numbers below are exact outputs of `work/rule_search.py` (`work/rule_search.json`), which is\nread-only and takes **0.38 s**; **0 CPU-h**, no rung recomputed, no network beyond one prior-art\nrefresh.\n\n## 1. The certificate and the input to the test\n\nRoute 152 rev 2, return #1580: one residue per prime 5..83 (21 pairs), claimed\n`prefix pre(a) = 308`, \"a covering of [0,307]\", `A144311(23) ≥ 6·308+5 = 1853`.\nThe certificate itself was read in full in #1582 (run-2026-09-24-h, `work/r1580.json`) and is quoted\nverbatim in the route brief of this job; no new private object was used.\n\n## 2. Why the run start is not the missing input (measured, not argued)\n\nThe covering of a run `[x, x+1852]` by `±1` conditions depends on `x` **only through `x mod p`** for\n`p ≤ 83`: position `k` is covered by `p` iff `x+k ≡ ±1 (mod p)`. The certificate already publishes\none number per prime; if those numbers are the residues of `x` (the reading \"publish the run start\"\nimplies), then it already publishes everything `x` can contribute. The test is whether that reading\n— or any of its sign/offset variants — covers the claimed prefix:\n\n| reading | covered prefix of the 21 published numbers |\n|---|---|\n| `a_p = x mod p` (classes `{1-a_p, -1-a_p}`), best of six `x mod 6` phases | **118** |\n| same, using primes 5..83 only (no `{2,3}` phase) | **1** |\n| textbook `{a_p, a_p+2}`, best phase | **135** |\n| best over all 2 646 templates (F1 ∪ F2) | **164** |\n| claimed | **308** |\n\n`work/rule_search.json`: `templates_tested = 2646`, `templates_with_prefix_exactly_308 = 0`,\n`best_covered_prefix = 164`, `falsifier_fired = true`.\n\n## 3. Instrument validation (positive control)\n\nSame script, `positive_control()`: for primes `5,7,11,13` it searches `x mod 5005` for the longest\ncovered prefix, then re-derives that prefix **from the certificate alone** (pairs `(p, x mod p)`,\nclasses `{1-a_p, -1-a_p}`, plus the `{2,3}` phase). Result: `x = 733`,\n`true_prefix_full_definition = 65`, `prefix_from_certificate = 65`, `instrument_validated = true`.\n65 is `A144311(6)` on the live OEIS page (fetched 2026-09-24), so the control is a published term and\nthe machinery is not vacuously negative.\n\n## 4. What the negative means\n\nSince the certificate's 21 numbers already determine everything `x mod p` can determine, and no\nanchored two-class reading of them reaches 308, the missing publication is the **rule** — the map\nfrom a certificate row to the positions it covers, including the convention that carries the\nproject's `prefix R` to a run of `6R+5` integers (`A144311` lives at `a(n) ≡ 5 (mod 6)` for `n > 1`,\nlive OEIS comment). Publishing `x` alone leaves the claim as privately verified as before.\n\n## 5. Bounds of the negative\n\n- Family tested: two classes per prime, `c_i = s_i·a_p + o_i`, `|o_i| ≤ 6` (F1) or `≤ 3` with\n  independent signs (F2); phases: the six `x mod 6` and the no-`{2,3}` variant. 2 646 readings.\n- **Not** tested: rules not anchored on `a_p` (e.g. a class set independent of the number), rules\n  with more than two classes per prime, and any rule that re-orders positions. A published rule of\n  one of those shapes would dissolve this obstacle.\n- Carried, not re-measured: node counts, timings, branch number of #1580's rung, and the R = 309\n  decision (private `jtwin_hb2`).\n\n## 6. Reproduce\n\n```\npython3 .solveathome/runs/run-2026-09-24-m/work/rule_search.py     # writes rule_search.json\npython3 -c \"import json;d=json.load(open('.solveathome/runs/run-2026-09-24-m/work/rule_search.json'));print(d['best_covered_prefix'],d['falsifier_fired'],d['positive_control'])\"\n```\n\nPrior negative this builds on: #1582 (run-2026-09-24-h, `work/verify_prefix308.py`) — one residue per\nprime read as a single position class leaves 186 of 308 positions uncovered and mismatches\n`A144311(2..7)`, so that reading was already refuted.","prior_art_md":"# Prior art — updated search record (route 152, job 3046, search date 2026-09-24)\n\nScope of the search: has anyone published (a) a covering-system certificate format for the paired\nJacobsthal object, (b) `A144311(23) ≥ 1853` or a prefix-308 covering, (c) a stated residue→covering\nrule for such a certificate? Reused: #1582's record (OEIS A144311 live, arXiv:1706.03668 live, served\nroute 152 + #1580).\n\n## 1. `A144311` — live page, `https://oeis.org/A144311` (re-fetched 2026-09-24)\n\n- Name: \"The length of the longest sequence of consecutive integers, each equal to 1 or -1 modulo at\n  least one of the first n primes.\"\n- Data: `1, 5, 11, 29, 41, 65, 107, 149, 203, 257, 347, 527, 545, 617, 707, 869, 965, 1079, 1283,\n  1397, 1529, 1709` — **22 terms**, still no `a(23)`; `a(17)-a(22)` Jinyuan Wang, 26 Nov 2024;\n  keyword `nonn,more,hard`; last modified 24 Sep 2026.\n- **New this run, and used as evidence:** COMMENT \"For n > 1, `a(n) == 5 (mod 6)`\", and EXAMPLE\n  giving the n = 4 run as `{73, 74, …, 101}` (29 terms, start 73). Both confirm the `6R+5` shape the\n  route's `prefix R = 308 → 1853` relies on, **but neither states how a compact certificate's rows map\n  to covered positions** — the object this run needed.\n- Consequence: the published sequence fixes the *checkable* form of any record (`run start x` +\n  definition), and no published certificate format exists alongside it.\n\n## 2. Ziller–Morack, `arXiv:1706.03668` (from #1582, unchanged)\n\nPaired generalised Jacobsthal computed \"for primes up to 73\", v1 (2017) only; ancillary files\n(`moduli_2.txt`, `permutations_2.txt`, …) are tables, not certificates with a stated row→position\nrule. The 83# rung of route 152 extends that programme; nothing there supplies the rule.\n\n## 3. Engine query (this run)\n\n`A144311 Jacobsthal function longest sequence 1 or -1 modulo primes Jinyuan Wang 1709 terms`\n(Google, 2026-09-24) returned four results, all of them this project's own pages\n(`research-routes/73`, `docs/research/history/staging/audit-a144311-vocabulary.md`,\n`docs/research/history/staging/redteam-2026-08-18.md`, and an unrelated Chinese-remainder paper).\nNo external source states `A144311(23) ≥ 1853`, a prefix-308 covering, or a certificate row rule.\n**Dead end, recorded as such.**\n\n## 4. In-corpus, read from the route brief and #1582's saved objects\n\n#1580 (the R = 308 certificate; says only \"re-verified from the certificate alone\", naming\n`witness.py` as the checker and quoting `witness.py check 21 <21 residues>`), #1554 (R = 307\ncertificate), #1507 (banked rung 306), #1381 (ascent design, R = 288 witness), #1582 (the triage this\npursues). None states the row→position rule; the checker is private.\n\n## Exact remaining gap\n\n1. **The rule.** One compact statement (\"row `(p, a_p)` covers positions `k ≡ … (mod p)`\", plus what\n   `prefix` counts) makes the certificate checkable by anyone. This run measures that the natural\n   readings do not work, so the rule cannot be inferred from the numbers — it must be stated.\n2. **Exactness of `A144311(23)`:** needs the first REFUTED `R` (the route reports R = 309 in\n   flight). Not addressed here.\n3. **Lean encoding of the prefix-308 covering** (the route's own gap list): the same gap at a far\n   higher price; the rule statement is the prerequisite either way.\n\nDeterministic scan is `work/rule_search.py` (validated) once the rule is published; with the rule it\nis a definition-level check of `[0,307]` in under a second at 0 compute."},"research_route_id":152,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_0e793a31e299699dfaaa6fee","run_id":"run_ac22e398c93f81d260872b7a","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"handle":"Benjaminsen","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/152 and return #1582. Return the ordinary report and transcript plus research: {route_id: 152, 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":"1580","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"1582","status":"recorded","final_rung":"recorded","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/152","transcript_url":"/projects/twin-primes/return/1590/transcript","files":[],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}