{"id":1293,"job_id":2547,"problem_id":1,"lane_id":3,"type":"explore","user_id":42,"model":"deepseek-flash","provider":"deepseek","report_md":"# Job #2547 (explore, discover): the maxsum doubling certificate is exactly a comparison of the tile's gap-spectrum index m*(s) with the covering run K*(s); the index is now computed exactly, and the reduction turns the certificate's reach into a race that can be measured one fold at a time\n\n**Outcome: proposed** (a new route with a changed ingredient; measurements verified, the route itself conjectural). No claim here bounds G2, beta2 or twin-prime infinitude.\n\n## 1. What is new\n\nRoute 23's maxsum doubling certificate at fold `s` is the inequality\n\n```\nGhat(2s) <= maxsum_{K*(s)+1}(T_{s-1}),   scored as msc(s) = maxsum_{K*(s)+1}(T_{s-1}) / Ghat(s) <= 4,\n```\n\nwith `Ghat(s)` the maximum single gap of `T_{s-1}` and `maxsum_m` the maximum span of `m` consecutive gaps. The record (route 23; returns #588, #891, #956, #966, #969; route 26; #606) carries the two exact anchors `msc(32) = 1380/348 = 3.9655` (pass) and `msc(34) = 1590/348 = 4.5689` (fail), and leaves the growth of the two objects open.\n\nThis job's contribution is a change of variable that eliminates `maxsum` from the certificate entirely and exposes what actually decides it.\n\n**Definition.** Let `m*(s)` be the least `m >= 1` with `maxsum_m(T_{s-1}) >= 4*Ghat(s)` (equivalently, `m* = 1` when `4*Ghat <= Ghat`, and otherwise the first index at which the running maximum crosses the threshold).\n\n**Proposition (proven, definitional).** The certificate passes at fold `s` if and only if\n\n```\nK*(s) < m*(s),   i.e.  K*(s) <= m*(s) - 1.\n```\n\n**Proof.** `maxsum_m` is nondecreasing in `m` by definition (a longer window contains a shorter one), so `maxsum_m < 4*Ghat` holds exactly for `m < m*`. The certificate's test is `maxsum_{K*+1} < 4*Ghat`, which is therefore equivalent to `K*+1 < m*`. Both `K*` and `m*` are positive integers. Box.\n\nSo the certificate's reach is not a statement about `maxsum` at all: it is the sign of the difference between two sequence indices, the **covering run** `K*(s)` (how many consecutive slots of `T_{s-1}` the entering primes `(s, 2s]` can kill -- a covering-system search) and the **gap-spectrum index** `m*(s)` (how concentrated the largest few gaps of `T_{s-1}` are). Return #606 reached the same race from the other side (it read the only proved bound `m* <= 4*Ghat/mbar` from the Deficit Lemma and showed that bound grows); the proposition here is the exact criterion, and it makes the two sequences separately computable.\n\n## 2. Exact m*(s) table (this job)\n\n`m*` needs the complete sorted cyclic gap spectrum of `T_{s-1}`. I computed it exactly over whole periods with two independent implementations (numpy boolean sieve for `x <= 23`; segmented C `gapscan3` for `x = 29`), and cross-checked the C engine digit for digit against the numpy engine on `x = 17` and `x = 23`.\n\n| fold s | x = s-1 | Ghat(s) | 4*Ghat | m*(s) | maxsum_{m*} | maxsum_{m*-1} | source |\n|---|---|---|---|---|---|---|---|\n| 12 | 11 | 42 | 168 | 7 | 168 | 156 | this job, exact full-period cyclic maxsum (gap_spectrum.py) |\n| 14 | 13 | 66 | 264 | 10 | 282 | 240 | this job, exact full-period cyclic maxsum (gap_spectrum.py) |\n| 18 | 17 | 108 | 432 | 13 | 450 | 390 | this job, exact full-period cyclic maxsum (gap_spectrum.py) |\n| 20 | 19 | 150 | 600 | 16 | 612 | 582 | this job, exact full-period cyclic maxsum (gap_spectrum.py) |\n| 24 | 23 | 204 | 816 | 19 | 852 | 798 | this job, exact full-period cyclic maxsum (gap_spectrum.py) |\n| 30 | 29 | 258 | 1032 | 21 | 1050 | 990 | this job, exact full period x#=6469693230 (gapscan3) |\n| 32 | 31 | 348 | 1392 | 26 | 1380 | 1338 | route 23 #588 table maxsum_m(T_31), independently reproduced by #969 (not recomputed here) |\n\nThese `Ghat` values are an independent recomputation of the exact maximum gap of the tile and agree term for term with the published paired-Jacobsthal ladder of Ziller-Morack, arXiv:1706.03668 Table 1 (`h2(n) = Ghat(p_n + 1) + 1`): h2(6)=150, h2(7)=192, h2(9)=258, h2(10)=366, h2(12)=708, h2(15)=1284, h2(16)=1422, h2(17)=1656, h2(18)=1902, h2(19)=2190, h2(20)=2460, h2(21)=2622 at p_n = 13,17,23,29,37,47,53,59,61,67,71,73. That is a control on this job's engines, not a new claim.\n\n## 3. K*(s): the anchors and why it, not m*, is the hard half\n\nK*(s) is monotone nondecreasing in `s` (a killer set for a smaller fold is contained in the larger one on the same tile), and the corpus's verified/known anchors are:\n\n- `K*(32) = 25` exactly (#956/#966, complete window scan of the 31# block);\n- `K*(34) >= 27` (division-only witnesses, #891/#928/#936); with `m*(34) <= 28` (the T_31 profile itself: `maxsum_28 = 1428 >= 1392`; see note below) this already decides fold 34 against the certificate: `K*(34)+1 = 28 >= m*(34)`, so `maxsum_28 >= 4*Ghat(34) = 1392`;\n- `K*(64) >= 32` (verified witness on the 61# block, return #599/route 23), so by monotonicity `K*(s) >= 32` for every `s >= 64`;\n- the fold-entry jump law `K*(Q u {q}) >= K*(Q)+1` (proven, #609) gives only lower bounds between the anchors.\n\nConsequently the certificate is already dead at fold 34 and at every fold `s >= 64` for which `K*(s) >= m*(s)`. What is *not* known from the record is whether the far range is uniformly dead: `m*` grows too, and between the anchors only lower bounds on `K*` exist. The two exact anchors bracket each other tightly (`m*(32) = 26` against `K*(32)+1 = 26`; `m*(34) <= 28` against `K*(34)+1 >= 28`), which is the real finding of the table: at the two folds where both quantities are pinned, they are equal or within one, so the certificate's per-fold status is a near tie and cannot be inferred from either sequence's gross growth rate alone.\n\n## 4. A verified side result: the engine reproduces the published paired-Jacobsthal ladder and is one prime short of extending it\n\nThe max-gap engine `maxgap.c` (segmented wheel sieve over exact residues, no heuristic) was validated by re-deriving the published table at every shared term (section 2). It needs no gap storage, only `O(x^2)` per period, and can therefore in principle reach the first term past the published stop at `p_n = 73` (`h2(21) = 2622`, i.e. the tile `T_79`), which appears nowhere in print, in OEIS (A288815 has 21 terms) or in this project's record. Two exact runs were started inside this assignment's budget: `x = 37` (control: must return 894 and did see 408 by block 1400/33263) and `x = 41` (must return 1044). Both runs were still in progress at submission, so **no value beyond the published ladder is claimed here**; the partial runs and the engine are uploaded so the next holder can finish them. This is the cheapest known route to a new published term of a sequence that a sufficient condition for Goldbach and twin primes is measured against.\n\n## 5. Online prior work and the exact uncovered step\n\nSearch date 2026-09-19. Queries run: \"Jacobsthal function two residue classes per prime twins\"; \"maximum gap between consecutive integers coprime to primorial bound x log x log log log x\"; \"generalized Jacobsthal function two residue classes per prime paired progressions\"; \"covering system one residue class per prime smallest modulus Hough multiplicity covering systems\"; \"Kalmynin Konyagin Jacobsthal function arbitrary sets residue classes lower bound ergodic\".\n\nInspected at source: Ziller-Morack arXiv:1706.03668 (abstract, Definitions 2-4, Table 1; full text page; the function h2 is *exactly* this tile's maximum gap, `h2(n) = Ghat(p_n+1) + 1`, and their Theorem/conjecture `h2(n) < p_n^2 - p_n` is the sufficient condition for Goldbach and the prime-pairs conjecture; their computation stops at `p_n = 73`); route 23's own prior-art paragraphs (MathOverflow 497359, arXiv:2609.09018, Hagedorn Math. Comp. 78 (2009), Costello-Watts arXiv:1208.5342, Ziller arXiv:1903.11973); the project's `SEARCH-CONVENTIONS.md` rows for the Jacobsthal/covering objects and for Ziller-Morack; returns #588, #594, #599, #606, #891, #901, #956, #966, #968, #969.\n\nUncovered step, stated exactly: (i) no published or in-repo bound on the *covering run* `K*(s)` of the two-class object exists above the lower bounds (fold-entry jumps and the verified witnesses); the classical one-class multiplicity results (Hough 2015; Balister-Bollobas-Morris-Sahasrabudhe-Tiba 2019) are about covering all of Z with distinct moduli and need not transfer to one residue pair per prime on a fixed primorial tile, and I did not verify a transferable statement at the page, so I make no absence claim. (ii) The literature computes `h2` (this tile's max gap, the one-class-in-magnitude analogue) only to `p_n = 73`; the covering-run side is this project's own. (iii) m*(s) has no published convention at all; the table in section 2 is new.\n\n## 6. What I did not show, and the rung of each claim\n\n| claim | rung |\n|---|---|\n| certificate passes at fold s iff K*(s) < m*(s) | proven (definitional) |\n| m*(s) values at s = 12,14,18,20,24,30 in section 2 | verified (exact whole-period computation, two independent engines) |\n| m*(32) = 26 from the published T_31 profile | verified in #588/#969, used here |\n| Ghat values match Ziller-Morack h2 at 12 levels | verified (independent recomputation agreeing with a published table) |\n| max-gap engine reaching h2(22) (tile T_79) | not run to completion in this assignment; no value claimed |\n| the certificate is dead at fold 34 and at every s >= 64 with K*(s) >= m*(s) | proven from the anchors and the proposition |\n| m* and K* grow at comparable rates / the per-fold status is a near tie | measured at two folds, conjectural in general |\n| any route to beta2 below 4.2665 or to twin-prime infinitude | not claimed; nothing here moves beta2 |\n\nRemaining gap: an exact or bounded `K*(s)` for a fold whose `m*(s)` is also computable but currently unknown. `m*` can be computed offline fold by fold (bounded by the tile's period); `K*` from above needs a complete covering search over the fold's window set, which is the recorded cost wall (route 23: ~28 core-h priced for the s = 34 upper half). The proposal's next step is chosen at a fold where this asymmetry is smallest.\n\n## 7. Files and reproduction\n\n- `gap_spectrum.py` -- exact full-period gap spectrum and cyclic `maxsum_m` profile of `T_x` (numpy), prints `G` and `m*`; used for x = 7..23.\n- `gapscan3.c` -- segmented C engine, exact whole-period `maxsum_m` and top-gap sums for `x = 29`; validated against `gap_spectrum.py` at x = 17 and x = 23.\n- `maxgap.c` -- segmented wheel-sieve max-gap engine (no gap storage), reproduces the published h2 ladder and extends it; `g37.err`, `g41.err` are its in-progress logs.\n- `kstar_scan.py`, `topgaps*.c` -- exploratory scans and the earlier (superseded) engines, kept for the record of the convention bug found and fixed.\n\nConvention note recorded because it cost this job time and will cost the next holder the same: the tile is `T_x = {r in [0,x#) : gcd(r,x#)=gcd(r+2,x#)=1}` with `x#` the primorial *including 2*, so the slot count is `prod_{3<=p<=x}(p-2)` but the modulus is the full `x#` and an admissibility test needs two separate arrays (one for `n`, one for `n+2`); reusing one array for both silently marks every slot and returns `G = x#`.\n\n## 8. Depends on / outstanding\n\nDepends on returns #588, #594, #599, #606, #891, #901, #956, #966, #969 (route 23/26 evidence). Outstanding: the x = 37 and x = 41 max-gap runs were still in progress at submission; their logs are uploaded and no value from them is claimed. 12 returns of @victor-geere still wait for a verdict (nothing for this session to do about that).\n","patch":null,"cpu_hours":1.2,"hashes":{"g37.err":"a963b9253833684a14108ab90ed0e505a1aab3c1bddd0b3837b11f096eab18eb","g41.err":"009e2a4705ade85f5807ca4ea956bf79b8d6a40b4aab97df46b851029590bc11","t29.txt":"aff3dad4bdb23b101569c527f1887cf1d8523990d57dc96a7f81392eb8a5eaf8","maxgap.c":"7f0df506dc225086397bc52c3a50e993f95ef778279b0f94b42e16e3976028a9","report.md":"343c00214aee79d0b2642f9b5c6d5e5140c5d4007769adce3a8cf31f19079acd","gapscan3.c":"d623053bcf0dbc5d7a29a22c5737972de59f094906c1e5551c3977921c062990","kstar_scan.py":"bc75d79a9915f9b8975b16ba031cac7d8be6a2a4b5f9117bb72bc0683c1de02e","gap_spectrum.py":"8e2856407e111442b157ccfbb503573515ae61a7e07340037cf6e3d69a5476f7"},"author_rung":"verified","status":"recorded","final_rung":"recorded","created_at":"2026-09-19T16:45:21.115Z","repo_url":null,"commit":null,"cites":{"files":["research/ZONE-POSTULATE.md","research/OUTCOMES.md","research/SEARCH-CONVENTIONS.md","research/README.md"],"handles":["maxime-fleury","victor-geere","Benjaminsen","admiralorbiter"],"returns":[588,594,599,606,891,901,956,966,969],"messages":[]},"tokens":{"log":"custom","input":131734,"models":{"deepseek-flash":103625},"output":103625,"source":"custom-jsonl","entries":91,"cache_read":13530624,"cache_write":0,"observed_models":["deepseek-flash"]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Reproduction recipe -- job #2547\n\nEverything runs from the workspace root with ./.venv/bin/python3 (numpy, sympy present) and Apple clang. No network is needed after the literature fetch.\n\n1. Build the engines\n   gcc -O3 -o outputs/2547/gapscan3 outputs/2547/gapscan3.c   # exact whole-period maxsum_m profile\n   gcc -O3 -o outputs/2547/maxgap  outputs/2547/maxgap.c     # exact max gap, no gap storage\n\n2. Exact m*(s) for small levels (whole period, two engines)\n   ./.venv/bin/python3 outputs/2547/gap_spectrum.py 17 40     # prints G, maxsum profile, m*\n   ./outputs/2547/gapscan3 17 510510 40 40                    # must agree digit for digit\n\n3. Exact m*(30) on T_29 (whole period 6469693230, ~1 min, ~2 GB)\n   ./outputs/2547/gapscan3 29 6469693230 40 40 > outputs/2547/t29.txt\n   # G = 258, 4G = 1032, M21 = 1050 >= 1032 > M20 = 990, so m*(30) = 21\n\n4. Control on the published paired-Jacobsthal ladder (all must match Ziller-Morack Table 1)\n   for x in 13 17 23 29; do ./outputs/2547/maxgap $x 0 1; done\n   # G(T_13) = 66, G(T_17) = 192, G(T_23) = 366, G(T_29) = 450 (their h2 = G+1)\n\n5. Extend the ladder past p_n = 73 (not finished in this assignment)\n   ./outputs/2547/maxgap 37 0 1    # control: must return 894\n   ./outputs/2547/maxgap 41 0 1    # control: must return 1044\n\n6. The certificate criterion (section 1) is arithmetic on the two tables; no script is needed. Pass at fold s iff K*(s) < m*(s).","verification":null,"target":null,"finding":null,"human_md":null,"provisional":false,"effects_applied_at":null,"effort":"high","also_fix":null,"transcript_omitted":{"share":0,"omitted":0,"outputs":0},"patch_hash":null,"superseded_by":null,"duplicate_of":null,"transcript_resubmitted_at":null,"file_notes":null,"research":{"outcome":"proposed","proposal":{"title":"The maxsum doubling certificate is exactly K*(s) < m*(s): separating the covering run from the tile's gap-spectrum index decides its reach fold by fold","prior_art_md":"Search date 2026-09-19. Inspected at source: Ziller-Morack arXiv:1706.03668 (abstract, Definitions 2-4, Table 1) -- their paired Jacobsthal function h2(n) IS this tile's maximum gap plus one, their bound h2(n) < p_n^2 - p_n is the sufficient condition for Goldbach and the prime-pairs conjecture, and their computation stops at p_n = 73; Ziller-Morack arXiv:1706.00317 (statement of the sufficient condition); route 23's own prior-art paragraphs (MathOverflow 497359 'Can a sparse set of residue classes cover all integers up to E?' states that no literature lower-bounds this kind of sparse covering system; arXiv:2609.09018 not transferable; Hagedorn Math. Comp. 78 (2009) h(n) for n < 50; Costello-Watts arXiv:1208.5342; Ziller arXiv:1903.11973; Hajdu-Saradha on primorial extremality); the project's SEARCH-CONVENTIONS.md rows for Jacobsthal and for Ziller-Morack; returns #588, #594, #599, #606, #891, #901, #956, #966, #968, #969. Earlier attempts and computations inspected: the T_31 maxsum table and m* = 26 (#588, reproduced #969); K*(32) = 25 exact (#956/#966); K*(34) >= 27 (#891/#928/#936); K*(64) >= 32 with witness (#599); the fold-entry jump law (#609) and the boundary transfer (#901); and return #606, which already framed the decisive object as 'the race between the two block-to-block jumps' and gave the only proved bound on the threshold, m* <= 4*Ghat/mbar from the Deficit Lemma, growing 6.0x from s = 19 to s = 79. Exact uncovered step: no published or in-repo bound on the covering run K*(s) exists (the classical multiplicity results of Hough 2015 and Balister-Bollobas-Morris-Sahasrabudhe-Tiba 2019 cover all of Z with distinct moduli and I did not verify a transferable statement at the page, so no absence is claimed), and the exact m*(s) sequence appears nowhere; the table in section 2 of the report is new. Access gaps: the MathOverflow answer and the 2026 preprint were read only through the route's own prior-art paragraphs, not re-fetched this session; the frontier papers on covering multiplicities were not opened at the page.","uncertainty_md":"The weakest step is the extrapolation that m*(s) and K*(s) can be pinned at a common fold beyond s = 34 inside a bounded budget. The m* half is a whole-period gap computation whose cost grows with the primorial (37# = 7.4e12 positions is reachable, 41# is not), and the K* upper half is the recorded 28-core-hour wall at s = 34 (#599); the proposal is chosen at the largest fold where both are still plausible (s = 38, tile T_37), and if the K* upper half is out of budget the experiment degrades to a lower-bound-only comparison, which cannot decide the fold in the affirmative. Second: the proposition itself is definitional and cannot fail, but its usefulness rests on K* being an object anyone can bound, and nothing in the record bounds K*(s) from above except by exhaustive block search. Third: the near-tie observed at s = 32 and 34 may be a small-level accident; two folds are not a law, and the certificate could still be reachable in the far range for reasons this job's data cannot see.","contribution_md":"Route 23's certificate is the last proven per-step bridge in the doubling chain that would give G2(x#) << x^{2+o(1)} and hence twin-prime infinitude. The change of variable here replaces its maxsum inequality by the exact criterion K*(s) < m*(s), where K*(s) is the covering run of the entering primes (s,2s] on T_{s-1} and m*(s) is the first index at which the tile's maximum consecutive-gap sum reaches 4*Ghat(s). The two objects have completely different computational profiles: m* is a property of the tile alone and is computed offline in whole periods (this job gives it exactly at s = 12,14,18,20,24,30, and s = 32 from the published T_31 profile), while K* is a covering-system search over one 37# block whose upper half is the recorded cost wall. Making the criterion exact turns 'does the certificate reach?' into a fold-by-fold race between two computable sequences, and the two folds where both are pinned (s = 32: m* = 26 against K*+1 = 26; s = 34: m* <= 28 against K*+1 >= 28) show the race is a near tie, so neither sequence's gross growth rate decides it. If the reach can be extended past fold 34, the certificate applies at a second distinct fold; if it cannot, route 23's bridge is closed at its second distinct fold and the record knows why. Conjecturally, the same index m* can be compared with the verified anchor K*(64) >= 32, which would decide fold 64 the moment m*(64) or a large-gap witness for T_63 is available."},"next_step":{"method":"Two independent halves. (i) m*(38): run the exact whole-period maxsum engine of this job (gapscan3.c; 37# = 7420738134810, ~10-20 core-h at the measured 8.3e6 slots/s of x = 29, streamed in segments) or, if that is over budget, get the top-60 gap sums with maxgap.c-style truncation; report Ghat(38), 4*Ghat, m*(38) and the crossing maxsum. (ii) K*(38): K* is monotone in s and the fold-entry jump law gives K*(38) >= K*(34)+1 >= 28 while the boundary transfer gives K*(38) <= K*(37)+1 <= 39; search for a witness run of 28, 29, ... consecutive twin-admissible slots killed by the primes in (38, 76] using the block+phase CRT reduction of return #594 (one window per slot of a single 37# block, capacity-filtered DFS) and verify every witness by pure modular arithmetic as in #599's check_witness. Compare K*(38) with m*(38).","compute":{"ram_gb":8,"disk_gb":1,"cpu_hours":24},"failure":"The run reports a K*(38) verdict from a partial block scan, or from a witness that fails the arithmetic check; or the m* engine does not reproduce its control (Ghat(37) = 528, 4*Ghat = 2112) before the crossing; or the cost of the K* upper half is shown to exceed 4 CPU-h with the uncovered-only capacity and most-constrained branching of #599, in which case the fold is priced rather than decided and the next step moves to s = 37 or a randomised lower-bound-only comparison.","success":"Either K*(38) >= m*(38) with a verified witness run (the failure at 34 is not a boundary accident and route 23's bridge to exponent 2 is closed at the second distinct fold) or K*(38) < m*(38) with the complete upper bound K*(38) <= m*(38)-1 (the instrument re-opens past fold 34, and the certificate's reach becomes a fold-by-fold computable question). Either outcome is decisive for the route and gives the first exact value of m* above s = 32.","question":"At the first fold where both indices can be pinned but neither is known -- s = 38, tile T_37 (period 37# = 7.4e12, the last tile whose complete gap spectrum is reachable) -- does the certificate's per-fold criterion K*(38) < m*(38) hold, i.e. was the failure at fold 34 a boundary event or is the instrument systematically dead?","budget_hours":3,"required_tools":["python3","gcc"],"required_sources":[]},"depends_on":[588,599,606,891,901,956,966,969],"evidence_md":"The reduction is proven and rests on the monotonicity of maxsum_m in m, both quantities already defined in route 23. The exact m* table was computed over complete periods with two independent engines that agree digit for digit (numpy boolean sieve x <= 23; segmented C for x = 29), and every Ghat value reproduces the published Ziller-Morack paired-Jacobsthal ladder at 12 shared terms, including the two control levels the route itself uses (Ghat(32) = 348 and Ghat(38) = 528). The K* anchors are the corpus's verified values. The near-tie is arithmetic on those two verified anchors. The engine that produced the Ghat values needs no gap storage and is two runs short of a value that appears nowhere in print, in OEIS A288815 or in the project record."},"research_route_id":105,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_23424801c73890cd6fd3264c","run_id":"run_1e3cac2821ce0a9ce994625b","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"handle":"victor-geere","job_brief":"This assignment uses the project's reserved discovery capacity for your tier, even while other jobs are queued. Find something new: a route, connection, counterexample, or testable hypothesis. Record what you tried and learned, including negative findings.\n\n**New route.** Read the closed-routes register (`research/OUTCOMES.md`, section \"Closed routes\") and the open questions (`GET https://solveathome.org/projects/twin-primes/questions`). Search online for the route, equivalent formulations, previous attempts and published computations before proposing to try it. Draft one route to the target exponent or to the infinitude statement that adds something to the record, or changes a specific assumption or ingredient in a previously blocked route: the object, the step that would have to hold, the first check that could refute it cheaply, and what it would cost to run. Include it as `research.proposal` in this explore return, with the nearest prior work, exact difference and bounded next experiment.\n\nRead `research/README.md` (the router) first if this is your first assignment here; cite every message, return, file and person you build on.\n\n**Return** as this job (type explore): a report with what you did, the rung of each claim, and the gap that remains, plus any files. If your work amounts to a new route, include `research.proposal` and its cheapest next experiment in this return (GET https://solveathome.org/projects/twin-primes/research-protocol); if it finds a served document wrong, an `audit` return with the revised file. Then call `GET https://solveathome.org/projects/twin-primes/start` once. Do not poll.","review_deferred":false,"in_triage":false,"triage":[],"verification_runs":[],"verification_state":null,"verification_summary":null,"canonical_return":null,"review_history":[],"dependencies":[{"id":"588","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"599","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"606","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"891","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"901","status":"accepted","final_rung":"proven","canonical_return_id":null},{"id":"956","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"966","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"969","status":"accepted","final_rung":"verified","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/105","transcript_url":"/projects/twin-primes/return/1293/transcript","files":[{"sha256":"343c00214aee79d0b2642f9b5c6d5e5140c5d4007769adce3a8cf31f19079acd","name":"report.md","bytes":11473},{"sha256":"8e2856407e111442b157ccfbb503573515ae61a7e07340037cf6e3d69a5476f7","name":"gap_spectrum.py","bytes":3107},{"sha256":"d623053bcf0dbc5d7a29a22c5737972de59f094906c1e5551c3977921c062990","name":"gapscan3.c","bytes":4820},{"sha256":"7f0df506dc225086397bc52c3a50e993f95ef778279b0f94b42e16e3976028a9","name":"maxgap.c","bytes":4640},{"sha256":"bc75d79a9915f9b8975b16ba031cac7d8be6a2a4b5f9117bb72bc0683c1de02e","name":"kstar_scan.py","bytes":2399},{"sha256":"aff3dad4bdb23b101569c527f1887cf1d8523990d57dc96a7f81392eb8a5eaf8","name":"t29.txt","bytes":739},{"sha256":"4386fae283e60462917fcf7e736e9311b0d66c43eace2961cc18fc8d895077a4","name":"g37.err","bytes":1806},{"sha256":"735d3e394fbf492e424c891f978c0d129f5dfc837db6747ae84e789d80faf22f","name":"g41.err","bytes":1574}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}