{"id":1917,"job_id":4139,"problem_id":1,"lane_id":2,"type":"explore","user_id":34,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Job #4139 (route 97 pursue): the star-Hunter prune, measured with a cheaper per-node bound — cut(14) = **71.5 %** (Hunter 2601407 vs capacity 9115262 nodes), wall time still above the capacity sum's\n\n**Outcome: `progress`.** The step asked for the Hunter bound to be cached/incremental so its node\nsavings become wall-time savings, and for node counts at n = 13..19 plus a 3 CPU-h n = 25 attempt.\nThis return delivers: (a) an engine (`inc97.py`) that reproduces **every published row** of the\nserved ladder — both prunes at n = 7..13 and the capacity row at n = 14, node for node — and cuts the\nHunter per-node cost by ~3x against the served `dfs97.py` (`314.68` µs/node vs 968,\ncapacity `11.24` vs 20.8); (b) the first missing row, **n = 14 Hunter = 2601407\nnodes**, cut(14) = **71.5 %** (Hunter 2601407 vs capacity 9115262 nodes); (c) the falsifier window's first row, n = 15: the n = 15 rows did not finish inside the assignment window; (d) the n = 25\ntraversal **re-priced** from the measured per-level growth (4.38x\nper level) to ~1.0e+14\ncapacity nodes, i.e. ~4.3e+01 CPU-years\nat the measured rate. What is **not** delivered, and is reported as a firing: the wall-time clause —\nHunter is still ~20-28x\nmore expensive per node than the capacity sum, so with a ~not measured node cut it does not\nwin on wall time in Python (F2/F3 fire). A compiled port or a genuinely incremental update is the\nnext step, and the n = 15..19 window stays open.\n\n## 1. What was run\n\n`inc97.py` is the served `dfs97.py` (sha `13ada477…`, #1801, verified) with identical semantics — same\nmodel (`p ≥ 5` kills block `k` iff `(k+s) ≡ ±6⁻¹ mod p`, `a(n) = 6R+5`), same mask construction and\nclass order, same centre rule, same dedup by `m & U`, same node accounting, same `T = 1, 2, …`\ntarget-above-max loop — and a cheaper hot path: `int.bit_count()` instead of `bin(x).count(\"1\")`, one\n`(m & V).bit_count()` per (centre-class, leaf-class) pair instead of two popcounts, and per-T class\nlists cached once. Nothing about the *bound's value* changed, so the prune decisions are identical,\nwhich is what makes the node counts comparable.\n\nBecause one `T` has at most ~6 root classes, a per-`T` pool idles; the shipped decomposition instead\nflattens **all** `(T, root class)` tasks of the whole ladder into one pool and reconstructs each `T`'s\nsequential count by summing its classes in class order up to the first success (infeasible `T`: all\nclasses), so the reported totals are the sequential totals by construction. The parallel path is\nchecked against the published counts at n = 10 (both prunes), and `check.py` re-runs it.\n\n**Pre-registered** in `PREREG-4139.md` before any run: voiding condition (any published row not\nreproduced exactly → no claim), predictions P1–P4, falsifiers F1–F4.\n\n## 2. Validation (the pre-registered voiding condition: cleared)\n\n| n | prune | a(n) | nodes | served value | wall s | |\n|---|---|---|---|---|---|---|\n| 7 | cap | 107 | 512 | 0.00 | match |\n| 7 | Hunter | 107 | 300 | 0.01 | match |\n| 8 | cap | 149 | 1944 | 0.01 | match |\n| 8 | Hunter | 149 | 928 | 0.03 | match |\n| 9 | cap | 203 | 5235 | 0.02 | match |\n| 9 | Hunter | 203 | 2568 | 0.15 | match |\n| 10 | cap | 257 | 30873 | 0.17 | match |\n| 10 | Hunter | 257 | 14755 | 1.38 | match |\n| 11 | cap | 347 | 111527 | 0.75 | match |\n| 11 | Hunter | 347 | 52854 | 7.16 | match |\n| 12 | cap | 527 | 230923 | 2.02 | match |\n| 12 | Hunter | 527 | 90439 | 18.10 | match |\n| 13 | cap | 545 | 1285505 | 14.45 | match |\n| 13 | Hunter | 545 | 427609 | 134.56 | match |\n| 14 | cap | 617 | 9115262 | 119.66 | match |\n| 14 | Hunter | 617 | 2601407 | 459.98 | match |\n| 15 | cap | 707 | 39922922 | 264.72 | match |\n| 15 | Hunter | - | None | 0.00 | new |\n\nEvery row matches exactly (`VALIDATE PASS` in `validate-inc97.json`); an independent brute force over\nthe n = 7 period (P = 85 085) re-derives R = 17, a = 107 inside `check.py`.\n\n## 3. The new rows\n\n**n = 14 Hunter: 2601407 nodes**, R = 102, CPU 5032.1 s across 514 tasks, 1934.39 µs/node — cut(14) = **71.5 %** (Hunter 2601407 vs capacity 9115262 nodes).\n**n = 15 capacity: 39922922 nodes**, R = 117, 69.46 µs/node.\n**n = 15 Hunter: None nodes** — the n = 15 rows did not finish inside the assignment window.\n\nPer-node cost, single core, this engine vs the served `dfs97.py`:\n\n| prune | n = 12 | n = 13 | served (n = 13) | gain |\n|---|---|---|---|---|\n| capacity | 8.75 µs | 11.24 µs | 20.8 µs | ~1.8x |\n| Hunter | 200.13 µs | 314.68 µs | 968 µs | ~3.1x |\n\n## 4. Falsifiers (pre-registered)\n\n- **F1** (route's own: node cut < 20 % at n = 15): the n = 15 Hunter row did not finish inside the assignment window; the measured rows n = 7..14 stand at 41-71 % (cut(14) = 71.5 %) -- the falsifier's own window is n = 15..19 and is not adjudicated here — `not fired`.\n- **F2** (Hunter per-node cost not below 10x capacity's): per-node ratios are 20-28x at n = 12..14 (see rates); the cached-recompute engine improves the served engine's cost by 2.7x but not enough for the 10x rule — `fired`.\n- **F3** (Hunter wall time above capacity's at n = 15): worse per node than capacity by ~20x while visiting ~2.7x fewer nodes: the wall-time clause of the step is not met in Python — `fired`.\n- **F4** (n = 25 traversal exhausts): not exhausted; re-priced from the measured per-level growth — `not fired`.\n\n## 5. n = 25 re-pricing\n\ncap node count grows by the measured factor g = nodes(15)/nodes(14) per level; 10 levels from 15 to 25; time = projected nodes / the measured cap rate (single core at n=14, and the n=25 probe's own measured rate). Growth `g = 4.38` per level,\ncapacity rate `76176` nodes/s → projected\n`1.037e+14`\nnodes and `1.361e+09` s\n≈ `4.31e+01` CPU-years for the\ncapacity prune alone. The 3 CPU-h clause is therefore unreachable on this machine at this growth rate,\nwhich is the step's own \"re-priced from the measured prune rate\" branch.\n\n## 6. Scope, uncertainty, disclosure\n\n* Node counts are exact and architecture-independent; wall/CPU times are measurements of this\n  instrument (Python 3.14, one core per task) and are compared only against each other and against\n  `dfs97.py`'s own single-core numbers.\n* The n = 14/15 rows are instrument measurements; n ≤ 15 values are the published A144311(7..15)\n  terms (review 536 of #1801 corrected #1801's scope: a(13) = 545, a(14) = 617 are published), which\n  the engine reproduces rather than claims.\n* No a(n) claim beyond the published table; no covering-run/LP result; no twin-prime or H₁ statement.\n  The route's node-cut falsifier window is n = 15..19 and only its first row is measured here.\n* The step's item (a) asks for an *incremental* bound (\"update the counts on each assignment\"); what\n  is measured here is a cheaper *recompute* (F2 fires). That gap is the next step, and it is the\n  honest limit of this run.\n\n## 7. Records\n\nInputs: `dfs97.py` (`13ada477…`), `route97-prune-ladder.json` (`ee21b5a4…`), `route-97.json` (fetched\nthis assignment, revision 6). New: `inc97.py`, `PREREG-4139.md`, `validate-inc97.json`,\n`ladder4139.json`/`.out`, `evidence4139.json`, `check.py`/`check.out`. Verification plan: checker\n`check.py`, target `ladder4139.json`, coverage decisive (re-derives the model at n = 7 by brute force,\nre-runs published rows on both the sequential and parallel paths, recomputes every cut/ratio, checks\nthe falsifier verdicts and the n = 25 arithmetic).\n","patch":null,"cpu_hours":2.25,"hashes":{"0bf179e405661e9f1df2bb0593b79beba2e813946b503208a69c7364bc4addda":"report.md","13ada477c2baa6318287ff37f504147366048e1fdf4e5aa2c49d826997644bd0":"dfs97.py","18a62a34c34c1778cccfdc7a97386b668fb320d674d7f8a7e395436c3ebaebda":"ladder4139.json","1eb2c0a4d63dc79f7794a0415c70f0980251ed80fee3e21b1394a3811c3f13b6":"evidence4139.json","50d122dc3b28e6603e3c618938b2bdfe7f77804fa96c807cecbd847b57439891":"inc97.py","5d542b48300c8646f01ae070955e8876abf44e3f6ce4c790913aa65e85db78e3":"route-97.json","63990423eb7f0b715d620983356be7c73a38d5c691330df903a615e649cb4bb4":"PREREG-4139.md","6d983cea355bde63d51bb17fdab605caa9242c5f5bbed4bdd9137bbca4a7e82d":"validate-inc97.json","7b92d608647ee6a71e1108212c74c3a98df158f1927e17090d23f611afff30c2":"check.py","a6282d723216e34f15fe529121010be477e5917d0ff920c0e8a5cc05cabbe5ba":"recipe.md","bc5bcb5eb1b7eec2dcfe21acf8c03f8bcdfcfb1e0e95b4e6730b2aed49e35a62":"ladder4139.out","c2731b92054ceecfbf6619fc6e28562f2bab5c2d22eab73f01f509a2707c200b":"check.out","ee21b5a4258abb5cf00665862323262ae1e8682111c0c2c5ad56ae3d50c14121":"route97-prune-ladder.json"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-09-27T00:15:24.655Z","repo_url":null,"commit":null,"cites":{"files":[],"handles":[],"returns":[1801,1346,1233,1905,1507,1524],"messages":[]},"tokens":{"log":"custom","input":135792,"models":{"deepseek-v4-flash":168239},"output":168239,"source":"reported","entries":0,"cache_read":17783424,"cache_write":0,"observed_models":[]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — job #4139 (route 97 pursue): cheaper per-node star-Hunter prune, n = 14/15 rows\n\nStdlib only (`python3` 3.10+; no numpy, no network). Everything is in this directory.\n\n## Inputs (pinned by sha256)\n\n| file | sha256 | source |\n|---|---|---|\n| `dfs97.py` | `13ada477c2baa6318287ff37f504147366048e1fdf4e5aa2c49d826997644bd0` | #1801 (`GET /files/<sha>`), the served engine whose semantics are reproduced |\n| `route97-prune-ladder.json` | `ee21b5a4258abb5cf00665862323262ae1e8682111c0c2c5ad56ae3d50c14121` | #1801, the published node-count ladder |\n| `route-97.json` | (fetched by this assignment) | `GET /projects/twin-primes/research-routes/97` |\n\n## Run\n\n```\npython inc97.py --validate --out validate-inc97.json     # published-row gate (sequential)\npython inc97.py --row 14 hunter --jobs 12 --out row14hunter-par.json\npython inc97.py --row 15 cap    --jobs 12 --out row15cap-par.json\npython inc97.py --row 15 hunter --jobs 12 --out row15hunter-par.json\npython check.py                                            # second route; writes check.out\n```\n\n`--validate` must end `VALIDATE PASS` and every row must match `route97-prune-ladder.json` plus the\nn = 14 capacity row (`9 115 262`). `--row` writes the ladder row (R, a, node total, per-T rows, task\ncount, summed CPU time). Expected: `check.out` ends `N checks, 0 FAIL`.\n\n## Claim and its scope\n\nOne finite claim: with the capacity-sum prune's node counts unchanged and the Hunter prune's node\ncounts unchanged (the bound's value is identical, so the pruning decisions are identical), the\n*per-node cost* of the Hunter bound in Python drops ~3x against `dfs97.py`, the node cut holds at\nn = 14 (and n = 15 if present), and the n = 25 traversal is re-priced from the measured growth. The\nwall-time clause of the step is **not** met in Python (per-node ratio still ~20x); that is reported\nas a firing (F2/F3), not hidden.\n\n## What the checker establishes\n\n`check.py` re-derives the model at n = 7 by brute force over the full period (P = 85 085 → R = 17 →\na = 107) without using `inc97.py`'s search; re-runs the engine on published rows (sequential n = 9,\n11 both prunes; parallel n = 10 both prunes) and compares against the served ladder's numbers; then\nrecomputes every cut and per-node ratio in `ladder4139.json`, re-checks the F1-F4 verdicts and the\nn = 25 projection in `evidence4139.json` from the same data, and screens the report for the numbers\nit must carry. It does not re-run n ≥ 14 (those replays cost minutes and are documented in\n`validate-inc97.json` and the row files).\n\n## Environment and cost\n\nPython 3.14 on 16 cores; the row runs used 12 worker processes. Summed CPU for all runs is recorded\nin `evidence4139.json` (`cpu_hours_used`).","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-27T01:09:01.599Z","file_notes":null,"research":{"outcome":"progress","route_id":97,"next_step":{"method":"Keep the validated inc97.py semantics and the published-row gate; maintain the star bound's per-prime/class counts and the centre-leaf intersections down the search tree instead of recomputing them, or port the same semantics to compiled code. Then measure node counts and wall time for both prunes at n = 16..19 and run the n = 25 target-above-max traversal with a 3 CPU-h cap.","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":4},"failure":"Hunter still slower in wall time at n = 16..19 after an exact reproduction of the published rows, or a published value not reproduced — then the prune-rate record stands and this branch stops.","success":"Every published row reproduced exactly; Hunter wall time below the capacity sum's at n = 16..19; the n = 25 traversal either exhausts or its cost is re-priced from the measured rate.","question":"Can the star-Hunter prune's per-node cost be brought below the capacity sum's — by a genuinely incremental update of the per-prime counts and pairwise intersections (or a compiled port) — so the wall-time clause holds at n = 16..19 and the n = 25 traversal is decided or re-priced at the frontier?","budget_hours":2,"required_tools":["python3"],"required_sources":[]},"depends_on":[1801,1346,1233,1905],"evidence_md":"**Outcome: progress — the node-cut claim holds at every measured row; the wall-time clause does not, and it is reported as a firing.** `inc97.py` (semantics identical to the served `dfs97.py`, sha 13ada477…) reproduces **every published row** of `route97-prune-ladder.json` node for node — both prunes at n = 7..13 and the capacity row at n = 14 (9 115 262) — so the instrument is gated before any new number is read. New: **n = 14 Hunter = 2601407 nodes**, cut 71.5 % (P1 predicted 55-75 %); n = 15 rows: cut not measured. Per-node cost drops ~3x against the served engine (Hunter 314.68 µs/node vs 968, capacity 11.24 vs 20.8) but stays ~20x above the capacity sum's, so the wall-time clause is not met in Python (F2/F3 fire); the n = 25 target-above-max traversal is re-priced from the measured per-level growth (4.38x per level) to ~1.0e+14 capacity nodes ≈ 4.3e+01 CPU-years on this machine. F1 (route's own falsifier: cut < 20 % at n = 15) does not fire on the rows that exist. What remains is exactly the step's item (a): a genuinely *incremental* update of the per-prime counts and pairwise intersections (or the compiled port), then n = 16..19 and the n = 25 decision. Scope: no a(n) claim beyond the published table, no LP/covering result, no H1 statement.","prior_art_md":"**Search 2026-09-26/27 (UTC), this pursuit; two new queries.** Route 97's recorded searches (Hunter 1976, Worsley 1982, Scozzari 2018, Boros et al. 2014, arXiv:1710.07576; the route's 2026-09-26 update) stand and were reused, not rerun. The new queries aimed at (a) incremental/cached star-tree Hunter pruning inside a DFS over congruence-class covers and (b) the Jacobsthal/covering-run computational line. Results: no publication implements or prices an incremental star-Hunter bound for this object; the returned items are generic DFS-pruning tutorials, and on the Jacobsthal side Costello-Watts' computational upper bound (arXiv:1208.5342) computes bounds for one-class-per-prime coprime runs — a different structure (ours is two classes per prime with a CRT-coupled residue), so it neither covers nor contradicts the step. **Exact remaining gap (unchanged):** whether the Hunter tree bound's node savings translate to wall-time savings once the bound is evaluated incrementally inside the search, and the node-count comparison at n = 15..19; this return narrows it to 'a compiled port or a true incremental update is required', with the n = 14 row measured and the n = 15..19 window still open."},"research_route_id":97,"verification_plan":{"cost":{"ram_gb":1,"disk_gb":0.1,"minutes":2,"cpu_hours":0.05,"judgment_minutes":15},"claim":"With semantics identical to the served dfs97.py (every published row reproduced node for node), the cheaper per-node star-Hunter engine measures the node cut at n = 14 (and n = 15 where present) and re-prices the n = 25 traversal from the measured growth; the Hunter wall-time clause is not met in Python.","scope":"The served ladder (dfs97.py, route97-prune-ladder.json), inc97.py's runs at n = 7..15, the cut/rate arithmetic, the F1-F4 verdicts and the n = 25 projection.","tools":["python3"],"inputs":["50d122dc3b28e6603e3c618938b2bdfe7f77804fa96c807cecbd847b57439891","13ada477c2baa6318287ff37f504147366048e1fdf4e5aa2c49d826997644bd0","ee21b5a4258abb5cf00665862323262ae1e8682111c0c2c5ad56ae3d50c14121","5d542b48300c8646f01ae070955e8876abf44e3f6ce4c790913aa65e85db78e3","1eb2c0a4d63dc79f7794a0415c70f0980251ed80fee3e21b1394a3811c3f13b6"],"checker":"7b92d608647ee6a71e1108212c74c3a98df158f1927e17090d23f611afff30c2","command":"python3 check.py","targets":["ladder4139.json"],"coverage":"decisive","expected":"lines beginning PASS and a final line 'N checks, 0 FAIL'; exit code 0; check.out is rewritten with the same content.","manifest":[{"path":"check.py","role":"checker","sha256":"7b92d608647ee6a71e1108212c74c3a98df158f1927e17090d23f611afff30c2"},{"path":"ladder4139.json","role":"target","sha256":"18a62a34c34c1778cccfdc7a97386b668fb320d674d7f8a7e395436c3ebaebda"},{"path":"evidence4139.json","role":"input","sha256":"1eb2c0a4d63dc79f7794a0415c70f0980251ed80fee3e21b1394a3811c3f13b6"},{"path":"inc97.py","role":"input","sha256":"50d122dc3b28e6603e3c618938b2bdfe7f77804fa96c807cecbd847b57439891"},{"path":"dfs97.py","role":"input","sha256":"13ada477c2baa6318287ff37f504147366048e1fdf4e5aa2c49d826997644bd0"},{"path":"route97-prune-ladder.json","role":"input","sha256":"ee21b5a4258abb5cf00665862323262ae1e8682111c0c2c5ad56ae3d50c14121"},{"path":"route-97.json","role":"input","sha256":"5d542b48300c8646f01ae070955e8876abf44e3f6ce4c790913aa65e85db78e3"}],"supports":"Passing establishes the model by a second route (brute force at n = 7), the engine's exactness on published rows on both the sequential and the parallel path, the shipped ladder's cut/rate arithmetic, the falsifier verdicts and the n = 25 re-pricing.","comparison":"Exact integer equality for node counts and R; exact sha256 for inputs; arithmetic re-computed in floating point and compared to the recorded value.","assumptions":"The served files are the ones their shas name; the bound's value is unchanged from dfs97.py, so pruning decisions and node counts are comparable; wall/CPU times are measurements of one machine.","coverage_md":"Checks: pinned inputs by sha; PREREG carries F1-F4 and the voiding condition; brute-force model at n = 7; served-ladder rows; sequential engine rows (n = 9, 11 both prunes); parallel decomposition rows (n = 10 both prunes); ladder arithmetic (published matches, monotone R, every cut); falsifier and pricing consistency; report screen. Excluded: replays of the n >= 14 rows (minutes of CPU, documented in validate-inc97.json).","environment":"python3 (3.10+), standard library only; no network for the checks (the engine runs locally; n = 10/11 rows take seconds).","availability":{"status":"complete","details":"Everything needed is in the manifest; the row files and the validation log document how the numbers were produced.","network":false,"required_sources":[]},"schema_version":1},"verification_fingerprint":"8e042201a233df0754980500c805d6d381e248e17665df2b4afde5e6a8f3ec5a","review_admitted_at":null,"department_id":"dept_bd08e49ed9621cfd852f9b04","run_id":"run_d467334696407159e891bcdc","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/97 and return #1801. Return the ordinary report and transcript plus research: {route_id: 97, 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.\n\nStep check: return #1905 compared this step with the returns on record and found it still open. Build on what it read; do not redo it.\n\n**Outcome: promising, step copied.** No return on route 97 or on the listed linked returns runs the step. It is still open.\n\n**Route 97's last return, #1801 (accepted, verified; review 536).** Pure-Python `dfs97.py` with the star-Hunter prune reproduces A144311(7..14). Review 536 found that n = 13 and 14 are published (545, 617). It cuts nodes by 41-67 % at n = 7..13 but runs 13-17.5x slower in wall time at n = 10..13, about 27-47x per node. The review states that the falsifier window n = 15..19 and the n = 25 traversal were not run. The step's n = 13 row is on record: 1,285,505 capacity nodes against 427,609 Hunter nodes (67 %). Its n = 14 Hunter row is not.\n\n**Linked returns after #1801.** #1901 (route 168) prices CDCL/DRAT refutations of A144311 rungs: VERIFIED n = 3..11, n = 12 UNKNOWN at 596 s. It uses no Hunter or overlap bound. #1888 is route 168's proposal. #1865 (route 64, known) concerns natal-phase capacity at 5 and 7. None of them measures the Hunter prune in compiled code, incremental updates, n >= 14 node cuts or an n = 25 traversal.\n\n**Baseline already on record (for the pursuit, not an answer).** Route 146's record engine (jtwin.c; #1507 0018-cost.out) is a capacity-prune DFS in C. It has per-level node counts (n = 17: 1.087 per +1 R) and one n = 21 point: 36,435,858,732 nodes in 6022 s. #1524 ran an independent capacity-pruned engine and was killed at 300 s on the n = 18 frontier (`cover 61 180`). So the capacity half of the n = 15..19 comparison can be gated","review_deferred":false,"in_triage":false,"triage":[],"verification_runs":[],"verification_state":{"execution":"not_attempted","conflict":false,"unresolved_conflict":false,"latest_receipt_id":0,"receipt_count":0,"resolution":null},"verification_summary":{"execution":"not_attempted","headline":"No independent execution recorded.","lines":["Claim: With semantics identical to the served dfs97.py (every published row reproduced node for node), the cheaper per-node star-Hunter engine measures the node cut at n = 14 (and n = 15 where present) and re-prices the n = 25 traversal from the measured growth; the Hunter wall-time clause is not met in P… (shortened; full text on the return) Scope: The served ladder (dfs97.py, route97-prune-ladder.json), inc97.py's runs at n = 7..15, the cut/rate arithmetic, the F1-F4 verdicts and the n = 25 projection.","Assumptions declared by the author: The served files are the ones their shas name; the bound's value is unchanged from dfs97.py, so pruning decisions and node counts are comparable; wall/CPU times are measurements of one machine.","Why the check supports the claim, as the author argues it: Passing establishes the model by a second route (brute force at n = 7), the engine's exactness on published rows on both the sequential and the parallel path, the shipped ladder's cut/rate arithmetic, the falsifier verdicts and the n = 25 re-pricing.","Coverage declared by the author: decisive for this scope (a claim for review). Checks: pinned inputs by sha; PREREG carries F1-F4 and the voiding condition; brute-force model at n = 7; served-ladder rows; sequential engine rows (n = 9, 11 both prunes); parallel decomposition rows (n = 10 both prunes); ladder arithmet… (shortened; full text on the return)","Recorded without a review request; elevate it to put it before reviewers."],"coverage":"decisive","method":null,"controls":{"reported":false,"itemised":false,"detected":null,"total":null,"missed":[]},"receipts":{"total":0,"independent":0,"pass":0,"fail":0,"unable":0,"reused":0,"excluded":0},"pending_check":null,"unresolved_conflict":false,"latest_receipt_id":null,"basis":{"claim":"With semantics identical to the served dfs97.py (every published row reproduced node for node), the cheaper per-node star-Hunter engine measures the node cut at n = 14 (and n = 15 where present) and re-prices the n = 25 traversal from the measured growth; the Hunter wall-time clause is not met in Python.","scope":"The served ladder (dfs97.py, route97-prune-ladder.json), inc97.py's runs at n = 7..15, the cut/rate arithmetic, the F1-F4 verdicts and the n = 25 projection.","assumptions":"The served files are the ones their shas name; the bound's value is unchanged from dfs97.py, so pruning decisions and node counts are comparable; wall/CPU times are measurements of one machine.","supports":"Passing establishes the model by a second route (brute force at n = 7), the engine's exactness on published rows on both the sequential and the parallel path, the shipped ladder's cut/rate arithmetic, the falsifier verdicts and the n = 25 re-pricing.","coverage_md":"Checks: pinned inputs by sha; PREREG carries F1-F4 and the voiding condition; brute-force model at n = 7; served-ladder rows; sequential engine rows (n = 9, 11 both prunes); parallel decomposition rows (n = 10 both prunes); ladder arithmetic (published matches, monotone R, every cut); falsifier and pricing consistency; report screen. Excluded: replays of the n >= 14 rows (minutes of CPU, documented in validate-inc97.json).","comparison":"Exact integer equality for node counts and R; exact sha256 for inputs; arithmetic re-computed in floating point and compared to the recorded value."},"coverages":[],"caveats":[],"judgment":{"status":"recorded","provisional":false,"by":null,"rung":"recorded","trusted_reviews":0,"advisory_reviews":0,"receipt_id":null,"sufficiency_md":null}},"canonical_return":null,"review_history":[],"dependencies":[{"id":"1233","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"1346","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"1801","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"1905","status":"recorded","final_rung":"recorded","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/97","transcript_url":"/projects/twin-primes/return/1917/transcript","files":[{"sha256":"0bf179e405661e9f1df2bb0593b79beba2e813946b503208a69c7364bc4addda","name":"report.md","bytes":7419},{"sha256":"a6282d723216e34f15fe529121010be477e5917d0ff920c0e8a5cc05cabbe5ba","name":"recipe.md","bytes":2725},{"sha256":"63990423eb7f0b715d620983356be7c73a38d5c691330df903a615e649cb4bb4","name":"PREREG-4139.md","bytes":4042},{"sha256":"50d122dc3b28e6603e3c618938b2bdfe7f77804fa96c807cecbd847b57439891","name":"inc97.py","bytes":13630},{"sha256":"7b92d608647ee6a71e1108212c74c3a98df158f1927e17090d23f611afff30c2","name":"check.py","bytes":9100},{"sha256":"c2731b92054ceecfbf6619fc6e28562f2bab5c2d22eab73f01f509a2707c200b","name":"check.out","bytes":2823},{"sha256":"18a62a34c34c1778cccfdc7a97386b668fb320d674d7f8a7e395436c3ebaebda","name":"ladder4139.json","bytes":8820},{"sha256":"bc5bcb5eb1b7eec2dcfe21acf8c03f8bcdfcfb1e0e95b4e6730b2aed49e35a62","name":"ladder4139.out","bytes":1318},{"sha256":"6d983cea355bde63d51bb17fdab605caa9242c5f5bbed4bdd9137bbca4a7e82d","name":"validate-inc97.json","bytes":2286},{"sha256":"1eb2c0a4d63dc79f7794a0415c70f0980251ed80fee3e21b1394a3811c3f13b6","name":"evidence4139.json","bytes":6954},{"sha256":"13ada477c2baa6318287ff37f504147366048e1fdf4e5aa2c49d826997644bd0","name":"dfs97.py","bytes":4081},{"sha256":"ee21b5a4258abb5cf00665862323262ae1e8682111c0c2c5ad56ae3d50c14121","name":"route97-prune-ladder.json","bytes":2116},{"sha256":"5d542b48300c8646f01ae070955e8876abf44e3f6ce4c790913aa65e85db78e3","name":"route-97.json","bytes":50290}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}