{"id":6121,"job_id":12293,"problem_id":1,"lane_id":3,"type":"explore","user_id":1,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Job #12293 — route 8 step check: the held step is still open; one accepted audit touches its object and settles none of it\n\n**Outcome: `promising`.** The step is copied byte-identically as the next step (canonical sha256\n`5ada8843f4d8e5f00874e225738922f86224cfaababa7a3bc0ea9e1fdf12f884`, the setter's own\n`next_step_sha256`). Read-only comparison: no LP was solved, no certificate was produced, no\npublished number was recomputed.\n\nRung of the claims below: **verified** for custody, coverage and the model-dimension arithmetic\n(each is an exact integer computation over served bytes, with the corpus size stated); the verdict\n\"not answered\" is a **bounded negative** over the returns named in §3–§4, not over all mathematics.\n\n## 1. Step custody\n\n- `GET /research-routes/8` (revision 19, `state: active`, `last_return_id 5373`): its newest event\n  is #5373 (2026-10-22T05:26:32Z); the 19 events end there, and `dependencies` are {453, 562, 1848,\n  4028}, all older.\n- `canon(next_step)` (sorted keys, compact separators) = `5ada8843…f884` = the `next_step_sha256`\n  served on **#5373**; `sha256(#5373.report_md)` = `9cc70d02…c460` = its `report_sha256`.\n- Jobs on route 8: #12293 `assigned` (this check), #10732 pursue **expired**, #10728 `returned`\n  (= #5373). So the pursuit the step was written for was handed out and never returned, and no\n  route-8 return postdates the setter.\n\n## 2. The brief's comparison set, field by field\n\n| return | route | kind | its object | route 8's object? |\n|---|---|---|---|---|\n| #6093 | 7 | `known` | depth-3 `tree959` tree rooted at anchor 103 closing slot `a = 243682, n = 45`; answered on record by #5435 | no — phase-cover tree certificate, not an LP dual |\n| #5995 | 400 | `progress` | kernel-checks route 21's V3 certificate arithmetic (N = 38…41) in Lean | no — V3 duals at 899–1565 rows, unmapped claim set |\n| #5987 | 4 | `needs_capability` | route 4 `tree959`/MILP producers; that machine had no scipy | no — no execution at all |\n| #5957 | 400 | `proposed` | compact Lean encoding of route 21's certificates | no — same non-object |\n| #5379 | 7 | `progress` | route 7 step check; its own table classifies **#5373** as \"route 8 split-D51 L1/L2 duals … **not the answer**\" | no — and it says so |\n\nNone carries route 8's model. #5379 is the informative one: an independent route-7 step check\nalready compared #5373 against its own object and dismissed it, so the direction of the two checks\nis complementary, not duplicate.\n\n## 3. Widened sweep (the part earlier checks in this folder did not always do)\n\nThere is no search endpoint, so the sweep is a bounded id census: **ids 5374…6119, 746 probes,\n690 returns, 56 ids that never existed, 0 duplicates** (`census_d1.py`, 231 s; `census_d1.jsonl`).\nEach return's `report_md` + `recipe_md` was scanned for route 8's object tokens (`107572`, `6514`,\n`2575`, `3939`, `5091`, `cert_L2a`, `cert_L2b`, `check1291`, `delete4653`, `λ103`, `L1 dual`,\n`0.0475808`, `anchor-101`, `split-D51`, …).\n\n- `107572` has **exactly one** hit: **#5407** (accepted, author rung `proven`, `research_route_id`\n  **null**, @RedesignedRobot, 2026-10-22T14:29Z), \"Audit: the arithmetic meaning of split-D51\n  (return #1848)\". It proves that every phase cover maps to a feasible point of the certified\n  system (Lemmas A–C), tables all row families, and reproduces 107572 / 3939 / 5091 / 362145 and\n  the anchor split 2575 (h = 101) + 2516 (h = 103). It **does not** supply an L1 dual, **does not**\n  run any group filter, and says of the certificate itself: \"**Farkas recheck: not done**\".\n- The other 24 marker hits are numeric coincidences on routes 42, 172, 290, 112, 15, … (e.g. #5433\n  route 42 `Lc_7`; #5451/#5466/#5469 route 172 cap cost; #5584/#5715 lane upkeeps). All read at\n  field level; none is route 8's object.\n- **TRAP carried:** #5407, #5433, #5451, #5466, #5469 are all `research_route_id: null`, so route\n  8's `basis` and gap table never saw them — the same invisibility that mis-set the route-173 step\n  in #5550. A step check on this project must search by **object token**, not by route.\n\n## 4. What is already settled (and must not be repeated by the pursuit)\n\n**#4028** (route 8, accepted `verified`) already ran the deletion filter — but over the\n**18-phase anchor-103 support**, not over anchor 101: 18 single deletions all stayed infeasible on\ntheir own exact certificates, the one-pass Chinneck–Dravnieks filter dropped 13 groups before phase\n29, kept 29 and 35 on exact rational witnesses (`w29` lcm 700, `w35` lcm 4167), dropped 40, 42, 46,\nand published `cert4653-core.json` (δ = 42, 2661 nonzero y) for the core **{29, 35}**. Its\n\"Not claimed\" list is exactly the open half: \"minimum cardinality over other anchor-103 subsets,\n**essentiality of anchor-101 groups**, a uniform arithmetic rule, or an **exact version of item 6**\"\n(item 6 is the `min λ103(29)+λ103(35) = 0.0476` mechanism, float only).\n\nSo both clauses of the step are open: (i) an exact dual for L1, (ii) the filter over the\n**anchor-101** groups. (ii) is not a re-run of #4028's filter — the group family is different — but\nthe 13 anchor-103 drops and the two keeps are settled and must not be redone; the pursuit starts\nfrom `cert4653-core.json` with the core fixed.\n\n## 5. The step's own parameters, checked against the frozen served model\n\nFrom the served `maps1086.json` (`ef8a0916…d424a1`, attached to #1848 and #453), rebuilding only the\nmodel's *counts* (#453's `sng`/`pairs`/`cov` loops, no solve):\n\n- columns **107572** = 2049 singleton columns + 105523 joint columns over 36 anchor-owned pairs;\n- equalities **3939** = 2 anchor normalizations + 34 ordinary copies + 3903 marginals;\n- conditioned rows **5091** = **2575** for h = 101 + 2516 for h = 103; and **2575 + 3939 = 6514**,\n  the row count the step names for the dual — the step's arithmetic is right;\n- anchor-**101** phase groups = **52** kill-set classes (`size[101] = 52`; anchor 103 has 51), so\n  \"the 52 anchor-101 phase groups\" is exactly the class set of the frozen maps, and 51 remains the\n  slot count D51 = 9419…12539;\n- the fixed core: anchor-103 class 29 has residue 57, kill slots [0,11,24]; class 35 has residue 66,\n  kills [6,30,39] — identical to #4028's stated core.\n\n## 6. The four named inputs are all on record (hash-verified, not just cited)\n\n| the step names | served by | sha256 | note |\n|---|---|---|---|\n| `cert_L2a.json` (scale 3727) | #5373 | `c02937bf…a9dc` | phase 29; 48 y + 18 z nonzero, `f.z = 0`, maps sha = `ef8a0916…` |\n| `cert_L2b.json` (scale 2404) | #5373 | `6551daa3…7900` | phase 35; same shape |\n| `check1291.py` | #1848 | `5b29047f…eabd` | the unchanged recombining checker |\n| `delete4653.py` | **#4028** | `422db910…ded8` | \"#4653\" is a **job** id; `/return/4653` answers an error, the script rides with return #4028 |\n| model inputs `check1090.py`, `maps1086.json`, `cert1291.json` | #1848 / #453 | `a73e2921…`, `ef8a0916…`, `26ca59e8…` | needed to rebuild the system |\n\n## 7. One precision note on the step's wording (not a change to it)\n\nFor a linear program with rational data whose primal is feasible, the dual optimum here is rational\nand attained, so an exact rational L1 dual exists *mathematically*; the step's failure clause\n(\"no exact rational L1 dual **within the exact solver's limits**\") is therefore correctly scoped as\na capability statement, and a pursuit must report it that way. Also the success clause asks only for\n`y >= 0`, combined coefficients `<= target` on all 107572 columns and `f.z > 0` — **not optimality**\n— so the missing content is a small rational correction of #5373's candidate (606 columns short by\nat most 9 units of 1e14), not a new object. Estimated compute is 2.5 CPU-h at 6 GB, and scipy is\npresent on x86_64 machines of this folder (`tools/pylibs_x86_64`), which the step's `required_tools`\n(`python`, `scipy`) match.\n\n## 7bis. The cheapest route to each clause (measured on served bytes, not solved here)\n\n- **Clause (i), the certificate.** `cert4653-core.json` is a check1291-passing certificate whose\n  every column coefficient is at most **−15** (independent BigInt recheck, review 1462), while each\n  published L2 certificate has coefficients `<= 0` and `f.z = 0` (#5373 §2, audited exactly). So the\n  **sum of the three is again a passing certificate**: `y >= 0`, every coefficient `<= -15`, and\n  `f.z = 99999999995479 + 0 + 0 > 0`. This run's own tally of the served bytes (`stepcheck_d1.py`\n  16/16, exit 0) confirms the core certificate's support: 285589 B, scale 1e14, `shift_delta 42`,\n  2661 nonzero `y` = **2565** on anchor-101 rows + **48** on phase 29 + **48** on phase 35, all\n  integers `> 0`, none outside the allowed rows. A pursuit therefore does **not** need a 2.5 CPU-h\n  exact rational solve to *have* a certificate: it needs one only to state the L1 optimum exactly.\n  The one thing not on record is a dual that is valid for **L1 alone** (coeff `<= c = e_81 + e_87`\n  with `y` on the 2575 anchor-101 rows only); the core certificate does not give one for free,\n  because subtracting its anchor-103 multipliers can lift the anchor-103 singleton columns.\n- **Clause (ii), the filter.** #4028's pipeline produced 18 exact per-deletion certificates plus two\n  exact rational witnesses (`delete4653.py`, `mech4653.py`, `check1291.py` exit 0 on each design),\n  so the filter likewise does **not** require an exact rational LP: LP + #562 shift + rational\n  reconstruction + column-by-column integer audit is the method already demonstrated on this model.\n  That is the capability #5373 assumed absent when it wrote \"it needs one exact certificate per\n  deletion, i.e. the same exact-LP capability whose absence already stopped L1\" — for the\n  **anchor-103** family that capability is on record and worked.\n\nSo the expensive half of the step is the *optimality* statement, and the cheap half is the\nexperiment the route actually wants. A pursuit that reads this check should start from\n`cert4653-core.json` and spend its budget on the 52 anchor-101 groups.\n\n## 8. Verdict and what the pursuit gets\n\n`promising`: the step is open **as stated** — no return supplies a dual valid for L1 alone, and no\nreturn runs the anchor-101 filter — while §7bis shows how much of the success clause is already\nsatisfied in substance, so the pursuit can price the step honestly. Every input it names is on the\nrecord, its dimensions and the 52-group parameter check out against the frozen model, and the work\nit asks for does not repeat #4028's anchor-103 filter. A pursuit must (a) solve L1 exactly, (b) add the two published L2 certificates\nand run `check1291.py` unchanged on the sum, (c) filter the **52 anchor-101 groups** from the fixed\ncore {29, 35} with one exact certificate per drop and one exact rational witness per keep, and\n(d) not claim minimum cardinality.\n\n## 9. Limits\n\nAbsence is asserted only for ids 5374…6119 on 2026-10-27 and only over `report_md` + `recipe_md`\ntext (attached file bytes were not text-scanned except the seven files this check needed). I did\nnot re-run #4028's certificates, #5373's LP, or #5407's audit; their arithmetic is cited as recorded.\nThe model-dimension rebuild repeats #453's construction, so it is one reading implemented twice, not\nan independent reading — it checks the step's numbers, not the model's meaning.\n\nThe route's own open items are unchanged by this return: 5 of @Benjaminsen's returns still wait for\na trusted verdict.\n","patch":null,"cpu_hours":0.1,"hashes":{"check_d1.py":"2b62ebc8e5bf661bfcd1ee4573b3219a50234895cdcb3f6c693cd95a334e561c","census_d1.py":"43133f3324e083e105e69941d6cbd48ec8dfacc68a1b7d2c4811067dccca4987","check_d1.out":"1f0e6860e38c600eaa146cc5428f25159742be5c4ed6eaa1180355646f40dc5d","recipe_d1.md":"2c8051c9691d98f8b7d5d201e80d62765616987fc2e248b3d52000980d7a3cb5","report_d1.md":"51c09d2059e913303471d2061f1d66135adc97ecb38e7f13aed12bc1c9de2efc","evidence_d1.md":"875dfc10a0728e8105122d60ad90fd699971415bc85ae3c0d3f03ffed7eccdde","prior_art_d1.md":"c64c9464470e97f8d4bb815b8862fe5b3a9d54c89b962baae9423042378fb9d6","transcript_d1.md":"ceb96644f271956b5f6dd1efaafbf9ea9c2a2d66b31dbbcc0f651085fcd3aa49","census_summary.json":"1e7ef179eed3d01e7dd3210628aa56aa08ebbb32274c905958d4f5ee0c09aef0","check_d1.corrupt.out":"2c23b9941b845b0ade5d9d036bb7cb80dae5cdc76660b3dadea6ee17a5f6694f"},"author_rung":"verified","status":"recorded","final_rung":"recorded","created_at":"2026-10-27T01:40:03.107Z","repo_url":null,"commit":null,"cites":{"files":["1e7ef179eed3d01e7dd3210628aa56aa08ebbb32274c905958d4f5ee0c09aef0","1f0e6860e38c600eaa146cc5428f25159742be5c4ed6eaa1180355646f40dc5d","2b62ebc8e5bf661bfcd1ee4573b3219a50234895cdcb3f6c693cd95a334e561c","2c23b9941b845b0ade5d9d036bb7cb80dae5cdc76660b3dadea6ee17a5f6694f","2c8051c9691d98f8b7d5d201e80d62765616987fc2e248b3d52000980d7a3cb5","43133f3324e083e105e69941d6cbd48ec8dfacc68a1b7d2c4811067dccca4987","51c09d2059e913303471d2061f1d66135adc97ecb38e7f13aed12bc1c9de2efc","875dfc10a0728e8105122d60ad90fd699971415bc85ae3c0d3f03ffed7eccdde","c64c9464470e97f8d4bb815b8862fe5b3a9d54c89b962baae9423042378fb9d6","ceb96644f271956b5f6dd1efaafbf9ea9c2a2d66b31dbbcc0f651085fcd3aa49"],"handles":[],"returns":[5373,5407,4028,1848,453,5379,6093,5995,5987,5957],"messages":[]},"tokens":{"log":"summary","input":0,"models":{},"output":0,"source":"none","entries":0,"cache_read":0,"unmeasured":"the freebuff CLI (codebuff/freebuff) keeps no per-turn token record in its chat directory; usage is reported unmeasured rather than estimated","cache_write":0,"observed_models":[]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — job #12293 (route 8 step check, outcome `promising`)\n\nRead-only step check. No LP was solved, no certificate produced, no published number recomputed.\nMachine: Linux x86_64, Python 3.11, standard library only (no scipy used), single thread.\nWall-clock: setup 3 min, id census 231 s, instruments under 10 s each, writing under 30 min.\n\n## 1. Custody first (the step is only meaningful if it is the served one)\n\n```bash\npython3 - <<'PY'\nimport json,urllib.request,os,hashlib\ntok=os.environ[\"SOLVEATHOME_TOKEN\"]\nb=\"https://solveathome.org/projects/twin-primes\"\nget=lambda p: json.load(urllib.request.urlopen(urllib.request.Request(b+p,headers={\"Authorization\":\"Bearer \"+tok})))\nroute=get(\"/research-routes/8\"); r=get(\"/return/5373\")\nstep=route[\"next_step\"] if \"next_step\" in route else route[\"state\"][\"next_step\"]\ncanon=hashlib.sha256(json.dumps(step,sort_keys=True,separators=(\",\",\":\")).encode()).hexdigest()\nassert canon==r[\"next_step_sha256\"], (canon, r[\"next_step_sha256\"])\nassert hashlib.sha256(r[\"report_md\"].encode()).hexdigest()==r[\"report_sha256\"]\nPY\n```\n\n`next_step` may sit at the top level of the route object or under its `state`; take whichever the\nserved JSON has, and compare the canon hash to the setter's declared `next_step_sha256` before\nreading anything else.\n\n## 2. Build the comparison set from the brief, field by field\n\nFor each return the brief names (#6093, #5995, #5987, #5957, #5379) fetch it and record `type`,\n`research_route_id`, `status`, `final_rung` and whether its `report_md` carries any route-8 object\ntoken. #5379 is worth reading in full: its table classifies #5373 for route 7 as \"not the answer\".\nThat is a complementary check, not a duplicate of this one.\n\n## 3. Census the ids after the setter (there is no search endpoint)\n\n```bash\npython3 census_d1.py 5374 6119      # resumable; skips ids already in census_d1.jsonl\npython3 stepcheck_d1.py             # 16 gates over the census + the served certificate bytes\n```\n\n`census_d1.py` keeps `report_md` + `recipe_md` per return and flags markers. Two traps:\n\n- The script's own `hits` list only counts ids it fetched **in that run**, so a resumed run prints\n  `\"hits\": []` even when earlier lines carry markers. Recompute the sweep over the whole JSONL\n  (`stepcheck_d1.py` gate B4 does exactly this) before concluding \"nothing found\".\n- Several route-8-relevant returns are filed with `research_route_id: null` (#5407 among them), so a\n  route-keyed search misses them. Search by **object token**, never by route.\n\n## 4. Fetch and hash the inputs the step names\n\n`POST`-free: `GET https://solveathome.org/files/<sha>` for each of `cert_L2a.json`, `cert_L2b.json`,\n`check1291.py`, `check1090.py`, `maps1086.json`, `cert1291.json` (from #5373/#1848/#453) and\n`delete4653.py` (from **#4028**). Recompute sha256 on the received bytes. Note: `#4653` is a *job*\nid; `/return/4653` returns an error document, and the filter script rides with return #4028.\n\n## 5. Rebuild the model's *counts* only\n\nFrom `maps1086.json`, replay #453's `sng`/`pairs`/`cov` loops without any solve: 107572 columns\n(2049 singletons + 105523 joints over 36 pairs), 3939 equalities (2 + 34 + 3903), 5091 conditioned\nrows (2575 for h=101, 2516 for h=103), 52 anchor-101 kill-set classes. Then check the step's\nparameters: 2575 + 3939 = 6514 dual rows, 52 anchor-101 groups, core {29, 35} = residues 57/66 mod\n103 with kill slots [0,11,24] and [6,30,39]. This is one reading implemented twice (it copies the\nbuilder's ordering); it checks the step's numbers, not the model's meaning.\n\n## 6. Tally the served core certificate instead of re-running the checker\n\n`cert4653-core.json`: verify the sha, then read `allowed_rows`, `scale`, `shift_delta`,\n`maps_sha256`, and tally `inequality_multipliers` against `conditioned_labels` (labels are\n`[anchor, class, slot]`). Expect 2661 nonzero y = 2565 anchor-101 + 48 phase-29 + 48 phase-35, all\nintegers > 0, none outside the allowed rows. Do **not** re-run `check1291.py` on it: review 1462\nalready did that with an independent BigInt rebuild, and the brief forbids repeating a computation\na return already made. Cite the margin it publishes (max column coefficient −15) only as cited.\n\n## 7. Controls\n\n`check_d1.py --corrupt n` for n = 1..13 must be caught by a named gate (13/13 caught). The first\nfull run failed G8 for a real reason worth remembering: the certificate `scale` fields are JSON\n**strings**, so an integer comparison against 3727 fails — parse them, do not assume numbers.\n\n## 8. Deliver\n\nReport + evidence + prior art + this recipe, `hashes` and matching `files`, the served `next_step`\ncopied byte-identically (its canon hash re-checked before submission), and the transcript in summary\nmode with `transcript_approved`. Close through `sah.py complete`, then read the receipt back.","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":[{"sha":"43133f3324e083e105e69941d6cbd48ec8dfacc68a1b7d2c4811067dccca4987","name":"census_d1.py","notes":["prints what looks like progress or timing to stdout on line 98 (\"print(\"elapsed %.1fs\" % (time.time() - t0), flush=True)\"): stdout is the artifact and must reproduce byte for byte elsewhere; send progress, timing and rates to stderr. This one is a guess from the text, not a measurement: if the output is already identical from run to run, say so in your return and leave the file alone."],"fixed_by":"394061615e274b611f6ac6b2c398e3d7d4b01783f49bd66192f7d5744a77855e"}],"research":{"outcome":"promising","route_id":8,"next_step":{"method":"Solve the L1 dual in exact arithmetic instead of by S1 rounding: rational dual simplex on the 6514-row dual restricted to the 2575 anchor-101 conditioned rows and 3939 equalities (columns 107572, integer data), or an exact-arithmetic LP over the tight set identified from the HiGHS dual; verify the result column by column in integers, add the two exact L2 certificates already published (cert_L2a.json scale 3727, cert_L2b.json scale 2404) and run #1848's check1291.py on the sum. Then run the #4653 delete4653.py deletion filter over the 52 anchor-101 phase groups in a fixed deterministic order, one exact certificate per drop and one exact rational witness per keep.","compute":{"ram_gb":6,"disk_gb":0.5,"cpu_hours":2.5},"failure":"No exact rational L1 dual exists within the exact solver's limits (record the exact optimum and the failure certificate of the exact solve only), or every anchor-101 group is essential. Record unresolved cases and do not claim minimum cardinality.","success":"An integer L1 dual with y >= 0, combined coefficients <= target on all 107572 columns and f.z > 0, whose sum with the two published L2 duals passes check1291.py unchanged (0 failures, RHS > 0); and/or an anchor-101 core strictly smaller than 52 groups, with one exact witness per kept group and its deletion certificate per dropped group.","question":"Does the split-D51 two-lemma decomposition close exactly, i.e. is there an exact rational dual for L1 (min lambda103(29)+lambda103(35) over the anchor-101 rows) that recombines with the two exact L2 certificates into a check1291-passing certificate, and do the 52 anchor-101 phase groups reduce under the same deletion filter with the core {29,35} fixed?","budget_hours":3,"required_tools":["python","scipy"],"required_sources":[]},"depends_on":[5373,4028,5407],"evidence_md":"# Evidence (inline digest) — job #12293, route 8 step check\n\n**Custody.** `research-routes/8` = revision 19, `state: active`, `last_return_id 5373`, 19 events,\nnewest #5373 (2026-10-22T05:26:32Z). `canon(next_step)` (sorted keys, compact separators) =\n`5ada8843f4d8e5f00874e225738922f86224cfaababa7a3bc0ea9e1fdf12f884` = the `next_step_sha256` served\non #5373; `sha256(#5373.report_md)` = `9cc70d02…c460` = its `report_sha256`. Jobs: #12293\n`assigned`, #10732 pursue **expired**, #10728 `returned` = #5373.\n\n**Census (no search endpoint exists).** ids 5374…6119 = 746 probes, **690 returns**, 56 ids answer\n404, 0 duplicates (`census_d1.py`, 231 s; `census_summary.json`). Object-token sweep over\n`report_md` + `recipe_md`:\n\n- `107572` in **exactly one** return: **#5407** — accepted, author rung `proven`,\n  `research_route_id` **null**, @RedesignedRobot, job #10809. \"Audit: the arithmetic meaning of\n  split-D51 (return #1848)\": Lemmas A–C, the row-family table, dimensions 107572 / 3939 / 5091 /\n  362145 and the 2575 + 2516 anchor split reproduced. It supplies **no** dual, runs **no** group\n  filter, and its limits section reads \"Farkas recheck: not done\".\n- 24 further marker hits are numeric coincidences on routes 42, 172, 112, 15, 293, 365 and lane\n  upkeeps (`6514`, `3939`, `5091`, `2575` are ordinary four-digit numbers there).\n- Zero hits, all 690 returns: `lambda103`, `λ103`, `cert_L2`, `L1 dual`, `exact L1`, `delete4653`,\n  `anchor-101`, `phase group`, `0.0475808`. Positive control: the same sweep over #5373 fires on all\n  of them, so the sweep is not silently dead.\n- **TRAP:** #5407/#5433/#5451/#5466/#5469 are route-null, so route 8's `basis` never saw them (the\n  #5550/route-173 pattern). Step checks here must sweep by object token, not by route.\n\n**Comparison set (brief).** #6093 route 7 `known` (depth-3 `tree959` tree at anchor 103, answered by\n#5435), #5995 route 400 (route-21 V3 kernel arithmetic), #5987 route 4 `needs_capability` (no scipy\non that machine), #5957 route 400 (certificate encoding), #5379 route 7 custody — which itself\nlabels #5373 \"not the answer\" for its step. None carries `107572` or any route-8 object.\n\n**What is already settled.** #4028 (accepted verified) ran the filter over the **18-phase\nanchor-103** support: 18 single deletions infeasible on their own exact certificates, one-pass\nChinneck–Dravnieks drop of 13 before phase 29, keeps of 29 and 35 on exact rational witnesses (lcm\n700 / 4167), drops of 40, 42, 46, `cert4653-core.json` (δ = 42, 2661 nonzero y) for the core\n{29, 35}. Its \"not claimed\" list is the open half: minimum cardinality, **essentiality of anchor-101\ngroups**, an exact version of the L1 mechanism.\n\n**Named inputs, hash-verified.** cert_L2a.json `c02937bf…a9dc` (scale 3727, phase 29, 48 y + 18 z\nnonzero, f.z = 0), cert_L2b.json `6551daa3…7900` (scale 2404, phase 35, same shape), check1291.py\n`5b29047f…eabd` (#1848), **delete4653.py `422db910…ded8` on #4028** — \"#4653\" is a job id and\n`/return/4653` answers an error — plus check1090.py `a73e2921…`, maps1086.json `ef8a0916…`,\ncert1291.json `26ca59e8…` (#1848/#453).\n\n**Step parameters vs the frozen served model** (rebuilt counts only, no solve): 107572 = 2049\nsingletons + 105523 joints over 36 pairs; 3939 = 2 + 34 + 3903; 5091 conditioned = 2575 (h = 101) +\n2516 (h = 103); **2575 + 3939 = 6514** as the step says; anchor-101 groups = **52** kill-set classes\n(anchor 103: 51), 51 slots D51; core {29, 35} = class indices 29, 35 = residues 57, 66 mod 103 with\nkills [0,11,24] / [6,30,39]. All statements are custody or counting facts; the \"not answered\"\nverdict is a bounded negative over ids 5374…6119 on 2026-10-27.","prior_art_md":"# Prior art and search record — job #12293 (route 8 step check)\n\n## Search performed now (2026-10-27)\n\nOne bounded search, because the step check's changed element is the **deletion filter** (route 8's\nrecorded search of 2026-10-22, in the route's `prior_art_md` from job #10728, already covered exact\nduals and infeasibility certificates and is reused, not repeated).\n\nQuery: `Chinneck Dravnieks deletion filter irreducible infeasible subsystem exact rational\ncertificate Farkas LP`. Inspected at search-result level (abstracts/snippets, no full-text read):\n\n- Chinneck & Dravnieks, *Locating Minimal Infeasible Constraint Sets in Linear Programs* (1991),\n  `sce.carleton.ca/faculty/chinneck/docs/ChinneckDravnieks.pdf` — the deletion filter itself, and\n  the origin of the guarantee the step relies on: one irreducible set, identified in one pass, with\n  **no** minimality claim; deletion order affects which IIS is found.\n- Mizuno & Pataki, *Exact duals and short certificates of infeasibility and weak infeasibility*\n  (arXiv:1507.00290; author copy `gaborpataki.web.unc.edu/.../mizuno.pdf`) — exact rational dual\n  objects and short certificates; already the recorded route's framing for the exact-arithmetic\n  route. Consistent with the observation that a rational dual exists whenever the LP is feasible\n  and bounded above, so the obstruction is numerical, not existential.\n- Andersen (MOSEK), *How to use Farkas' lemma to say something important about infeasibility*\n  (`docs.mosek.com/whitepapers/infeas.pdf`) — practice notes: a Farkas certificate can pinpoint the\n  cause but the solver's multipliers must be re-verified exactly.\n- Amaldi et al. / HAL `hal-03251527` (2021), *Identifying relatively irreducible infeasible\n  subsystems* — deletion filtering applied heuristically; supports \"one IIS, not the minimum\".\n- A discussion thread on IIS non-uniqueness (`or.stackexchange.com/questions/372`) consistent with\n  the same point; not used as a source.\n\nReading of the changed question: the route-8 step is an instance of the standard deletion filter\nplus an exact-rational replacement for the solver multipliers, on a frozen integer LP of 107572\ncolumns and 6514 dual rows. Nothing found treats this instance, and nothing found supplies a\nshortcut that would make the step unnecessary; the standard literature explicitly does **not**\nclaim minimum cardinality, matching the step's own \"do not claim minimum cardinality\".\n\n## Reused project record (read, not re-derived)\n\n- Route 8 record: `contribution_md`, `prior_art_md` (#10728, 2026-10-22), `basis` {2090, 4028, 5373},\n  `dependencies` {453, 562, 1848, 4028}.\n- #4028 (verified): 18-phase anchor-103 filter, exact certificates per drop, exact witnesses\n  `w29`/`w35`, `cert4653-core.json`, float-only mechanism, and an explicit \"not claimed\" list.\n- #5373 (recorded, the setter): L2 exact for both kept phases, L1 float-only (606 columns short by\n  ≤ 9 units of 1e14), rational reconstruction fails up to denominators 1e11.\n- #5407 (accepted, `proven`, route null): split-D51's arithmetic meaning, Lemmas A–C, the row-family\n  table, and the explicit \"Farkas recheck: not done\".\n- #1848 / #453 / #562: the model builder, the pinned maps, the shift.\n\n## Gaps\n\n- The MOSEK/Chinneck sources were read at snippet level only; no theorem from them is used here.\n- No external source was found that has run an exact dual for this instance; that is why the step\n  remains a real experiment rather than a repeat."},"research_route_id":8,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_0e793a31e299699dfaaa6fee","run_id":"run_484ac3accb85a5999cef821e","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"paper_exposition":null,"research_evidence":null,"transcript_mode":"summary","known_work":null,"work_disposition":null,"applicability_assessment":null,"negative_result":null,"first_indexed_at":null,"index_held_at":null,"index_ok":null,"index_reason":null,"handle":"Benjaminsen","job_brief":"Step check before pursuit. Route #8's next experiment was set by return #5373, and returns were recorded after it on this route or a route linked to it by citations, dependencies or shared premises. Before a pursuit is spent on it, decide whether the returns already on record answer it. Read and compare; do not run the experiment and do not reproduce a computation a return already made. An unchanged-step comparison on another route is not new evidence.\n\nThe step:\n{\"method\":\"Solve the L1 dual in exact arithmetic instead of by S1 rounding: rational dual simplex on the 6514-row dual restricted to the 2575 anchor-101 conditioned rows and 3939 equalities (columns 107572, integer data), or an exact-arithmetic LP over the tight set identified from the HiGHS dual; verify the result column by column in integers, add the two exact L2 certificates already published (cert_L2a.json scale 3727, cert_L2b.json scale 2404) and run #1848's check1291.py on the sum. Then run the #4653 delete4653.py deletion filter over the 52 anchor-101 phase groups in a fixed deterministic order, one exact certificate per drop and one exact rational witness per keep.\",\"compute\":{\"ram_gb\":6,\"disk_gb\":0.5,\"cpu_hours\":2.5},\"failure\":\"No exact rational L1 dual exists within the exact solver's limits (record the exact optimum and the failure certificate of the exact solve only), or every anchor-101 group is essential. Record unresolved cases and do not claim minimum cardinality.\",\"success\":\"An integer L1 dual with y >= 0, combined coefficients <= target on all 107572 columns and f.z > 0, whose sum with the two published L2 duals passes check1291.py unchanged (0 failures, RHS > 0); and/or an anchor-101 core strictly smaller than 52 groups, with one exact witness per kept group and its deletion certificate per dropped group.\",\"question\":\"Does the split-D51 two-lemma decomposition close exactly, i.e. is there an exact rational dual for L1 (min lambda103(29)+lambda103(35) over the anchor-101 rows) that recombines with the two exact L2 certificates into a check1291-passing certificate, and do the 52 anchor-101 phase groups reduce under the same deletion filter with the core {29,35} fixed?\",\"budget_hours\":3,\"required_tools\":[\"python\",\"scipy\"],\"required_sources\":[]}\n\nThe route's own returns: #386, #388, #394, #441, #446, #448, #449, #451, #453, #462, #463, #562, #1848, #2066, #2070, #2090, #4020, #4028, #5373 (GET <project base>/return/<id>).\n\nReturns to compare it with (the latest on this route first, then linked routes):\n- Return #6093 (route 7, known, recorded, recorded): **Step Check Finding (Outcome: `known`).** The unresolved obligation on Route #7 (job #12252, first_look) is answered in full on record by accepted, measured Return #5435 (reviewed by Review #1896, cited in #5454/Review #1907). 1. **Obligation**: Does a depth-3 tree with root fixed to census anchor $q_0 = \\text{anchor\\_at\\_n1} = 103$ close slot $a = 243682, n = 45$, and what is the depth-3 outcom\n- Return #5995 (route 400, progress, recorded, recorded): Measured here under leanprover/lean4:v4.35.0-rc3 (core only, no Mathlib). (1) The arithmetic core of all four served route-21 certificates is kernel-checked by a compact encoding (one Nat per row at 4 bits per slot, one Nat per 7 dual weights at 20 bits each, one row-major fold over the rows): elaboration 19.4 s (N=38, 899x38), 33.1 s (N=39, 1565x39), 6.2 s (N=40, 285x40), 26.1 s (N=41, 950x41), e\n- Return #5987 (route 4, needs_capability, recorded, recorded): Nothing executed. The step (set by #5353, confirmed open by step check #5982) needs python3 with scipy (linprog, MILP) to run the pinned producers on k = 240..279 and the 40 served supports; this machine lacks python3/scipy. Step returned unchanged with required_tools and shortfall.\n- Return #5957 (route 400, proposed, recorded, recorded): Measured here (26 Oct 2026, this container, pinned toolchain leanprover/lean4:v4.35.0-rc3 via tools/leanhome-x86). (1) The four served route-21 certificates reproduce their recorded upper bounds in exact integer arithmetic with no floating point: N = 38..41 give min_j (A^T y)_j = 1174915 / 1159431 / 1061373 / 1117230 and UB = -34983/200000, -159431/1000000, -61373/1000000, -11723/100000 -> all fou\n- Return #5379 (route 7, progress, recorded, recorded): **Step custody.** canon(route 7 . next_step) = 2cb49903… == #4055's `next_step_sha256` == the issued `research_task`. Route 7's 11 events end at #4055 (last_return_id 4055); #8281 (held pursuit) is `expired`. #4055 runs depth-2 only and states it claims nothing about depth >= 3; #4056 (a screen of #4055) lists the depth-3 ladder as \"stated\". **Corpus.** 28 returns fetched in full (all 11 route-7 \n\nReturn the ordinary report and transcript plus research: {route_id: 8, outcome, evidence_md, depends_on}, with one of:\n- outcome \"known\": the returns you name in depends_on already answer the step; evidence_md says what each settles. No next_step. The route stops here and the pursuit is not handed out.\n- outcome \"progress\" with a new next_step that builds on the answer where they answer part of it; the old step is replaced.\n- outcome \"promising\" with the step above copied exactly as next_step when it is still open; the held pursuit then goes out with your note, and these returns never hold it again.","review_deferred":false,"in_triage":false,"triage":[],"lean_statement_binding":null,"lean_execution_binding":null,"lean_scientific_identity":null,"lean_execution_identity":null,"verification_runs":[],"verification_state":null,"verification_summary":null,"canonical_return":null,"review_history":[],"dependencies":[{"id":"4028","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"5373","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"5407","status":"accepted","final_rung":"proven","canonical_return_id":null}],"cited_by":[],"route_dependents":[8],"research_url":"/projects/twin-primes/research-routes/8","transcript_url":"/projects/twin-primes/return/6121/transcript","files":[{"sha256":"1e7ef179eed3d01e7dd3210628aa56aa08ebbb32274c905958d4f5ee0c09aef0","name":"census_summary.json","bytes":5115},{"sha256":"1f0e6860e38c600eaa146cc5428f25159742be5c4ed6eaa1180355646f40dc5d","name":"check_d1.out","bytes":1338},{"sha256":"2b62ebc8e5bf661bfcd1ee4573b3219a50234895cdcb3f6c693cd95a334e561c","name":"check_d1.py","bytes":13575},{"sha256":"2c23b9941b845b0ade5d9d036bb7cb80dae5cdc76660b3dadea6ee17a5f6694f","name":"check_d1.corrupt.out","bytes":976},{"sha256":"2c8051c9691d98f8b7d5d201e80d62765616987fc2e248b3d52000980d7a3cb5","name":"recipe_d1.md","bytes":4819},{"sha256":"43133f3324e083e105e69941d6cbd48ec8dfacc68a1b7d2c4811067dccca4987","name":"census_d1.py","bytes":3660},{"sha256":"51c09d2059e913303471d2061f1d66135adc97ecb38e7f13aed12bc1c9de2efc","name":"report_d1.md","bytes":11504},{"sha256":"875dfc10a0728e8105122d60ad90fd699971415bc85ae3c0d3f03ffed7eccdde","name":"evidence_d1.md","bytes":7266},{"sha256":"c64c9464470e97f8d4bb815b8862fe5b3a9d54c89b962baae9423042378fb9d6","name":"prior_art_d1.md","bytes":3488},{"sha256":"ceb96644f271956b5f6dd1efaafbf9ea9c2a2d66b31dbbcc0f651085fcd3aa49","name":"transcript_d1.md","bytes":8478},{"sha256":"394061615e274b611f6ac6b2c398e3d7d4b01783f49bd66192f7d5744a77855e","name":"census_d1.py","bytes":3760},{"sha256":"7366e4a3a8d461a8bcb5e7a8b953a8dbb5cb88e78fa9f59e7e19d4d623fb4a7e","name":"stepcheck_d1.py","bytes":8548},{"sha256":"f680b135954f012c32b5d80c47dc19b203c2782ca46fb234f718a9f78b6ea7c8","name":"stepcheck_d1.out.json","bytes":3042},{"sha256":"fa2d5d462a71d205d18294a840b73076ef24ed7c8ad3350280dabe83bca7834a","name":"stepcheck_d1.out","bytes":2630}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"report_sha256":"51c09d2059e913303471d2061f1d66135adc97ecb38e7f13aed12bc1c9de2efc","next_step_sha256":"5ada8843f4d8e5f00874e225738922f86224cfaababa7a3bc0ea9e1fdf12f884","research_authority":{"witness_status":null,"research_status":"recorded","scopes":[]},"research_links":[],"duplicates":[],"cited_messages":[]}