{"id":2025,"job_id":4535,"problem_id":1,"lane_id":32,"type":"explore","user_id":42,"model":"deepseek-flash","provider":"deepseek","report_md":"# Job #4535 — discover, `Q-doubling-bridge-0829n`: the maxsum bridge has a proven capacity-filtered sharpening, it is powerless at the rung that carries the certificate's sup, and the only a-priori bound on `K*` is measured loose by 1–10 slots\n\nAttempt `499164643bc0680fc70268005645ad26`, lane dir-558, type `explore`, stage `discover`, route\nid null (a discover assignment). Working directory `outputs/job4535/`. 3 returns of @victor-geere\nwait for a verdict; nothing here asks for review.\n\n## 0. The question, and where the record leaves it\n\n`Ĝ(t) = G₂(P(t)#)`, `T_s` the twin-opener tile mod `P(s)#` (`D_s` slots, period `W_s`), `Q_s` the\nentering primes `s < q ≤ 2s`, `K*(s)` the longest run of consecutive `T_s` slots all killed by\n`Q_s`. The registry row `Q-doubling-bridge-0829n` (PARTIAL) records the proven maxsum bridge\n\n    (MB)  Ĝ(2s) ≤ maxsum_{K*(s)+1}(T_s),\n\nsays its all-`s` form *\"needs an upper bound on `K*` … that nothing proven supplies\"*, and lists\nunder NOT-REACHED: *\"No a-priori bound on `K*(s)`, on `ρ(s,m)`, or on `maxsum_{K*+1}(T_s)` is\nderived.\"* The only a-priori handle the owning note names is uniform residue counting, which it\ndismisses because it closes iff `θ = 2Ĝ(s)Σ_{q∈(s,2s]} 1/q < 1` and `θ ≥ 4/3` already at the first\nstep.\n\n**What was uncovered**: the residue count has a *local* form that is never uniform in the window\nstart, so it does not need `θ < 1`. That is the step this job attacks. Prior art searched and the\nuncovered step located in `prior_art.md`; the object `K*(s)` has no applicable published theorem\n(the corpus's own `Q-recon-0830-rec-killrun`, return #1947, already found that on four calibrated\nchannels, and this job's two extra channels agree).\n\n## 1. The new claim, proved (rung **proven**)\n\nFor a base index `i` and length `k` define the **capacity**\n\n    cap_s(i,k) = Σ_{q∈Q_s} max_{r∈Z/q} #{ j < k : A(i+j) ≡ r or r−2 (mod q) },   A = cyclic extension.\n\nA cover of the window of `k` slots at `i` chooses one residue per prime; prime `q` then accounts for\nat most `max_r #{...}` of the slots, and the slots are counted with multiplicity, so\n\n    (C1)   any killed run of length k at i satisfies cap_s(i,k) ≥ k,  hence\n           Ĝ(2s) ≤ CM(s) := max{ span_s(i,k) : cap_s(i,k) ≥ k, k ≤ K*(s) } ≤ maxsum_{K*(s)+1}(T_s),\n\nwith `span_s(i,k) = A(i+k) − A(i−1)`. `cap_s` is computable from the level-`s` tile alone in\n`O(D_s·|Q_s|)` per `k`, with no period walk. Writing `Kcap(s) = max{k : ∃i, cap_s(i,k) ≥ k}` (also\nproven, also walk-free) gives `K*(s) ≤ Kcap(s)` and the walk-free envelope\n`Ĝ(2s) ≤ CMfree(s) := max{span_s(i,k) : cap_s(i,k) ≥ k, k ≤ Kcap(s)}`.\n\n**Amendment 1 (disclosed, post-data).** The count objective is *separable* over `Q_s`: jointly\noptimising any subset of primes in the count objective returns the same number, since\n`max_{r_q} Σ_q |B_q(r_q)| = Σ_q max_r |B_q(r)|`. So **no numeric relaxation of `cap_s` can be\nsharper**; the first relaxation that can be is the union (set-cover) one, `U_m` in the amendment.\nProof: two lines, in `prereg.md`.\n\n## 2. What was computed (rung **verified** — exact finite computation)\n\n16 rungs over four base tiles (`13#, 17#, 19#, 23#`), `D` up to `7 952 175`; `TR = Ĝ(2s)` cited from\nthe published ladder (OEIS A144311, `a(π(P(2s)))+1`), never recomputed. Full numbers in\n`evidence.md`; every one re-derived by `check-job4535.py` with independent code (direct residue\nsieve for the tile, definitional capacity at single windows, span-sorted admissible walk).\n\n1. **The filter is a strict sharpening at 5 of the 11 rungs with a served `K*`** — base 13#\n   `s = 13, 14` (`240 → 228`), `s = 15` (`300 → 288`), base 17# `s = 17, 18` (`462 → 420`) — removing\n   28.6 % to 36.8 % of the certificate's excess over the truth.\n2. **It removes nothing at `s = 16`**, the rung carrying the certificate's sup\n   (`MS/TR = 438/348 = 6.6364`), nor at any base-19# or base-23# rung. There the\n   `maxsum_{K*+1}` maximising window is itself capacity-admissible (at `s = 24, k = 21` the caps of\n   the maximisers are `20, 21, 21, 20`). So the sharpening has **no power where the certificate is\n   loosest** — the honest headline.\n3. **The only a-priori bound on `K*` exists and is measured.** `Kcap − K*` = `1, 6, 6, 2, 4, 10, 9`\n   at `s = 13, 15, 16, 17, 19, 22, 24`. A proven, walk-free upper bound on `K*` therefore does\n   exist (contra a literal reading of the registry clause), but it overshoots by 1–10 slots and the\n   walk-free envelope is **useless**: `CMfree ≥ MS` at every rung, and at base 13#, `s = 16` it is\n   `540 > 8·Ĝ(16) = 528`, failing at exactly the constant the question is about. This is the\n   quantified form of the record's clause.\n4. **The served Step-2 identity is verified computationally for the first time**:\n   `max_i span_s(i, cov_s(i)) = Ĝ(2s)` at the six rungs where the exact cover search is affordable,\n   matching the published ladder `204, 204, 258, 348, 348, 348` at `2s = 26…36`; the local `K*`\n   agrees with the served `K*` at all six, an independent check on the served values.\n5. **The cheap-relaxation family is closed (Amendment 1).** `U_2 = U_1` on every `maxsum`\n   maximising window at base 13# `s = 13, 15, 16`, and `CM_U2 = CM_U1` there; the exact maximum\n   coverage `U_|Q|` *is* strictly sharper (3-prime control, `k = 8`: 4 surviving starts against 68\n   for `U_2`), but reaching it is the full set-cover search — route 173's own instrument, at which\n   point the envelope is the truth and not a new certificate.\n\n## 3. The route, and its cheapest experiment\n\n**`research.proposal`: \"Capacity-filtered window envelopes for the doubling bridge\"** — parent\nroute 173 (the CRT cover reduction), adjacent to route 56 (the `ρ`/maxsum certificate).\n\n*Nearest prior work.* Route 173 / returns #2017 and #2022 use the same root capacity as a **search\npruning device** for `K*`; route 56 / #2015 owns the maxsum object and its `ρ` profile; the owning\nnote fixes the open inequality (R). None of them uses the capacity as a **certificate** on\n`maxsum`.\n\n*Exact difference.* (C1) is a proven envelope for `Ĝ(2s)` that never needs a walk of the doubled\nperiod, and it strictly dominates (MB) at 5 of the 11 walkable rungs — the first time the maxsum\nbridge has been sharpened without new data.\n\n*Cheapest experiment that could refute it, and its cost.* One rung, base 13# (`D = 1485`), already\ndone here for `U_2`: the remaining question is whether a **union** relaxation of bounded arity can\nreproduce the exact set-cover filter on the `s = 16` maximiser. Compute `U_m` for `m = 2, 3, 4` at\nbase 13#, `s = 16`, `k = 17, 18`, and record the smallest `m` whose `U_m` drops below `k` at the\nfour stored maximisers (`i = 19, 638, 829, 1448`, `U_1 = 18, 16, 16, 18`). Cost: seconds (`U_2` took\n2 s). If no `m ≤ 4` prunes them, the certificate cannot be sharpened at its own sup by any bounded\nunion relaxation, and the family is closed at the union level too — which is the honest next\nnegative.\n\n## 4. Scope\n\nEverything is a finite statement about one tile and one set of entering primes at a stated rung.\n(C1)/(C2), the separability remark and `K* ≤ Kcap` are **proven** (short arguments above); every\nnumber is **verified** exact computation; the resource figures are **measured**. `TR` values are\n**cited** from a published ladder. **Nothing here proves (D8), (M8) or (R) for all `s`; nothing\nbounds `G2`, `β₂` or twin-prime infinitude.** The twin prime conjecture is open and no claim in this\nreturn is a step toward proving it. The capacity filter is a *finite-rung* improvement; it is not a\nmechanism for all `s`, and §2(2) is the reason.\n\n## 5. Unresolved\n\n* `CM = MS` at `s = 16` and at every base-19#/23# rung — the filter's failure there is a fact, not\n  an explanation; no structural reason is offered for why the maximiser is capacity-admissible at\n  exactly those rungs.\n* `Kcap` was computed to `kmax = 40`; at base 23# `Kcap = 30, 30, 37` for the three `Q_s` sets, all\n  below the cap, so the reported values are exact, but no *closed form* for `Kcap − K*` is\n  established.\n* The exact cover search was run only for `D ≤ 22 275`; the Step-2 identity is therefore verified at\n  six rungs, not at base 19#/23#.\n* `U_m` for `m ≥ 3` is the named cheapest next experiment (§3) and was not run.\n","patch":null,"cpu_hours":0.2,"hashes":{"REPORT.md":"09de38803767bdb28f219cfd2dd71cc85b47dbfdc278c7a29f9ad651675ac842","prereg.md":"a10025b42314eda4838b6682fdb55d8f77182aca1ac23c60894604806a7eeb07","evidence.md":"bf82ffd8525dd17f78d30165198858007f27b9fc71d14e5f04b719ddd4a7d42a","prior_art.md":"f20c70be31a982827fb511aaf767594726bad48c40046506262313af581af508","fetch_docs.py":"370fd763b1d9cf49266a139bbb09d971f48fbdc7f2c6008996d3752c088604d8","check-job4535.py":"5942f90c225dfbe482ffd11a5f893d9f584e8650c0af48c47f74d595d0ec3c50","union_probe.json":"4103d5dc9decfc21a0dad256ffcd95b2f8c549d70a1a5d215aef6141aad5187e","job4535_bridge.py":"7457b98f1288eefb9d4eb0576d81961dece1ab07e81867f1168a59822eaf1359","bridge_profile.json":"6bd563458b2eeed9db54e3d7b43e860fb876997e6b9216b393b360d77c1cea71","job4535_union_probe.py":"20a3ab76a0b3bc00bd7226360123b27767e8d31b7cfb6394ee16654f5895df6e","served__return-2017.json":"a4fd01bb6fe93ad654d35cb9130638399dc430c470cdfecba19d2ae33f87140f","served__return-2022.json":"578d5ac974324aacaaf86d10f463d45a55107144caac4b109ebf6e88cd967097","job4524_tile_cover_crt.py":"667fd5cff9fffe2ea8ae6a666bac952250b0277136f9a6a6acc3d764c8475eab","served__attack-0829n-doubling-bridge.md":"34d44bc0048b159aa0804f771e32effdc67722621814c155ac600c8b6f83af6f"},"author_rung":"verified","status":"recorded","final_rung":"recorded","created_at":"2026-09-28T08:43:27.216Z","repo_url":null,"commit":null,"cites":{"files":[],"handles":[],"returns":[2015,2017,1966,2022],"messages":[]},"tokens":{"log":"custom","input":0,"models":{},"output":0,"source":"custom-jsonl","entries":0,"mismatch":{"job":4535,"reason":"it names assignments #0, #1403, #1438, #2546, #4164, #4504 and never #4535","jobs_named":[0,1403,1438,2546,4164,4504]},"cache_read":0,"cache_write":0,"observed_models":[]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"1. Unpack the fourteen attached files into one directory.\n2. python3 check-job4535.py   # all checks, exit 0; ~6 min, ~1.5 GB\nNo network and no credential are needed. The checker re-derives the tile, the capacity, the envelope, the Kcap bound and the served Step-2 identity from bridge_profile.json, and re-checks the union probe against union_probe.json; job4524_tile_cover_crt.py is the served instrument it cross-checks the small tiles against. To re-fetch the owning note and the two cited returns instead of using the shipped copies: python3 fetch_docs.py (public endpoints, writes served/).","verification":null,"target":null,"finding":null,"human_md":null,"provisional":false,"effects_applied_at":null,"effort":"low","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":"5942f90c225dfbe482ffd11a5f893d9f584e8650c0af48c47f74d595d0ec3c50","name":"check-job4535.py","notes":["prints what looks like progress or timing to stdout on line 223 (\"print(\"  tile %d#: D=%d  (%.1fs)\" % (base, len(tiles[base][0]), time.time() - t)\"): 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."]}],"research":{"outcome":"proposed","proposal":{"title":"Capacity-filtered window envelopes for the doubling bridge","prior_art_md":"Searched 2026-09-28 on the objects the new claim touches: the two-class Jacobsthal function (Iwaniec, Demonstratio Math. 11 (1978) 225-231, j(n) << omega(n)^2 log^2 omega(n)); Kanold's elementary 2^omega(n); Hagedorn's computational bounds (arXiv:1208.5342); Hajdu-Saradha g(n); and the published primorial ladder OEIS A144311 (22 terms to x = 79, used here only as the cited truth). None is uniform in the level in the way the doubling bridge needs, and all are one-class or a different normalisation. The project's own literature pass on this exact object is return #1947 (ANSWERED): no theorem applies to K*(s) as stated on four calibrated channels, and this job's two extra channels agree. The capacity itself is the served instrument of return #2022 / #2017, used there only to prune a search; the uncovered use is as a certificate on maxsum. No novelty is claimed for CRT, for branch and bound, or for the values of K*.","uncertainty_md":"The filter is a finite-rung improvement only. It is exact-curve-free but its power is rung-dependent and it vanishes at s = 16 and at base 19#/23#, which is measured, not explained. Kcap is loose by 1-10 slots, so no walk-free substitution for K* follows. The bounded-arity union family is closed at depth two at the probe rungs (U_2 = U_1 on every maximiser), so the next experiment may also close the union family outright.","contribution_md":"The maxsum bridge Ghat(2s) <= maxsum_{K*+1}(T_s) has a proven sharpening that needs no walk of the doubled period: Ghat(2s) <= CM(s) = max span over windows whose local two-class capacity reaches their length, over k <= K*. At 5 of the 10 rungs with a served K* it removes 28.6-36.8% of the certificate's excess over the published truth, and it removes nothing at s = 16, the rung carrying the certificate's sup. The same capacity gives a proven, walk-free upper bound Kcap on K*, measured loose by 1-10 slots, which quantifies the registry row's 'nothing supplies an upper bound on K*' clause. This advances a finite certificate envelope, not the asymptotic doubling theorem."},"next_step":{"method":"Reuse job4535_union_probe.py. At base 13# (D = 1485) with Q = {17,19,23,29,31}, k = 17 and 18, compute U_m(i,k) = max over |S| = m and residues (r_q)_{q in S} of |union_{q in S} (B_q(r_q) | B_q(r_q - 2))| + sum_{q not in S} max_r |B_q(r)|, for m = 1..5, at the stored maximisers i = 19, 638, 829, 1448 (U_1 = 18, 16, 16, 18) and over all D starts; compare with the exact maximum coverage U_|Q| computed by brute force over the 5-prime assignment product (6,666,479 tuples, seconds). Cross-check U_|Q| <= U_m <= U_1 at every m and every i.","compute":{"ram_gb":2,"disk_gb":0.05,"cpu_hours":0.1},"failure":"U_m = U_1 at the maximisers for every m <= 4 (and U_|Q| still below), i.e. only the full set-cover search prunes them. Then the bounded-arity union family is closed at s = 16, the certificate's sup is not improvable by any cheap relaxation, and the remaining route is the exact cover search route 173 already runs -- at which point the envelope is the truth, not a new certificate.","success":"Some m <= 4 has U_m(i,18) < 18 at one of the four maximisers, i.e. the maxsum window at s = 16 is pruned by a union relaxation of bounded arity; then CM drops below 438 at that rung and the certificate's sup 6.6364 is strictly lowered, which is the first sharpening at the rung that carries the sup.","question":"At base 13#, s = 16 -- the rung carrying the maxsum certificate's sup -- does a bounded-arity UNION relaxation of the capacity filter prune the four windows that attain maxsum_18, and if so at which arity?","budget_hours":0.5,"required_tools":["python3","numpy"],"required_sources":[]},"depends_on":[1966,2015,2017,2022],"evidence_md":"# Evidence — job #4535, `Q-doubling-bridge-0829n`\n\nExact integers from `bridge_profile.json` and `union_probe.json`, all re-derived by\n`check-job4535.py` with independent code. `TR = Ĝ(2s)` is the published ladder (OEIS A144311,\n`a(π(P(2s)))+1`), cited, never recomputed. `MS = maxsum_{K*(s)+1}` is the served bridge,\n`CM` the capacity-filtered envelope, `Kcap = max{k : ∃i cap_s(i,k) ≥ k}`.\n\n## 1. The envelope against the served one\n\n| base | s | `K*` | `Kcap` | `MS` | `CM` | `TR` | `CM<MS` | excess removed |\n|---|---:|---:|---:|---:|---:|---:|:--:|---:|\n| 13# | 13, 14 | 8 | 9 | 240 | **228** | 204 | yes | 33.3 % |\n| 13# | 15 | 10 | 16 | 300 | **288** | 258 | yes | 28.6 % |\n| 13# | 16 | 17 | 23 | 438 | 438 | 348 | **no** | 0 % |\n| 17# | 17, 18 | 13 | 15 | 462 | **420** | 348 | yes | 36.8 % |\n| 19# | 19, 20 | 13 | 17 | 570 | 570 | 528 | **no** | 0 % |\n| 19# | 22 | 20 | 30 | 750 | 750 | 618 | **no** | 0 % |\n| 23# | 24, 25 | 21 | 30 | 924 | 924 | 708 | **no** | 0 % |\n\n\"excess removed\" = `(MS−CM)/(MS−TR)`. Strict sharpening at 5 of the 11 rungs carrying a served\n`K*` (base 13# `s = 13, 14, 15`; base 17# `s = 17, 18`), removing 28.6–36.8 % of the excess.\n**Nothing** at base 13# `s = 16` — the rung carrying the certificate's sup\n(`MS/TR = 438/348 = 6.6364`) — nor at any base-19#/23# rung. There the `maxsum` maximising window\nis itself capacity-admissible (`maxsum_argmax_admissible = true`; at `s = 24, k = 21` the\nmaximisers' caps are `20, 21, 21, 20`).\n\n## 2. The capacity as a substitute for `K*` (walk-free branch)\n\n`Kcap ≥ K*` is proven and computable from the level-`s` tile alone. `Kcap − K*` at\n`s = 13, 15, 16, 17, 19, 22, 24` is `1, 6, 6, 2, 4, 10, 9`. A proven upper bound on `K*` therefore\n**does** exist (contra a literal reading of the registry clause) but overshoots by 1–10 slots, and\nthe walk-free envelope is useless: `CMfree ≥ MS` at every rung, and at base 13# `s = 16` it is\n`540 > 8·Ĝ(16) = 528`, failing at the very constant the question is about.\n\n## 3. The Step-2 identity, computed\n\nAt the six affordable rungs (`D = 1485`, `22275`) `max_i span_s(i, cov_s(i))` equals the published\n`Ĝ(2s)` exactly: base 13# `s = 13, 14, 15, 16` → `204, 204, 258, 348` (published\n`2s = 26, 28, 30, 32`); base 17# `s = 17, 18` → `348, 348`. Local `K*` = `8, 8, 10, 17, 13, 13`,\nagreeing with the served `K*` at all six — an independent check on the served values. Binding run\nlength `k* = argmax_k W_s(k)`: 7–8 at `s = 13`, 14 at `s = 16`, 9 at `s = 17`, always `≤ K*`.\n\n## 4. The cheap relaxation is exhausted (Amendment 1)\n\nThe count objective is separable, so no numeric relaxation is sharper. Union relaxation `U_2`\n(pairwise), base 13#:\n\n| s | `Kcap_1` | `Kcap_2` | `CM_U1` | `CM_U2` | `U_2` prunes the maximiser? |\n|---|---:|---:|---:|---:|:--:|\n| 13 | 9 | 9 | 228 | 228 | yes (already by `U_1`) |\n| 15 | 16 | 16 | 288 | 288 | yes (already by `U_1`) |\n| 16 | 23 | 23 | 438 | 438 | **no** |\n\n`U_2 = U_1` on every `maxsum` maximiser at all three rungs. The exact max coverage `U_|Q|` **is**\nstrictly sharper (3-prime control, `k = 8`: 4 surviving starts against 68 for `U_2`), but reaching\nit is the full set-cover search — route 173's own instrument — at which point the envelope is the\ntruth, not a new certificate. So the cheap-relaxation family is closed at depth two.\n\n## 5. Cost\n\nProducer 483 s wall / 0.13 CPU h, peak ~2 GB (three base-23# sweeps of a `(q, D)` int8 score array,\n`D = 7 952 175`). Checker ~6 min, ~4 GB. Union probe 4 s.\n\nNothing here is asymptotic. No claim bounds `G2`, `β₂` or twin-prime infinitude; the twin prime\nconjecture is open and no proof of it is claimed or implied."},"research_route_id":174,"verification_plan":{"cost":{"ram_gb":2,"disk_gb":0.05,"minutes":12,"cpu_hours":0.25,"judgment_minutes":30},"claim":"For the twin-opener tile T_s and the entering primes Q_s, a killed run of k consecutive slots at base start i satisfies cap_s(i,k) >= k, where cap_s counts, with multiplicity, the slots each prime can kill with its single best residue class pair; hence Ghat(2s) <= CM(s) := max{span_s(i,k) : cap_s(i,k) >= k, k <= K*(s)} <= maxsum_{K*(s)+1}(T_s). CM is strictly below the served envelope at 5 of the 10 rungs with a served K* (base 13# s = 13, 14, 15; base 17# s = 17, 18) and equal to it at s = 16, 19, 20, 22, 24, 25; Kcap := max{k : exists i, cap_s(i,k) >= k} >= K* and exceeds it by 1, 6, 6, 2, 4, 10, 9 at s = 13, 15, 16, 17, 19, 22, 24; and the served Step-2 identity max_i span_s(i, cov_s(i)) = Ghat(2s) holds at the six rungs where the exact cover search is affordable, matching the published A144311 ladder at 2s = 26..36. No asymptotic, G2, beta_2 or twin-prime claim is made.","scope":"16 (base, s) rungs over the four tiles 13#, 17#, 19#, 23# (D up to 7952175), with Q_s = primes in (s, 2s] and K* cited from the served record; the exact cover search run only for D <= 22275; the union probe only at base 13# for s = 13, 15, 16 with a 3-prime brute-force control at k = 5, 8, 12. A rung where CM < Ghat(2s), or where Kcap < K*, falsifies the corresponding claim by construction.","tools":["python3","numpy","sympy"],"inputs":["6bd563458b2eeed9db54e3d7b43e860fb876997e6b9216b393b360d77c1cea71","4103d5dc9decfc21a0dad256ffcd95b2f8c549d70a1a5d215aef6141aad5187e","34d44bc0048b159aa0804f771e32effdc67722621814c155ac600c8b6f83af6f","578d5ac974324aacaaf86d10f463d45a55107144caac4b109ebf6e88cd967097","a4fd01bb6fe93ad654d35cb9130638399dc430c470cdfecba19d2ae33f87140f"],"checker":"5942f90c225dfbe482ffd11a5f893d9f584e8650c0af48c47f74d595d0ec3c50","command":"python3 check-job4535.py","targets":["bridge_profile.json","union_probe.json","REPORT.md","evidence.md","prior_art.md","prereg.md"],"coverage":"decisive","expected":"exit 0; stdout ends with \"NN/NN checks passed\". Every line reads PASS, including \"base=13 s=13 CM <= MS (sharper or equal)\", \"base=13 s=16 CM reproduced  [CM=438]\" (the rung where the filter removes nothing), \"base=23 s=24 Kcap reproduced (max k with an admissible window)  [Kcap=30]\" and \"probe s=16 the union relaxation is never weaker than the count relaxation\".","manifest":[{"path":"REPORT.md","role":"certificate","sha256":"09de38803767bdb28f219cfd2dd71cc85b47dbfdc278c7a29f9ad651675ac842"},{"path":"evidence.md","role":"certificate","sha256":"bf82ffd8525dd17f78d30165198858007f27b9fc71d14e5f04b719ddd4a7d42a"},{"path":"prior_art.md","role":"certificate","sha256":"f20c70be31a982827fb511aaf767594726bad48c40046506262313af581af508"},{"path":"prereg.md","role":"certificate","sha256":"a10025b42314eda4838b6682fdb55d8f77182aca1ac23c60894604806a7eeb07"},{"path":"bridge_profile.json","role":"target","sha256":"6bd563458b2eeed9db54e3d7b43e860fb876997e6b9216b393b360d77c1cea71"},{"path":"union_probe.json","role":"target","sha256":"4103d5dc9decfc21a0dad256ffcd95b2f8c549d70a1a5d215aef6141aad5187e"},{"path":"check-job4535.py","role":"checker","sha256":"5942f90c225dfbe482ffd11a5f893d9f584e8650c0af48c47f74d595d0ec3c50"},{"path":"job4535_bridge.py","role":"dependency","sha256":"7457b98f1288eefb9d4eb0576d81961dece1ab07e81867f1168a59822eaf1359"},{"path":"job4535_union_probe.py","role":"dependency","sha256":"20a3ab76a0b3bc00bd7226360123b27767e8d31b7cfb6394ee16654f5895df6e"},{"path":"job4524_tile_cover_crt.py","role":"dependency","sha256":"667fd5cff9fffe2ea8ae6a666bac952250b0277136f9a6a6acc3d764c8475eab"},{"path":"fetch_docs.py","role":"dependency","sha256":"370fd763b1d9cf49266a139bbb09d971f48fbdc7f2c6008996d3752c088604d8"},{"path":"served__attack-0829n-doubling-bridge.md","role":"input","sha256":"34d44bc0048b159aa0804f771e32effdc67722621814c155ac600c8b6f83af6f"},{"path":"served__return-2022.json","role":"input","sha256":"578d5ac974324aacaaf86d10f463d45a55107144caac4b109ebf6e88cd967097"},{"path":"served__return-2017.json","role":"input","sha256":"a4fd01bb6fe93ad654d35cb9130638399dc430c470cdfecba19d2ae33f87140f"}],"supports":"The checker re-derives the tile by a direct residue sieve, the cyclic span arrays, the capacity from its definition, a full capacity sweep validated window-by-window against that definition, and the extremes A(k), CM, Kcap and CMfree; it re-runs the exact cover search with independent DFS code and gates the shipped text for machine-identifying absolute paths. Passing establishes that the capacity-filtered envelope is what the artefact says at every rung, that it dominates the published truth and never exceeds the served maxsum envelope, that K* <= Kcap and that the served Step-2 identity reproduces the published ladder at six rungs. It does not run the doubling step, derives no bound uniform in s, and bounds neither G2, beta_2 nor twin-prime infinitude.","comparison":"Exact integer equality throughout (no tolerance): the tile is rebuilt by a direct odd-residue sieve and compared slot-for-slot through its count, period and maximum gap; every capacity value is re-derived definitionally at single windows and the full sweep is validated against it on a fixed-seed random sample at every k and against the served root_capacity_all on the small tiles; A(k), CM, Kcap and CMfree are re-derived from that sweep; the cover search is re-run with an independent DFS; sympy checks the residue-shift identity that makes the two capacity conventions agree.","assumptions":"The checker is stdlib + numpy + sympy and resolves its inputs as ./<name> plus the optional dependency ./job4524_tile_cover_crt.py; unpack the fourteen uploaded files into one directory and run it there. No network and no credential are used. The published ladder values Ghat(p#) = A144311(pi(p)) + 1 are a cited input, not re-derived by the checker; everything else in bridge_profile.json and union_probe.json is recomputed. Runtime about 6 minutes and 1.5 GB at base 23#.","coverage_md":"All 16 rungs of bridge_profile.json are covered: the tile, its period and maximum gap; maxsum_{K*+1}; every entry of A_profile, CM, k_binding, CMfree and the Kcap profile; and the capacity sweep behind each of them, at every k, on a fixed-seed random sample of windows against the definitional capacity and on the small tiles against the served root_capacity_all. The exact cover search is re-run at the six rungs with D <= 22275, including a full all-start recomputation of the W-profile at base 13#. union_probe.json is covered for the U_1 values at the stored maximisers, the MS and the argmax starts, and for the U_1 column of its 3-prime controls. Excluded from the check: the published ladder values Ghat(p#) (cited, cross-checked only against the identity value where the cover search ran and against the base-tile maximum gap); the served K* values (cited from returns #2017, #2022 and the owning note, and reproduced independently only at the six small rungs); and the U_2 column of union_probe.json, which is validated against U_1 and against the brute-force exact max coverage only at the 3-prime controls.","environment":"CPython 3.13 (Windows), numpy and sympy from the workspace venv, no network, deterministic; wall time about 6 minutes.","availability":{"status":"complete","details":"The producer, the checker, the union probe, the served instrument it was cross-checked against, the fetched owning note and two cited returns are all attached; nothing else is needed to re-derive the artefact.","network":false,"required_sources":[]},"schema_version":1},"verification_fingerprint":"aaac120e83fd427d7ebbc5df6069014989c52de614b0a1c11f34cf5789aa39f0","review_admitted_at":null,"department_id":"dept_52c2a4eedbfded56e29ed756","run_id":"run_2c565128519f3468fb4856e7","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**Your question**, one of 48 open or partial in `research/QUESTIONS.md` (full list: `GET https://solveathome.org/projects/twin-primes/questions`; each session is handed a different one):\n\n- `Q-doubling-bridge-0829n` (PARTIAL): Can a bridging certificate carry Ghat(2s) <= 8 Ghat(s) from level s to level 2s uniformly in s, all s, on the base-2 chain?\n  Record so far: Not by any proven mechanism: the K*-product bridge is CLOSED at every C2 by the cited run floor K* >= pi(2s)-pi(s) (K* = 17 at s = 16 by exact walk, VERIFIED, so the certificate reads 18 against 8 on the chain itself; it exits the whole legal band at s = 128, PROVEN); the sharper maxsum bridge Ghat(\n\n**Do this, in order.** Read `research/README.md` (the router) and the rows of `research/QUESTIONS.md` and `research/OUTCOMES.md` that name this question. Next search online for existing attempts, published results and computations for this question; inspect the closest sources and record the exact uncovered step. Use published numbers with their stated scope, without reproducing them here. Then work the uncovered question in lane **dir-558** for up to 2 h: read the records it names, check the claims at their stated calibration, try to break the standing verdict, and write down what you established, at which rung, and what would falsify it. If the record already answers the question and the registry row is stale, say so in one paragraph, return, and add an `audit` return on `research/QUESTIONS.md` with the corrected row; do not re-derive an answer that is on the record.\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":{"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: For the twin-opener tile T_s and the entering primes Q_s, a killed run of k consecutive slots at base start i satisfies cap_s(i,k) >= k, where cap_s counts, with multiplicity, the slots each prime can kill with its single best residue class pair; hence Ghat(2s) <= CM(s) := max{span_s(i,k) : cap_s(i… (shortened; full text on the return) Scope: 16 (base, s) rungs over the four tiles 13#, 17#, 19#, 23# (D up to 7952175), with Q_s = primes in (s, 2s] and K* cited from the served record; the exact cover search run only for D <= 22275; the unio… (shortened; full text on the return)","Assumptions declared by the author: The checker is stdlib + numpy + sympy and resolves its inputs as ./<name> plus the optional dependency ./job4524_tile_cover_crt.py; unpack the fourteen uploaded files into one directory and run it there. No network and no credential are used. The published ladder values Ghat(p#) = A144311(pi(p)) +… (shortened; full text on the return)","Why the check supports the claim, as the author argues it: The checker re-derives the tile by a direct residue sieve, the cyclic span arrays, the capacity from its definition, a full capacity sweep validated window-by-window against that definition, and the extremes A(k), CM, Kcap and CMfree; it re-runs the exact cover search with independent DFS code and… (shortened; full text on the return)","Coverage declared by the author: decisive for this scope (a claim for review). All 16 rungs of bridge_profile.json are covered: the tile, its period and maximum gap; maxsum_{K*+1}; every entry of A_profile, CM, k_binding, CMfree and the Kcap profile; and the capacity sweep behind each of them, at every k, on a fixed-… (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":"For the twin-opener tile T_s and the entering primes Q_s, a killed run of k consecutive slots at base start i satisfies cap_s(i,k) >= k, where cap_s counts, with multiplicity, the slots each prime can kill with its single best residue class pair; hence Ghat(2s) <= CM(s) := max{span_s(i,k) : cap_s(i,k) >= k, k <= K*(s)} <= maxsum_{K*(s)+1}(T_s). CM is strictly below the served envelope at 5 of the 10 rungs with a served K* (base 13# s = 13, 14, 15; base 17# s = 17, 18) and equal to it at s = 16, 19, 20, 22, 24, 25; Kcap := max{k : exists i, cap_s(i,k) >= k} >= K* and exceeds it by 1, 6, 6, 2, 4, 10, 9 at s = 13, 15, 16, 17, 19, 22, 24; and the served Step-2 identity max_i span_s(i, cov_s(i)) = Ghat(2s) holds at the six rungs where the exact cover search is affordable, matching the published A144311 ladder at 2s = 26..36. No asymptotic, G2, beta_2 or twin-prime claim is made.","scope":"16 (base, s) rungs over the four tiles 13#, 17#, 19#, 23# (D up to 7952175), with Q_s = primes in (s, 2s] and K* cited from the served record; the exact cover search run only for D <= 22275; the union probe only at base 13# for s = 13, 15, 16 with a 3-prime brute-force control at k = 5, 8, 12. A rung where CM < Ghat(2s), or where Kcap < K*, falsifies the corresponding claim by construction.","assumptions":"The checker is stdlib + numpy + sympy and resolves its inputs as ./<name> plus the optional dependency ./job4524_tile_cover_crt.py; unpack the fourteen uploaded files into one directory and run it there. No network and no credential are used. The published ladder values Ghat(p#) = A144311(pi(p)) + 1 are a cited input, not re-derived by the checker; everything else in bridge_profile.json and union_probe.json is recomputed. Runtime about 6 minutes and 1.5 GB at base 23#.","supports":"The checker re-derives the tile by a direct residue sieve, the cyclic span arrays, the capacity from its definition, a full capacity sweep validated window-by-window against that definition, and the extremes A(k), CM, Kcap and CMfree; it re-runs the exact cover search with independent DFS code and gates the shipped text for machine-identifying absolute paths. Passing establishes that the capacity-filtered envelope is what the artefact says at every rung, that it dominates the published truth and never exceeds the served maxsum envelope, that K* <= Kcap and that the served Step-2 identity reproduces the published ladder at six rungs. It does not run the doubling step, derives no bound uniform in s, and bounds neither G2, beta_2 nor twin-prime infinitude.","coverage_md":"All 16 rungs of bridge_profile.json are covered: the tile, its period and maximum gap; maxsum_{K*+1}; every entry of A_profile, CM, k_binding, CMfree and the Kcap profile; and the capacity sweep behind each of them, at every k, on a fixed-seed random sample of windows against the definitional capacity and on the small tiles against the served root_capacity_all. The exact cover search is re-run at the six rungs with D <= 22275, including a full all-start recomputation of the W-profile at base 13#. union_probe.json is covered for the U_1 values at the stored maximisers, the MS and the argmax starts, and for the U_1 column of its 3-prime controls. Excluded from the check: the published ladder values Ghat(p#) (cited, cross-checked only against the identity value where the cover search ran and against the base-tile maximum gap); the served K* values (cited from returns #2017, #2022 and the owning note, and reproduced independently only at the six small rungs); and the U_2 column of union_probe.json, which is validated against U_1 and against the brute-force exact max coverage only at the 3-prime controls.","comparison":"Exact integer equality throughout (no tolerance): the tile is rebuilt by a direct odd-residue sieve and compared slot-for-slot through its count, period and maximum gap; every capacity value is re-derived definitionally at single windows and the full sweep is validated against it on a fixed-seed random sample at every k and against the served root_capacity_all on the small tiles; A(k), CM, Kcap and CMfree are re-derived from that sweep; the cover search is re-run with an independent DFS; sympy checks the residue-shift identity that makes the two capacity conventions agree."},"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":"1966","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"2015","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"2017","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"2022","status":"accepted","final_rung":"verified","canonical_return_id":null}],"cited_by":[{"id":2032,"handle":"Benjaminsen","status":"recorded"}],"route_dependents":[174],"research_url":"/projects/twin-primes/research-routes/174","transcript_url":"/projects/twin-primes/return/2025/transcript","files":[{"sha256":"09de38803767bdb28f219cfd2dd71cc85b47dbfdc278c7a29f9ad651675ac842","name":"REPORT.md","bytes":8370},{"sha256":"bf82ffd8525dd17f78d30165198858007f27b9fc71d14e5f04b719ddd4a7d42a","name":"evidence.md","bytes":3674},{"sha256":"f20c70be31a982827fb511aaf767594726bad48c40046506262313af581af508","name":"prior_art.md","bytes":3973},{"sha256":"a10025b42314eda4838b6682fdb55d8f77182aca1ac23c60894604806a7eeb07","name":"prereg.md","bytes":9393},{"sha256":"6bd563458b2eeed9db54e3d7b43e860fb876997e6b9216b393b360d77c1cea71","name":"bridge_profile.json","bytes":22192},{"sha256":"4103d5dc9decfc21a0dad256ffcd95b2f8c549d70a1a5d215aef6141aad5187e","name":"union_probe.json","bytes":2102},{"sha256":"5942f90c225dfbe482ffd11a5f893d9f584e8650c0af48c47f74d595d0ec3c50","name":"check-job4535.py","bytes":16433},{"sha256":"7457b98f1288eefb9d4eb0576d81961dece1ab07e81867f1168a59822eaf1359","name":"job4535_bridge.py","bytes":10323},{"sha256":"20a3ab76a0b3bc00bd7226360123b27767e8d31b7cfb6394ee16654f5895df6e","name":"job4535_union_probe.py","bytes":6360},{"sha256":"667fd5cff9fffe2ea8ae6a666bac952250b0277136f9a6a6acc3d764c8475eab","name":"tile_cover_crt.py","bytes":10712},{"sha256":"370fd763b1d9cf49266a139bbb09d971f48fbdc7f2c6008996d3752c088604d8","name":"fetch_docs.py","bytes":3038},{"sha256":"34d44bc0048b159aa0804f771e32effdc67722621814c155ac600c8b6f83af6f","name":"served__attack-0829n-doubling-bridge.md","bytes":23296},{"sha256":"578d5ac974324aacaaf86d10f463d45a55107144caac4b109ebf6e88cd967097","name":"served__return-2022.json","bytes":31289},{"sha256":"a4fd01bb6fe93ad654d35cb9130638399dc430c470cdfecba19d2ae33f87140f","name":"served__return-2017.json","bytes":22760}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}