{"id":687,"job_id":1476,"problem_id":1,"lane_id":2,"type":"explore","user_id":34,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Triage — research route 40, \"pay the translate census, not the transfer\" (job #1476)\n\n**Verdict: `promising`, but not for the experiment the route proposed.** The route's own named\nnext step is *defeated by measurement* on both halves; a different, cheaper step replaces it.\nThis is a triage: no published number is re-derived, and the route is not closed.\n\n## 1. What was measured (33.05 s, exit 0, under this run's Windows job object)\n\nOne script, three sections. `artifacts/check-1476.py`; the job-object enforcement record is\n`artifacts/check-1476.job.json` (wall, job/user CPU time, per-process memory, process-tree\nownership; `survivors: []`, peak process memory 828,407,808 B against the 8,589,934,592 B cap,\nuser CPU 22.27 s against the 1600 s cap).\n\n### A. The bitset producer is VALIDATED — and the route's failure condition does not fire\n\nThe route makes validation mandatory: *\"an implementation that disagrees with a fully enumerated\ncensus is simply wrong and must not be used at a new level.\"* So the producer was written only to\nbe checked against the census this run already filed (#675, `artifacts/check-1454.out.json`).\n\nIt reproduces that census **exactly, on every offset**, at x = 5, 7, 11, 13 — full sweeps of 14,\n104, 1154 and 15014 even offsets, all twelve filed aggregates identical (`W`,\n`even_offsets_enumerated`, `cover_0`, `cover_2`, `max_cover`, `max_plus1`, the whole `argmax` set,\n`argmax_count`, `argmax_has_offset2`, `distinct_cover_values`, `cover_min`, `cover_mean`). At\nx = 17 a 203-offset cross-check against the filed numpy `census()` agrees on **201 of 203**; the\ntwo exceptions are offsets my sample included that the census never sweeps because they are\n**odd** (W//2 = 255255 and W//2 + 2). At an odd offset the class pair {0, −τ} is {0, 1} mod 2, so\nprime 2 kills every position, `adm(τ)` is empty, the numpy census returns its `None`\n(no-survivor) sentinel and the bitset returns W = 510510, which is what the arithmetic says. That\nis a convention difference at a degenerate parity, caused by my sampling, not a disagreement:\n**on the domain the census is defined on, the two implementations agree everywhere tested.**\n\nTwo defects were found and fixed while writing the producer; both are recorded because each would\nhave produced plausible wrong numbers rather than an error:\n\n1. The kill mask needs `rot(NC, −τ)`, not `rot(NC, τ)`. The wrong sign is invisible on τ = 0 and\n   on τ = 2 (the identity `cover(τ) = cover(W−τ)` makes the wrong-sign map a mirror image, so the\n   *multiset* of cover values, and therefore max, mean and distinct-value count, still describe\n   the same function) — it shows up only as a mirrored argmax set and 5 wrong offsets at x = 5.\n2. The binary-lifting run length must move a **zero** to position 0 before the linear scan.\n   Rotating the other way leaves a one at position 0, splits the run that wraps the word\n   boundary, and silently *undercounts* cover. This produced 2–4 short values on scattered offsets\n   (x = 5: τ ∈ {4, 6, 10, 14, 16}; x = 7: {4, 6, 8}; x = 11: {6, 8}) while every aggregate that a\n   casual check would look at — max, cover(2), the identity — still passed.\n\n### B. The route's instrument does not buy the level the route needs\n\nMeasured per-offset cost of the exact producer, and what it implies for the full sweep it needs:\n\n| level | W | even offsets | cost/offset | full sweep | with τ → W−τ | route budget |\n|---|---|---|---|---|---|---|\n| x = 17 | 510510 | 255255 | **1260 µs** | 0.089 h | 0.045 h | — |\n| x = 19 | 9699690 | 4849845 | **55.7 ms** | **75.1 h** | **37.5 h** | 3 CPU-h |\n\nThe filed numpy census costs 1014 µs/offset at x = 17 (258.86 s for the same 255255 offsets). So\nthe bit form is **not faster than the census it was meant to replace** (1260 vs 1014 µs — 1.24×\n*slower*), and at x = 19 it is far past the route's own budget: **37.5 h even after halving by the\nτ → W−τ symmetry the route does not use**. The route's own cost note (24.7 h at x = 19, from an\n18.3 ms/offset figure the Kalmynin lift test measured) was already outside its stated\n`cpu_hours: 3`; the exact implementation is **3× worse per offset** than that figure, because the\nW-bit operations and the log-depth run refinement both grow with the mask. Route 40's step (2) —\n\"if the full x = 19 sweep is under about 2 h, run it\" — is therefore answered: it is not, by a\nfactor of ~19. Only the route's own fallback (transition classes only) survives, and a footnote\nin its own step (2) says that fallback yields a *certified lower bound*, not the price.\n\n### C. The overlap ledger is a relabelling of \"which primes divide τ\" — the named mechanism carries no new information\n\nThe route names the overlap ledger as its second object and states its failure mode precisely: the\nledger is empty of content if the kill-count histogram is *injective* in τ. It is not injective —\nso that failure mode does not fire — but it fails for a reason the route did not anticipate.\n\n| level | even offsets | distinct histograms | distinct divisor signatures p\\|τ | cover values per histogram class | argmax | argmax class |\n|---|---|---|---|---|---|---|\n| x = 11 | 1154 | **15** | **15** | up to **9** | 16 | one class, strictly larger than argmax |\n| x = 13 | 15014 | **31** | **31** | up to **17** | 32 | one class, strictly larger than argmax |\n\nTwo exact readings:\n\n* **The histogram and the divisor signature carry the same information.** Their class counts are\n  equal at both levels (15 = 15, 31 = 31), i.e. the kill-count histogram of the two-class system\n  adds nothing beyond the set of primes dividing the offset — which is also what the arithmetic\n  predicts, since a prime removes two classes when p ∤ τ and **one** when p | τ. So the \"overlap\n  ledger\" is a relabelling of τ's divisor set, not an independent overlap mechanism, and cannot\n  be the compressed carrier the route wants it to be.\n* **It does not characterise the argmax.** All argmax offsets do share one histogram class, but\n  that class is strictly larger than the argmax set at both levels, and cover takes up to 9 (x = 11)\n  and 17 (x = 13) distinct values inside a single class. So knowing the ledger does not tell you\n  cover, and knowing the class does not identify the maximisers.\n\n**Consequence for the route.** Its second object is answered negatively at x ≤ 13 (cheaply, from\nthe filed census's own instrument), so the ledger branch should be dropped rather than funded. Its\nfirst object — whether the price Π(x) = (1 + max_τ cover)/(1 + cover(2)) is x^{o(1)} — is *not*\nanswered and is *not* answerable by the instrument the route names, at the budget it states.\n\n## 2. Prior art: the mechanism exists for the one-class object and the two-class density exists\n\nThe online pass (2026-09-16; conventions that own the object) located two sources the record does\nnot carry, and they change what the route's novelty claim can be.\n\n* **Costello & Watts, *A computational upper bound on Jacobsthal's function*, arXiv:1208.5342\n  (2012).** They define φ(b, m, k) = the number of integers coprime to P_k in a window of m\n  consecutive integers starting after b, and φ_min(m, k) = its minimum **over all b** — that is,\n  the one-class object *uniform in the window position*, which is the exact analogue of the\n  route's \"uniform in the offset\". Their bound is proved by an expression whose correction term is\n  stated as arising \"due to constraints on the **co-occurrence** of residues of the primes up to\n  p_k\", and their exact recurrence,\n  φ(b,m,k) = m − Σ_i F_{b,m}(p_i) + Σ_j F_{b,m}(2p_j) + Σ_{i<j} φ(c_b(p_i p_j), F_{b,m}(p_i p_j), i−1),\n  is a recursion over **prime pairs** — which is precisely the overlap structure the route calls\n  \"the binding constraint\" (the corpus's own §4d). It yields h(k) ≤ 0.27749612254 k² log k for\n  50 ≤ k ≤ 10000, hundreds of orders of magnitude better than Kanold/Stevens. **So the overlap\n  technique is not new; what is missing is its two-class form.**\n* **Zhao, *Proof of Existence of Integers Excluding Two Residue Values in a Specific Range*,\n  arXiv:2501.15707 (Jan 2025).** Two residue values excluded modulo every prime ≤ p_k, inside\n  [p_k², p_{k+1}²], uniform in the chosen residues, via the Mertens-type density\n  ∏_{2<p<x}(1 − 2/p) = C₂ (ln x)^{−2}(1 + o(1)) with C₂ ≈ 1.07 — the density of the two-class\n  admissible set. This is a located source on **the two-class union of residue classes, uniform in\n  the residue choice**, but by density in a short interval, not an exact covering capacity as a\n  function of the offset. (Short paper, non-specialist venue; used here as a located source, not as\n  authority.)\n\n**Exact remaining gap, sharpened.** No located source and no document in this record bounds the\ntwo-class covering capacity **as a function of the offset**, and none compares the fixed (τ = 2)\nand free (max over τ) members of that family. But the *method* that would do it is published\n(Costello–Watts) and uniform in its own free parameter. That is a materially different — and\nnarrower — novelty claim than the route's blanket \"no source states any bound uniform in the\noffset\". Nguyen's 2026 preprint (`preprints.org` 202608.1299), already carried from #675, remains\nthe nearest relative on the object itself.\n\n## 3. Recommended bounded next step (distinct from the route's, and cheaper)\n\n**Question.** Can the two-class covering capacity be bounded as a function of the offset by the\nCostello–Watts pair-co-occurrence recursion — in time independent of the period W — far enough to\ndecide whether the price Π(x) stays x^{o(1)}?\n\n**Method.** (1) Map their recurrence: their correction term counts, for each pair of primes\np_i p_j, a reduced coprime count on the corresponding arithmetic subsequence. For the two-class\nfamily the killed set is the union of two arithmetic progressions per prime, so the same pair\nstructure applies with F_{b,m}(p) replaced by the count of integers ≡ 0 or ≡ −τ (mod p) in the\nwindow, and the (ω_k − 1) multiplicity replaced by the kill multiplicity. Implement it, and\nvalidate it against the filed census at x ≤ 13, which this triage's producer now reproduces\nexactly, on every offset. (2) Controls: the two custody identities cover(0) + 1 = A048670(π(x)) and\ncover(2) = A144311(π(x)) at every level, plus a full-aggregate comparison at x ≤ 13. (3) Use it to\ncompute the price at x = 19 and x = 23 and report the gap to the exact value at the levels where\nexactness is known.\n\n**Success.** A bound on max_τ cover — hence on Π — assembled in under ~2 CPU-h, whose gap to the\nexact value is *measured* at x ≤ 13, and which either keeps Π in its observed band [1.0, 2.3] or\nshows it growing. Either reading is a result: the first makes L7's τ = 2 statement inherit the free\nobject's bounds; the second means the record's imported difficulty floors are the wrong member's\nand route 32 must be re-aimed.\n\n**Failure.** φ_min in Costello–Watts is itself an optimisation over window positions; if the\ntwo-class version cannot be closed without the one-class admissibility they rely on, or if the\nassembled bound is vacuous against the filed census at x ≤ 13, then the method does not map onto\nthis object and the price question should be **closed** rather than funded again.\n\n**Budget.** 4 h of reasoning time, 2 CPU-h, 8 GB RAM. No new source is needed; all three cited\nsources are readable at the record.\n\n## 4. Scope, disclosure, and what this triage does NOT claim\n\n* It does **not** re-derive any published number, does not recompute a ladder, and does not\n  reproduce the census: the census enters only as the control the route itself demanded. The\n  per-offset costs are measurements on this machine, not properties of the mathematics.\n* The route's **central question is open**. Nothing here bounds Π(x); the record's five measured\n  values (1.5000, 1.0000, 1.5714, 2.2727, 1.7778) are unexplained by this triage, and the constant\n  -versus-growth question is untouched.\n* The 20 assertions in `check-1476.out.json` are **not all \"hoped-for\" outcomes**: 10 pass, and\n  the 10 that fail are labelled with their meaning. Eight encode the ledger HOPES (injectivity\n  etc.) and their failure *is* section C's finding (the ledger compresses but does not\n  characterise); one is B3, the producer-beats-census comparison, whose failure is the honest\n  negative of section B; one is A6, the odd-offset convention artifact explained in section A. A\n  reader who takes \"failed\" as \"the code is broken\" will misread the file; that reading is\n  corrected here.\n* The producer's two defects (section A) were found by the control, not by inspection. That is the\n  third time in this run's history that a control caught its own author; it is recorded as the\n  reason the route's mandatory validation step is worth its cost.\n* `author_rung: measured`; `evidence_md` is section 1–2. Nothing outside this repository was\n  recomputed, and no credential or private payload is in any artifact.\n","patch":null,"cpu_hours":0.0084,"hashes":{"check-1476.py":"5c7e6cf73c2f8e564ffe2a5d3c7d5e28f48fff2974d27f46effeea5126dd6bda","check-1476.job.json":"1cfbd7bbfee2c23b952bc242d711b2c963a89bea4a3459ed73355e3b93bb266e","check-1476.out.json":"b8252e245d86f86b13fa51b30c3b70902fa8deb1ddaebbafdde82e4f4ffc95d7","1cfbd7bbfee2c23b952bc242d711b2c963a89bea4a3459ed73355e3b93bb266e":"check-1476.job.json","5c7e6cf73c2f8e564ffe2a5d3c7d5e28f48fff2974d27f46effeea5126dd6bda":"check-1476.py","b8252e245d86f86b13fa51b30c3b70902fa8deb1ddaebbafdde82e4f4ffc95d7":"check-1476.out.json"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-09-16T12:42:51.283Z","repo_url":null,"commit":null,"cites":{"files":[],"handles":[],"returns":[675,647,650],"messages":[]},"tokens":{"log":"custom","input":0,"models":{"deepseek-v4-flash":0},"output":0,"source":"none","entries":0,"cache_read":0,"cache_write":0,"already_counted":{"of":1,"on":["return #688"],"entries":1},"observed_models":["deepseek-v4-flash"]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — job #1476 (`bf4-911665bf27f8081b1e`)\n\nEverything in the report reproduces from one script and one command, in 33 s. The producer writes\nits own artifact to `--out`; stdout carries one compact JSON summary only, stderr one progress\nline per section.\n\n## Run it\n\n```\nC:/Python314/python.exe <sahx.py> jobs --run bf4-911665bf27f8081b1e \\\n  --timeout 1200 --mem-mb 8192 --cpu-s 1600 \\\n  --registry <run>/state/jobs-registry.json --out <run>/artifacts/check-1476.job.json \\\n  --cwd D:/AI/TwinPrimeProject -- \\\n  C:/Python314/python.exe <run>/artifacts/check-1476.py \\\n  --out <run>/artifacts/check-1476.out.json \\\n  --validate-to 13 --sample-x 17 --sample-n 200 --cost-x 19 --cost-sample 300\n```\n\n`sahx jobs` (sah-ext/3.0.0) runs the command inside a Windows job object: wall clock\n(`WaitForSingleObject` + `TerminateJobObject`), job/user CPU time, per-process and job memory, and\nprocess-tree ownership (`JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`) are enforced by the OS and written to\n`--out`. Recorded run of 2026-09-16T13:0xZ: exit 0, `timed_out: false`, **33.05 s**, user CPU\n22.27 s, peak process memory 828,407,808 B against the 8,589,934,592 B cap, `survivors: []`.\n\n## Inputs\n\n1. **The filed #675 census**, `artifacts/check-1454.out.json`, and its code\n   `artifacts/check-1454.py` — loaded as a module (`importlib`, the file name contains a hyphen)\n   and used two ways: `census()` as the independent reference implementation, and `census[<x>]` as\n   the frozen aggregate block the producer is checked against. Nothing from it is re-derived for\n   its own sake; it is the control.\n2. **The primorial periods the script builds itself** (`primes_upto`, numpy `packbits`). No\n   external covering data, no published ladder recomputation.\n\n## What it computes\n\n* **Producer.** `NC` = bitmask of positions non-coprime to W. Position r is killed at offset τ iff\n  r is non-coprime to W or r + τ is, i.e. r ∈ NC or (r − τ) ∈ NC, so\n  `cov(τ) = NC | rot(NC, −τ)` and **cover(τ) = longest cyclic run of killed positions** (one more\n  than the survivor gap `maxwrapgap(adm(τ))`).\n* **Exact longest run.** `power_masks` gives `pw[j]` = positions where a run of 2^j ones starts;\n  the largest power present is found by iteration, then a greedy log-step extension over the same\n  masks gives the exact maximum. A lower-bound-only variant undercounts and is not used; and a\n  **zero** must be rotated to position 0 first, otherwise the run that wraps the word boundary is\n  split (this was a real defect: it produced 2–4 short values on scattered offsets).\n* **Section A** sweeps every even offset at x = 5, 7, 11, 13 and compares twelve aggregates with\n  the filed block; separately cross-checks a 203-offset sample at x = 17 against the filed\n  `census()` itself.\n* **Section B** times the producer over sampled offsets at x = 17 and x = 19 and projects the full\n  sweep, with and without the τ → W − τ symmetry.\n* **Section C** computes, per offset, the kill-count **histogram** by a bit-sliced DP over the\n  per-prime kill masks (precomputed per prime and residue), plus cover, and reports class counts,\n  whether cover is a function of the histogram and of the divisor signature, and whether the\n  argmax set is one histogram class.\n\n## Output\n\n`check-1476.out.json`, one JSON document, `indent=1`, `sort_keys=True`, newline `\\n`:\n`A_validation` (per level: the twelve aggregates, `matches_filed_census`, `mismatches`, timing;\nplus `sample_crosscheck`), `B_cost` (per level and `verdict`), `C_ledger`, the 20 `checks` with\nobserved/expected, `failures`, `passed`, `total`, `ok`, `seconds`. Deterministic: no randomness,\nno network, OLS-free. Run on CPython 3.14.6 with numpy 2.4.4.\n\n**Reading `failures`.** The 10 failing assertions are findings, not breakage: 8 encode the ledger\nHOPES (their failure is section C — the ledger compresses but does not characterise cover), 1 is\nB3 (the producer is 1.24× *slower* than the census: the honest negative), and 1 is A6, where two\nsampled offsets are odd, the filed census never sweeps odd offsets, and its `None` no-survivor\nsentinel meets the bitset's arithmetically correct W. See report.md §4.\n\n## Cost, and where it stops\n\n33 s total: A 2 s, B 19 s (the x = 19 sample of 300 offsets is 16.7 s of it), C 12 s. The measured\nper-offset costs are x = 17: 1260 µs; x = 19: 55.7 ms → a full x = 19 sweep is **75.1 h**, or\n**37.5 h** with the τ → W − τ symmetry the route does not use; x = 23 would be far beyond that and\nadditionally needs a residue set of 36,495,360 Python integers. This is why the route's own step\n(2) is not executable at its stated `cpu_hours: 3`, and why the recommended next step replaces the\nsweep with a co-occurrence recursion whose cost does not scale with W.","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-18T23:09:51.598Z","file_notes":null,"research":{"outcome":"promising","route_id":40,"next_step":{"method":"Same run, same conventions, no new source. (1) Map their recurrence: their correction term counts, for each pair of primes p_i p_j, a reduced coprime count on the corresponding arithmetic subsequence. For the two-class family the killed set is the union of two arithmetic progressions per prime, so the same pair structure applies with F_b,m(p) replaced by the count of integers congruent to 0 or -tau (mod p) in the window, and the (omega_k - 1) multiplicity replaced by the kill multiplicity. Implement it and VALIDATE it against the filed census at x <= 13, which this triage's producer now reproduces exactly on every offset (that validation is a mandatory control, not an option). (2) Controls: the custody identities cover(0) + 1 = A048670(pi(x)) and cover(2) = A144311(pi(x)) at every level, plus a full-aggregate comparison at x <= 13. (3) Use it to compute the price at x = 19 and x = 23 and report the gap between the assembled bound and the exact value at the levels where exactness is known, and say plainly whether the bound can separate a constant Pi from a slow growth. Dropped by this triage and NOT to be funded: the overlap-ledger branch (section C answers it negatively) and any full census sweep at x >= 19 (75.1 h, or 37.5 h with symmetry, against a 3 CPU-h budget).","compute":{"ram_gb":8,"disk_gb":1,"cpu_hours":2},"failure":"This attempt is defeated if phi_min in Costello-Watts is itself an optimisation over window positions that cannot be closed for two classes per prime without the one-class admissibility they rely on, or if the assembled bound is vacuous against the filed census at x <= 13 -- in which case the method does not map onto this object and the price question should be CLOSED rather than funded again. A failure here does not defeat the route's object or its verified identity; it defeats the borrowed method, and the honest fallback is to close the route with the five measured price values recorded as the end state.","success":"A bound on max_tau cover -- hence on Pi -- assembled in under about 2 CPU-h, whose gap to the exact value is measured at x <= 13, and which either keeps Pi inside its observed band [1.0, 2.3] or shows it growing. Either reading is a result: the first would make L7's and route A's tau = 2 statements inherit the free object's bounds up to a constant, so that the corpus's imported floors are the right member's after all; the second would mean the project's target is asymptotically easier than the published conjecture and return #647's route 32 needs re-aiming, a decision the record can act on immediately. Either way the validated producer, the exact identity test and the ledger verdict of this triage stand.","question":"Can the two-class covering capacity be bounded as a function of the offset by the Costello-Watts pair-co-occurrence recursion -- in time independent of the period W -- far enough to decide whether the price Pi(x) = (1 + max_tau cover)/(1 + cover(2)) stays x^{o(1)}?","budget_hours":4,"required_tools":[],"required_sources":["costello-watts-cooccurrence","oeis-ladders","zhao-two-residue"]},"depends_on":[675],"evidence_md":"TRIAGE VERDICT: the route's own named next step is defeated by measurement on BOTH halves; a different, cheaper step replaces it. Measured in 33.05 s, exit 0, under this run's Windows job object (survivors: [], peak 828 MB against an 8 GB cap, user CPU 22.27 s). THREE READINGS. (1) THE PRODUCER THE ROUTE SPECIFIES IS VALIDATED BUT DOES NOT BUY THE LEVEL THE ROUTE NEEDS. The bitset producer reproduces the filed #675 census exactly, on every offset, at x = 5, 7, 11, 13 (all twelve filed aggregates identical, full sweeps of 14/104/1154/15014 even offsets), and agrees with the filed numpy census on 201 of 203 sampled offsets at x = 17 -- the two exceptions are ODD offsets my sample included, where the census returns its no-survivor None and the bitset returns W, which is what the arithmetic says for the class pair {0,1} mod 2; the census only sweeps even offsets. BUT the exact producer costs 1260 us/offset at x = 17 versus 1014 us for the filed numpy census it was meant to replace (1.24x SLOWER), and 55.7 ms/offset at x = 19: a full x = 19 sweep is 75.1 h, or 37.5 h even after halving by the tau -> W - tau symmetry the route does not use. The route's budget is cpu_hours 3. So its step (2) -- 'if the full x = 19 sweep is under about 2 h, run it' -- is answered: it is not, by about 19x, and its own fallback (transition classes only) yields a certified LOWER bound, not the price. (2) THE ROUTE'S SECOND OBJECT IS ANSWERED NEGATIVELY, CHEAPLY. The kill-count histogram is NOT injective in tau, so the declared failure mode does not fire; it fails for a reason the route did not anticipate. At x = 11 there are 15 distinct histograms over 1154 offsets and 15 distinct divisor signatures p|tau; at x = 13, 31 and 31 over 15014 offsets. Equal class counts at both levels means the histogram carries EXACTLY the information 'which primes divide tau' and nothing more -- as the arithmetic predicts, since a prime removes two classes when p does not divide tau and one when it does. So the 'overlap ledger' is a relabelling of tau's divisor set, not an independent overlap mechanism. It also does not characterise the argmax: all argmax offsets share one histogram class, but that class is strictly larger than the argmax set, and cover takes up to 9 (x = 11) and 17 (x = 13) distinct values inside a single class. (3) THE ROUTE'S CENTRAL QUESTION IS UNTOUCHED AND STILL OPEN. Nothing here bounds Pi(x) = (1 + max_tau cover)/(1 + cover(2)); the five measured values are unexplained by this triage. TWO DEFECTS FOUND BY THE CONTROL, kept visible because each would have produced plausible wrong numbers rather than an error: the kill mask needs rot(NC, -tau) not rot(NC, +tau) (invisible on tau = 0 and tau = 2 because tau -> W - tau makes the wrong-sign map a mirror of the right one, so max, mean and distinct-value counts still describe the same function), and the exact longest-run algorithm must rotate a ZERO to position 0 first, else the run wrapping the word boundary is split and cover is silently undercounted (it produced 2-4 short values on scattered offsets while every casual aggregate still passed). This is the third time in this run's history that a control caught its own author, and it is the reason the route's mandatory validation step is worth its cost. SCOPE: no published number is re-derived; the census enters only as the control the route itself demanded; the per-offset costs are measurements on this machine, not properties of the mathematics.","prior_art_md":"Online pass 2026-09-16 in the conventions that own the object (Jacobsthal function / primorial wheels / paired progressions). Queries: 'Jacobsthal function two residue classes offset dependence covering capacity primorial bound uniform in shift' (deep); 'Jacobsthal function p# two residue classes maximum run covered residues overlap counting 2026' (deep); 'maximum gap integers each covered by at least one of two residue classes modulo each prime primorial offset dependence' (deep); 'Hagedorn Jacobsthal function tables primorials two residues computation upper bound' (deep). TWO LOCATED SOURCES THE RECORD DOES NOT CARRY, AND THEY RESHAPE THE NOVELTY CLAIM. (1) Costello and Watts, 'A computational upper bound on Jacobsthal's function', arXiv:1208.5342, read at https://arxiv.org/html/1208.5342v2 on 2026-09-16: they define phi(b,m,k) = the number of integers coprime to P_k in a window of m consecutive integers starting after b, and phi_min(m,k) = its minimum OVER ALL b -- the one-class object uniform in the window position, the exact analogue of the route's 'uniform in the offset' -- and prove a bound whose correction term is stated to arise 'due to constraints on the co-occurrence of residues of the primes up to p_k', with the exact recurrence phi(b,m,k) = m - sum_i F_b,m(p_i) + sum_j F_b,m(2 p_j) + sum_{i<j} phi(c_b(p_i p_j), F_b,m(p_i p_j), i-1): a recursion over PRIME PAIRS, which is precisely the overlap structure the corpus's own section 4d calls the binding constraint. It yields h(k) <= 0.27749612254 k^2 log k for 50 <= k <= 10000. So the route's mechanism is NOT new as a technique: it exists for the one-class object and is uniform in its own free parameter; what is missing is its two-class form. (2) Zhao, 'Proof of Existence of Integers Excluding Two Residue Values in a Specific Range', arXiv:2501.15707 (2025), read at https://arxiv.org/html/2501.15707v1 on 2026-09-16: two residue values excluded modulo every prime <= p_k inside [p_k^2, p_{k+1}^2], uniform in the chosen residues, via the Mertens-type density product_{2<p<x} (1 - 2/p) = C_2 (ln x)^{-2} (1 + o(1)) with C_2 about 1.07 -- the density of the two-class admissible set. A located source on the two-class union of residue classes uniform in the residue choice, but by density in a short interval, not an exact covering capacity as a function of the offset. (Short paper, non-specialist venue: used as a located source, not as authority.) EARLIER WORK RE-READ, NOT REPEATED: the four OEIS ladders already carried from #675 (A144311, A288815, A072753, A048670 with their read URLs, dates and shas in artifacts/check-1454.py); the corpus's two-class-lower-bounds.md sections 1-12, sift-limit-attack.md 6-7e, covering-dive.md, PRIOR-ART.md, history/staging/qc-wave6-X.md (the [ABSENT] adjudication narrowing the gap to the fixed pair {0,-2}); Nguyen, 'Finite-Window Noncovering on Primorial Wheels', preprints.org 202608.1299, the nearest relative on the object itself. EXACT REMAINING GAP, SHARPENED: no located source and no document in this record bounds the two-class covering capacity AS A FUNCTION OF THE OFFSET, and none compares the fixed (tau = 2) and free (max over tau) members of that family -- but the METHOD that would do it is published and uniform in its own free parameter. That is a materially narrower claim than the route's blanket 'no source states any bound uniform in the offset'. ACCESS GAPS: the preprints.org and SciPy/Scilit mirrors of Nguyen's preprint still return 403 here; Kalmynin-Konyagin arXiv:2302.00459 was not re-read at source (the corpus carries its abstract and the 4c substitution). A located match is not a novelty claim."},"research_route_id":40,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_bd08e49ed9621cfd852f9b04","run_id":"run_37d99fa98129d26560a2c65d","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"handle":"maxime-fleury","job_brief":"Search online for existing attempts, results, tables and datasets before testing feasibility. Reuse the recorded search and inspect the closest sources and weakest assumption. Use published numbers with citations; do not reproduce them in triage. Seek the smallest experiment on the uncovered step. Recommend promising only with specific evidence and a bounded next step; do not claim the route is proved. Map the assumptions of any borrowed method onto this problem.\n\nRead GET <project base>/research-routes/40 and return #675. Return the ordinary report and transcript plus research: {route_id: 40, 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":"675","status":"accepted","final_rung":"measured","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/40","transcript_url":"/projects/twin-primes/return/687/transcript","files":[{"sha256":"5c7e6cf73c2f8e564ffe2a5d3c7d5e28f48fff2974d27f46effeea5126dd6bda","name":"check-1476.py","bytes":16047},{"sha256":"b8252e245d86f86b13fa51b30c3b70902fa8deb1ddaebbafdde82e4f4ffc95d7","name":"check-1476.out.json","bytes":12089},{"sha256":"1cfbd7bbfee2c23b952bc242d711b2c963a89bea4a3459ed73355e3b93bb266e","name":"check-1476.job.json","bytes":472}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}