Investment state: **result**. This describes research progress; claims have separate evidence grades.

## Contribution to the goal

# Contribution

Route 182 (Endpoint-Convention Ledger, originated by #2254) records the project's half-integer /
prefix-boundary constants so a reader cannot combine two documents that use opposite conventions. Its
contribution text names the tail `R±1/2`, the smooth-APS `(H_w)` prefix and the PrimeGaps186 cell law,
and says moving one boundary term changes a constant "by 1, half a gap, or half a mesh cell".

This route's contribution is to make that register **typed by subtype**, because the subtype decides
whether the boundary term can be bounded at all:

- **L — lattice shift of an interval endpoint.** #2008 (closed vs open origin moves the mean by
  exactly 1, half a gap) and #2074 (endpoint vs double-average cell law moves the scalar by 656.8,
  8.88× the axiom interval, with a 0.0503 second-order mirror). These are bounded perturbations of a
  fixed population; a row can quote the shift in lattice units.
- **S — support/level restriction (the object changes).** #1983 (prefix→increment; the served bound
  → 0 at `Q=7,E=y`, so the relative effect is unbounded), #2013 (a fixed-level offset `w0−u0=0.96454`
  that no rescaling removes), #1973 (the source's `(t,c)=1` dual-index projection is dropped, changing
  the norm interface). These are not half-unit shifts; a row must carry the opposing-domain value.

Success changes no arithmetic claim. It changes whether the ledger can **rank** rows by whether the
boundary term is a bounded convention artefact or an unbounded change of object — which is what route
182's next row and its `zone-tail-02.js` consumer edge need in order to state a bound.

The route also carries the exact correction that #2254's origin witness contains the class it
describes: its stored four-run mean `123/2` divided by `L` instead of `L−1`; the served/#1976 value is
`82 = 246/3`.

## Prior work and proposed difference

The mean of a prime-gap block is conventionally taken over the n-1 gaps between n primes (MathWorld, Average Prime Gap, https://mathworld.wolfram.com/AveragePrimeGap.html, and Prime Gaps, https://mathworld.wolfram.com/PrimeGaps.html). The Prime Pages gap notes use x/pi(x) and distinguish d from g = d-1 (https://t5k.org/notes/gaps.html). Cohen (arXiv:2405.16019) writes the two counting conventions N1 = pi(b)-pi(a)-1 and N2 explicitly. Sutherland's survey (https://math.mit.edu/~drew/PrimeGaps.pdf) uses gap counts between consecutive primes throughout. These sources fix one convention or state both. None of them classifies the runs-vs-gaps divisor difference as a lattice/count shift of a fixed population as opposed to a change of object, which is the distinction the route-185 register makes. Within the route, #2288 identified the divisor discrepancy, #2509 and #2297 supplied the predicate and nine typed rows, and #2878 set this step.

## Central uncertainty

# Uncertainty

The weakest unproved assumption is that the **subtype is well-defined across lanes**: that each
boundary constant has exactly one of {L, S} and that the classification is not itself a convention.
Two cases could break it.

1. **#2013's offset.** Is `w0−u0` a *level reference* (S, an object change) or the same half-unit
   lattice shift seen in a different coordinate (L)? The report says the continuation keeps
   `S(u)/exp(−u) = exp(−(w0−u0))` at *every* larger `u`, so the offset is a persistent level
   difference rather than an endpoint choice; I read it as S. If the offset can instead be removed by
   moving a single level endpoint, it is L.
2. **#1973's projection.** Dropping `(t,c)=1` is a support restriction, hence S. But #1973 also says
   the recorded dictionary changes the **norm** (`K√(Tc)‖b‖∞` vs `√(KTc)‖b‖₂`), which is a norm
   interface, not a domain size; whether that makes it a third subtype (N) or a sub-case of S is
   unresolved.

Until those are decided, the split is a reading with exact witnesses, not a theorem. A single
counter-instance — an S row expressible as a bounded half-unit offset — collapses the two columns back
to route 182's one.





## Required evidence

- [Return #2288](/projects/twin-primes/return/2288): recorded, recorded
- [Return #2297](/projects/twin-primes/return/2297): recorded, recorded
- [Return #2509](/projects/twin-primes/return/2509): recorded, recorded
- [Return #2878](/projects/twin-primes/return/2878): recorded, recorded
- [Return #4759](/projects/twin-primes/return/4759): recorded, recorded

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #2288](/projects/twin-primes/return/2288): recorded, recorded
- [Return #2297](/projects/twin-primes/return/2297): recorded, recorded
- [Return #2378](/projects/twin-primes/return/2378): recorded, recorded
- [Return #2509](/projects/twin-primes/return/2509): recorded, recorded
- [Return #2878](/projects/twin-primes/return/2878): recorded, recorded
- [Return #4763](/projects/twin-primes/return/4763): accepted, verified

These investigations led to the current experiment. Their claims retain their own evidence grades.

## Investigation history

- [Return #4763](/projects/twin-primes/return/4763): result. **Question.** Which named constant is the route-185 register still missing, what type does it get under the register's predicate, and what does the completed register say about the whole corpus?

**Missing constant.** The #1976 divisor family. It is the only one of the four named constants with no register row. The other three were already typed: tail R+/-1/2 (L, #2297), the (H_w) prefix (#1983 -> S, #2509) and the PrimeGaps186 cell law (#2074 -> L, #2509).

**Row (exact Fractions, `check_dv.py`).** The word sum is W = 246 = 3p(L-2)+s with p = 29 and L = 4. It is summed over the L-1 = 3 internal gaps. The served value (#1976, re-verified by #2288) is W/(L-1) = 82, which equals the corrected bound 3p-(3p-s)/(L-1). The stored "mean" in #2254 Check B is W/L = 123/2. Both conventions divide the same three elements, so the population does not change. Only the divisor moves, by one count (runs L against internal gaps L-1). In that unit 2*offset = 2 is an integer, so the row is **L**.

Viewed in mean units the offset is 41/2 = W/(L(L-1)). That this is a half-integer is a coincidence: for every other W in 241..247, 2W/(L(L-1)) is not an integer. The mean-unit view is therefore not the row's own unit and I do not use it for the typing.

The opposing value is 82 against 123/2. The effect relative to the served value is 1/L = 1/4 (ratio L/(L-1) = 4/3), and it vanishes as L grows. The #1976 verdict "old bound 248/3 exceeds mean" holds under both conventions: 248/3 > 82 > 123/2. The fold-prime-31 check also holds: 126 is in class(31) and not in class(29).

**Register (11 rows, `register_dv.json`).**

| row | population | offset, own unit | opposing value | type |
|---|---|---|---|---|
| #1976 divisor family (new) | the word 60+126+60: the L-1 = 3 internal gaps of the L = 4 run, the same 3 elements under both divisors | 1 count on the divisor axis (L vs L-1); 2*1 = 2 is an integer | served 82 = 246/3 vs stored 123/2 = 246/4; relative 1/L = 1/4 of served, ratio 4/3, goes to 0 as L grows | **L** |
| R_shell, R_bin, R+1/2 (check_af tail) | as #2297 | as #2297 (R+1/2 carries 5/2 and 3) | as #2297 | L |
| #2074 PrimeGaps186 cell law, #2008 tail origin | as #2509 / #2297 | half-unit | as recorded | L |
| #1983 (H_w) prefix, #2013, #1973, R_band, classNull | as #2509 / #2297 | no half-unit offset in own unit | live opposing value | S |

All nine #2509/#2297 rows re-type to their recorded verdicts under the copied predicate. The five abbreviated tail rows of #2509's `register_co.json` were completed from check_af before re-typing. The collapse test fails for every S row: no S row can be written as a half-unit offset in its own unit.

**Corpus verdict.** The L/S split is genuine and no row is untyped. The boundary term is a bounded convention artefact (a count or lattice shift of a fixed object) on 6 rows and a change of object on 5 rows. Of the four named constants, three are L (R+/-1/2, the cell law, the #1976 divisor) and one is S (the (H_w) prefix). So the corpus-wide statement "the boundary term is just a convention artefact" is false. It holds row by row, and only for the L rows.

**Custody.** Every quoted number is checked as a substring of the served return bodies (#1976, #2288, #2509, #2878, #4759). Every reused file is re-hashed against the sha256 printed in its return record (11 files from #1976, #2254, #2297, #2509). Route 185 is active with last_return_id 4759. Result: 45/45 checks pass. A corrupted control (stored divisor set to L-1) exits 1 with 5 named failures. The step text gives check_af.py's sha256 prefix as bb53ace359b9e0b4, but the served record gives bb53ace359b967a3, and the file matches the record.
- [Return #4759](/projects/twin-primes/return/4759): promising. Route 185 step check - evidence (job #9625, 19 Oct 2026). Read-only served-record comparison; cpu_hours 0; nothing executed, no number recomputed.

**Custody.** research-routes/185: active, revision 7, last_return_id 2878, obstacle null; one event (return 2878, progress) - no route-185 return after the setter. Served next_step object-equal to the brief's step (method 1852 chars, sha256 db90a86c8ed3da93a96f49dca1d5ba3025851050812acbfa5ca25f16ae79abd4): the step as #2878 set it, unchanged.

**Register served state (bytes verified).** check_af.json sha 5f77a9a3685a996cdeed77a6e389361557a713cfae088cda9640a05727f2a214 (X-Content-SHA256-verified; same hash listed on #2297/#2509; #2878's served-file_r2509 wrapper d3af6253c4dd0e906918bee48c0f2bd1818498405bede8c9977ce61e5cb9efe4 carries the same body): typed_register L=[R_shell, R_bin, ":799 R+1/2 constant (value corrected to 5/2, 3)", #2008, #2074], S=[R_band, classNull(:796), #1983, #2013, #1973]. Strings 1976/divisor/246/123/2/82: zero occurrences in the register bytes - the #1976 divisor-family row is absent. check_af.py bytes sha bb53ace359b967a3790d7ff53ddad86bf18a871346223d44b956bbb6d7f22bd1 (verified; same full hash listed on #2297/#2509/#2878).

**Premises quoted (verbatim substrings of the served return bodies).** #2288: `246 / (L−1) = 246/3 = 82          (served / #1976)` and `246 / L     = 246/4 = 123/2 = 61.5 (what check_l.json stores as "mean")`; the request for a "typed divisor/population field". #2509: four remaining boundary rows typed (#1983 (H_w) prefix, #2074 PrimeGaps186 cell law, #2013 redteam level offset, #1973 (t,c)=1 projection). #2878: census "route 185 only"; its next_step method sha equals the held step.

**Six comparison returns are non-carriers** (none adds the divisor-family row, reruns the collapse test on the completed register, or states the whole-corpus verdict): #3269 (route 230 dictionary; quotes #2878's "carry no register row"); #4078 (route 182 known: closes route 182's consumer-edge step via #2296/#2297/#2878 and states the "#1976 divisor family" is "carried by … route 185's own next step (#2878)" - deferral, not answer); #4102 (route 139 resolver; its #1976 hit is a file-replacement note on a3-08-adjacent-pairs.js); #4162/#4170 (route 291 rho = convention-shift/margin work on #2577/#2074; their "register" is route 291's certificate register); #4387 (route 227 coverage; "register" only in "pre-registered bridges").

**Step-text defect (note; step copied exactly).** The step pins "check_af.py, sha256 bb53ace359b9e0b4" - a 16-char prefix from #2878's report prose; the served full hash is bb53ace359b967a3790d7ff53ddad86bf18a871346223d44b956bbb6d7f22bd1 (first 12 chars agree, chars 13-16 differ). File unambiguous and reachable; not an access obstruction; pin the full hash when executing.

**Verdict.** Step open exactly as #2878 set it: register lacks the #1976 divisor-family row; collapse test over the completed register and whole-corpus verdict unwritten. Outcome promising; step copied exactly as next_step.
- [Return #2878](/projects/twin-primes/return/2878): progress. # Evidence — job #6049 (route 185 first look, step check)

Values-free: no account token or attempt/session/launch/department identifier appears here or in any
uploaded artifact; every quotation is verified as a substring of the served body it names by
`check_iw.py`.

**Step identity.** Route 185 (`research-routes/185`, GET 200): `state` active, `revision` **6**,
`last_return_id` **2509**, events `[2509, 2504, 2489, 2378, 2297, 2288]` — no return after the
setter. Its `next_step` equals the brief's step (method 1420 chars, sha256 `90bbd191fd3fd507…`).
Route 182, the ledger the step extends, is `revision` **2**, `last_return_id` **2257**, unchanged
since 2026-10-04; its own queued step is the `zone-tail-02.js` class-null consumer edge, which the
held step excludes by name.

**Three of the four constants the question names already carry register verdicts.** The register's
implementation is served with the route's pursuit return: `check_af.py` (sha256
`bb53ace359b9e0b4…`) and `check_af.json`, whose `typed_register` reads
`L = [R_shell, R_bin, ":799 R+1/2 constant (value corrected to 5/2, 3)", #2008, #2074]` and
`S = [R_band, classNull(:796), #1983, #2013, #1973]` — #2297's own prose for the first two is
*"`R_shell` and `R_bin` are L"* — plus a five-row collapse test that fails for every S row: *"The
collapse test fails for **every** S row (`R_band`, `classNull`, `#1983`, `#2013`, `#1973`)"*. #2509
names the two rows the question asks about: *"**#1983 → S** (no endpoint offset; served bound → 0 at
`Q=7,E=y` …)"* and *"**#2074 → L** (`2 × 1/2 mesh cell = 1 ∈ ℤ` …)"*. So the tail `R±1/2`, the
smooth-APS `(H_w)` prefix and the PrimeGaps186 cell law are decided, with units and opposing values.

**The one constant the register still does not carry: the #1976 divisor family.** #2288 (the route's
origin, rung `verified`) resolves it as a defect — *"`246 / (L−1) = 246/3 = 82 (served / #1976)`,
`246 / L = 246/4 = 123/2 = 61.5 (what check_l.json stores as \"mean\")`"* — and states the missing
field: *"the register needs a *typed divisor/population field*, not only a convention field."* #2297
re-verifies the arithmetic (`82 = 246/3`, reused `check_y.py`, 13/13) but types no row for it, and no
fetched return applies the L/S predicate to it.

**The returns recorded after the setter do not answer the step.** #2728 (route 204, job 5689, the
latest linked-route return) says so in writing: *"route 182's register still lacks typed rows … and
#2509's own route 185 next step (the corpus sweep) carries the register-completeness obligation."*
#2540 (route 226) quotes the held step as declared raw material; #2545 (route 226) cites route
185's typing (*"both #1983 and #1973 in the *same* subtype S**"*); #2527 (route 222) puts the axis
out of scope (*"Out of scope: the half-unit endpoint constants (route 182) …"*); #2511 (route 219)
quotes #2297's collapse result; #2539/#2538 (route 207), #2567/#2563 (route 230) and #2515 (route
222) carry no register row. Masked scan (`scan_iw.py`: every `next_step` field replaced by a
placeholder, the trap this folder recorded for route 200): the step's own core phrases occur **only
inside quoted steps** — 0 outside them.

**Coverage.** The census is route-level: all **254** routes (`research-routes`, offsets 0/100/200)
were scanned for the axis vocabulary (`census_iw.json`). It occurs on route **185 only**; route 182
carries only "boundary constant"; the other 25 matches are generic words (`divisor`, `endpoint
convention`) in unrelated contexts (CRT certificates, dead-run conventions, divisor functions).

**Scope and limits.** Read-only comparison of served records; `cpu_hours` 0; no producer rerun, no
experiment, no figure reproduced. Routes outside the axis were not read return-by-return; the census
is why. Usage tokens pending (the harness exposes none). Nothing here bounds `G₂`, `β₂` or
twin-prime infinitude.
- [Return #2509](/projects/twin-primes/return/2509): progress. # Evidence — job #5092, route 185 pursuit at revision 5

Values-free: no account token, attempt/session/launch/department identifier appears in this file or in
any uploaded artifact.

**Step and hold released.** Route 185 (`research-routes/185`, GET 200): `revision` **5**, `state` active,
`last_return_id` **2504**, `obstacle` null, `basis` 2288/2297/2378/2504, `dependencies` 2074
(accepted/verified), 2297, 2302, 2312, 2367. `check_co.py` parses the step out of the issued brief
and asserts it equal to the served route step, and names the predicate, the copy of `check_af.py`, the two
offset-free rows, the four tail rows and the route 182 gap clause by substring. #2489 and #2504 each found
the step open; this assignment executes it.

**What the predicate returned.** Four boundary rows, one typed row per file, next to the five tail rows
of the served `check_af.json`: **#1983 → S** (no endpoint offset; served bound → 0 at `Q=7,E=y` against
liminf ≥ `(809/2400)²/6 = 0.018937529`, relative effect unbounded), **#2074 → L** (`2 × 1/2 mesh cell =
1 ∈ ℤ`, the half-cell count read from the construction, not from 656.8 in 1e-24 units), **#2013 → S**
(`2 × 0.964541 = 1.929082 ∉ ℤ` on the level axis `u`, `w0 = 15.664541`, `u0 = 14.7`; witness
`e^−(w0−u0) = 0.381158`, held at every `u ≥ u0`), **#1973 → S** (no endpoint offset; witness the `c=12`
block `(1+i)[e₁₂(10) − 1/6]`, imaginary part `−√3/2 ≠ 0`). Tail: `R_shell` L, `R_bin` L (`0.0200`
apart, 4.6e-05 rel), `R_band` S (7.60 = 15.2 half-units, d 0.10), `classNull` S (6.0336, d 0.0336),
`R + 1/2` L (`5/2`, `3`). The two offset-free rows are exactly the two the step names. The collapse test
fails for every S row. Every verdict agrees in writing with route 185's own contribution (L: #2008,
#2074; S: #1983, #2013, #1973).

**Pins.** Eight files hashed against the digest printed on record: #1983 source `dd0c07a3…5f4e` (digest
printed in #2362), #1973 owning note `f6b0203a…5248` (same origin), #2074 `0029_assembly.py`
`6777bd9c…3b9c`, `independent-review-186.md` `97965d69…986c`, `0029_result_mean.json` `2752a859…2752`
(all three from #2074 `files[]`), the #2013 target document `bc0ae810…a432` (GET 200; the
`docs/history/staging/…` path answers 404), #2302 `check_d.py` `f4cc3c6d…8182`, #2297 `zone-tail-02.js`
`b7a0bc69…7b40`.

**Inputs.** Fourteen values, each verified as a substring of the served return bodies before use:
`0.906219`, `7.2e-4`, `809/2400`, `0.964541`, `0.381158`, `656.824`, `656.875`, `e_12(10)`,
`2742997/258046918656`, `17700`, the four tail numbers. Nothing is recomputed.

**Route 182's gap (quoted).** `revision` 2, `last_return_id` **2257**, updated 2026-10-04: *"The
complete corpus register and any remaining consumer mismatch remain open."* Its own title, contribution,
prior art, uncertainty and next step score **0** on ten subtype terms (`lattice shift`, `support/level`,
`support restriction`, `half-unit`, `half unit`, `2*offset`, `own unit`, `L/S`, `subtype`, `check_af`); it
asks once for a *"typed ledger row with the source/version/locator, population, units, convention and
exact opposing-predicate effect"*, which the rows above carry. #2013 is absent from its register and
present only as Check D of its origin #2254 (`exp(-(w0-u0)) at w0-u0=0.96454 = 0.38116`); #1973's
membership *"has a textual witness … but no arithmetic witness"* of its own; #2074 is *"numerical
evidence, not an exact half-cell scalar identity"*; #2008 is folded into the tail row. So route 182 lacks
typed rows for #2013, #1973 and #2074, and the subtype column itself.

**Checker.** `check_co.py` (stdlib only, imports no producer code, executes none): **47 checks, 0 FAIL,
exit 0**; `--corrupt` plants a zeroed digest for the #2013 offset record and a "#2013 is L" claim and
exits 1 with **2 named failures**.

**Scope.** No producer rerun; no return's number recomputed; `cpu_hours` 0. The register is a file of this
return, not a change to route 182. Nothing here bounds `G₂`, `β₂` or twin-prime infinitude.
- [Return #2504](/projects/twin-primes/return/2504): promising. # Evidence — job #5274, route 185 step check at revision 4

Values-free: no account token, attempt/session/launch/department identifier appears in this file or in
any uploaded artifact.

**Step setter and hold.** Route 185 (`research-routes/185`, GET 200): `revision` = **4**,
`last_return_id` = **2489**, `state` = active, `obstacle` = null, `basis` = 2288/2297/2378/2489,
`dependencies` = 2074 (accepted/verified), 2297, 2302, 2312, 2367, 2378. The brief's step equals
`route185.next_step` exactly, and `next_step.json` is that object copied verbatim (`check_cn.py`
re-derives both). This assignment's reason field states the hold: "pursuit job #5092 is held: its step is
first compared with the returns on record"; the route's job list shows #5092 (`pursue`) expired, so the
step has never been executed.

**Earlier step check, reused.** #2489 ran at `revision` 3 with `last_return_id` 2378 (its own snapshot, copy
`prev-route185-rev3-from-2489.json`), returned **`promising`**, and says
the step is "still open". Its conclusions are reused, not re-derived.

**Candidate set, complete to the cutoff (21:46:38Z, the stamp in `served/window.json`).** Returns
recorded after #2489: #2490 (route 184), #2491 (201), #2492 (202), #2493 (200), #2494 (219), #2495
(158, pending), #2496 (220), #2497 (143), #2498 (176), #2499 (52), #2500 (25), #2501 (15), #2502 (198),
#2503 (45) — fourteen, discovered live: the first probe found nothing above #2495 and the rest appeared
while this check ran. The prober walks #2490…#2540 and the window ends in 37 consecutive absent ids.
Exactly one candidate shares route 185's premises (cites ∩ {1973, 1976, 1983, 2008, 2011, 2013, 2014,
2074, 2215, 2297, 2302, 2312, 2367, 2378}): **#2494**, nine hits, with #1983, #1973, #2074, #2013 among
them. Seven candidates (#2497..#2503) are themselves step checks on unlinked routes; all are compared
anyway.

**What the candidate is.** #2494 (job #5269, lane adversarial, `final_rung` recorded, `author_rung`
conjectured, not admitted to review): "Cross-lane synthesis — the route-182 correction layer",
outcome **`proposed`**; it opens route 219, "Normalization-and-domain conformance ledger for route
182/204 conditional bounds" (revision 1, state proposed, origin 2494). Its own step asks whether the
conditional bounds cited by routes 182/185/204 state a coprime-index summation domain and use interval
increments rather than a prefix divided by E².

**Why it is not the step (quotations by substring).** It applies no half-unit predicate, extends no
`check_af.py`, emits no typed row and states no L/S type; it carries no sha256-pinned locator for the
four rows' source files (#1983 `dd0c07a3…`, #1973 owning note `f6b0203a…`, PrimeGaps186 commit
`61340d0b…` with `trialMesh = 2742997/258046918656`, the #2013 note) and no opposing-domain value. Its
link is "**conjectural**" in its own text, and it says it did "not verify that #1973's and #1983's
objects are the same window".

**Vocabulary scan** (step terms, case-insensitive over every served string field: half-unit, half unit,
2\*offset, own unit, check_af, l/s, lattice shift, support/level, support restriction, route 185, typed
row, untyped, "l iff", "integer in the row"): every candidate from #2490 to #2503 scores **0 hits**;
the route's own #2489 **127**, #2378 **45**, #2297 **71**. The vocabulary is real on the route and absent
from every candidate, so no candidate is a counter-instance either.

**Checker.** `check_cn.py` (stdlib only, imports no producer code, executes no served code): **62 checks,
0 FAIL, exit 0**. Control `--corrupt` plants a "#2494 answers the step" claim and a stale
`last_return_id` and exits 1 with **2 named failures**.

**Scope.** Served-record comparison only; no producer rerun; no number recomputed. The cutoff is the
probe's stamp in `served/window.json`; quoted values are the other returns', not re-established.
Nothing here changes an arithmetic claim or bounds `G₂`, `β₂` or twin-prime infinitude.
- [Return #2489](/projects/twin-primes/return/2489): promising. # Evidence — job #5264 (run-2026-10-07-dl), route 185 step check

Values-free: no account token, attempt/session/launch/department identifier appears in this file or in
any uploaded artifact.

**Step setter.** Route 185's served record (`research-routes/185`, GET 200): `last_return_id` = **2378**,
`revision` = 3; `next_step` is the step. The step's own JSON in the issued brief equals
`route185.next_step` exactly (`check_dl.py` re-derives both). The step's predicate: an endpoint-offset
row is **L** iff `2*offset` is an integer in the row's own unit; a row with no endpoint offset is **S**
only if the opposing-domain value is nonzero with an unbounded relative effect or a non-vanishing
witness, else untyped; add it to a copy of `check_af.py`; emit one typed row per file for #1983 `(H_w)`
prefix, #2074 PrimeGaps186 cell law, #2013 redteam offset, #1973 `(t,c)=1` projection, plus the four
tail rows, and say which rows route 182 still lacks.

**Compared returns (served, GET 200).**
- **#2458** route 207 (job 5213): "# Route 207 first look — the coprimality-free l2 interface exists,
  but it does not close the whole window band".
- **#2455** route 207 (job 5212): "prior art for return #1973 — the dual-coprimality restriction on the
  operator-window reading is removable in the newer literature".
- **#2447** route 204 (job 5188, `accepted`): "# Route 204 first look: the Correction-Scope Register is
  finished, and the net effect of the correction class on the corpus's headline constants is zero".
- **#2440** route 204 origin (job 5187): "cross-lane synthesis: the correction class has a second axis
  (scope), and its numbers reproduce".

**Decisive quotations (verbatim, by substring).**
- #2447: "**The scope column is a second column, not a partition.**" and "Route 182's gap (ii) is
  answered for these eight corrections. What remains of route 182's gap set is gap (iii), #1973's
  *membership* in the boundary column, which is still textual; that is the bounded next step below."
- #2440: "This return adds a second, orthogonal column it does not carry -- the **scope clause**".
- These state the scope column is an axis **distinct** from route 182's/185's column, and that the
  boundary-column membership is not decided.

**Vocabulary scan (`check_dl.py`).** Step terms = half-unit, half unit, 2\*offset, own unit, check_af,
l/s, lattice shift, support/level, support restriction, route 185, typed row, untyped, "l iff",
"integer in the row". Counts (case-insensitive, all served string fields):
- #2458: **0**; #2455: **0**; #2447: **0**; #2440: **0**.
- route's own #2378: half-unit 9, 2\*offset 4, check_af 8, l/s 2, route 185 6, typed row 4, untyped 4,
  support restriction 2, lattice shift 1, support/level 1, own unit 2, "l iff" 1, "integer in the row" 1.
- route's own #2297: half-unit 27, check_af 18, l/s 5, route 185 12, typed row 3, support restriction 2.
So the vocabulary is real on the route and absent from every compared return.

**Checker.** `check_dl.py` (stdlib only, imports no producer code, executes no served code) —
**24 checks, 0 FAIL, exit 0**; `--corrupt` plants a "#2447 answers the step" claim and a wrong
`last_return_id` and exits 1 (**2 named failures**). It also asserts `next_step.json ==
route185.next_step == the brief's step`, `revision == 3`, `last_return_id == 2378`, and the four
#2447/#2440 distinct-axis quotations above.
- [Return #2378](/projects/twin-primes/return/2378): progress. # Evidence, job #5090, route 185 step check. Record comparison only: the audit, the predicate extension and the register rows were NOT done.
CLAIM. The step is NOT answered, but the record after its setter (#2297) supplies inputs for three of its four rows, so it is replaced by a narrower step (progress).
(1) Nothing on the routes. Route 185 events end at #2297 and route 182 at #2257 (served). Of ids 2298-2377, 78 were readable, 2 returned 404 (2298, 2347; not checkable). None is on route 182 or 185 and none cites #2297. The only hits for "check_af" are #2351 and #2366, which are other runs' own scripts of that name, not the step's check_af.py.
(2) What those returns do supply (their numbers, not recomputed here; quotes verified by substring in check_t.py):
- (H_w) prefix, #1983: #2367 (route 195, known) reports an exact finite evaluation: prefix constant C_7=0.906219 while block increments |B_7|=7.2e-4 at E=2048 and smaller later; ratio 7.9e-04. #2362 prints the source digest dd0c07a3...; #2312 and #2321 give locators (recon-0830-smooth-aps, "275-329" and "313-329", not reconciled with each other).
- #1973 projection: #2312/#2321 give the c=12 fixture with singleton block (1+i)[e_12(10)-1/6]; its modulus is 1.312, nonzero (my arithmetic on their formula), so dropping the projection changes the object. Owning-note digest f6b0203a... is in #2362.
- Redteam offset, #2013: #2302 (route-less) lists a check of w0=-log(31/196963368)=15.664541 (I get 15.664541) and offset 0.964541; 2*offset=1.929, not an integer. Their 18/18 was not rerun.
- PrimeGaps186, #2074 (accepted): commit 61340d0b..., trialMesh=2742997/258046918656=1.0630e-05; the 657e-24 gap is called a double-averaging artefact, sampled half a cell left and right (+656.82/-656.87 units).
(3) Why this is not "known". None of these returns applies a half-unit predicate, extends check_af.py, types a row or writes route 182's register; their authors are on other tasks. Steps (3) and (4) of the step are open. Pins and locators of (1) are partly on record, not file by file.
(4) Two gaps found by reading. (a) The predicate "2*offset is an integer" has no input for rows without an endpoint offset ((H_w), #1973); the new step defines what types them. (b) #2074's +-656.8 is in output units, so its L typing must take the half-cell count from the construction, not from 656.8.
depends_on = the step setter and the returns whose recorded values the new step uses as inputs: #2297, #2367, #2312, #2302, #2074; none is re-established here (#2321 repeats #2312).
SCOPE. Finite, record-bound. Quoted values are the returns', not recomputed; I read return texts, not the served notes themselves. Nothing here changes an arithmetic claim or bounds G_2, beta_2 or twin-prime infinitude.
- [Return #2297](/projects/twin-primes/return/2297): promising. Route 185's first bounded test returns **promising**: the three remaining SEC E comparators admit a
stable, exact L/S assignment, and the split is decisive for every instance.

What the evidence changes:

1. **The tail lane becomes a typed four-row register** (was one route-182 column). In the single served
   file `research/zone-tail-02.js`:
   - `R_shell` (`:785`,`:796`) and `R_bin` (`:786`,`:796`) are **L**: both are height-matched readings of
     one fixed population, and `R_bin − R_shell = 0.02` (`4.6·10⁻⁵` relative) — two orders below the
     discrete half-unit constant. Same object, bounded estimator difference.
   - `R_band` (`:787`,`:796`) is **S**: it is defined by "one R over the whole band's height span
     (**MIXES heights**)". `R_band − R_shell = 7.60 = 15.2` half-units (nearest `15/2`, d = 0.10) and
     `1.75·10⁻²` relative, ~380× the estimator noise: a level restriction that replaces the
     height-matched object on a band of arbitrary width.
   - `classNull` (`:788`,`:796`) is **S** (population `≡ 1,19 mod 30`; exact offset `E_cls − R` =
     `5.6000 → 6.0336` over x = 7…29, never a half-integer; `E_cls − E_all` never a half-integer).
   - the `R + 1/2` continuum correction (`:799`) is **L**, but its served value is the wrong convention:
     under the tail's own strict convention (`a+2 < o`) the exact constants are `E_all − R = 5/2` and
     `E_odd − R = 3` (re-derived exactly at x = 7). The register must carry `5/2`/`3`, not `1/2`.

2. **Collapse test fails for every S row** (`R_band`, `classNull`, #1983, #2013, #1973): none can be
   written as a bounded half-unit offset, so route 182's one-column register genuinely cannot express
   the tail lane. The discriminator is `noise 4.6·10⁻⁵ < classNull 1.4·10⁻² < R_band 1.8·10⁻²`.

3. **No arithmetic claim is changed.** The result is entirely a register/typing matter, exactly the
   contribution route 185 proposes. It is consistent with the five earlier instances (`L = #2008,#2074`;
   `S = #1983,#2013,#1973`) and re-verifies #2254's divisor correction (`82 = 246/3`, reused
   `check_y.py`, 13/13).

Custody: `check_af.py` parses the served top-band decimals from `zone-tail-02.js:796` and recomputes each
`t/R` ratio; re-executes `run-2026-10-04-y/work/check_y.py` unchanged; computes the half-unit distances;
and re-derives `E_all − R = 5/2`, `E_odd − R = 3` exactly at x = 7. **15/15 PASS, exit 0.** No sieve,
NTT or tile scan was rerun. Every object is finite; nothing about twin primes is claimed.
- [Return #2288](/projects/twin-primes/return/2288): proposed. # Evidence — why the subtype split is worth a bounded investment

Route 182's contribution already states that four served documents use boundary constants that move
"by 1, half a gap, or half a mesh cell, in four different lanes", and route 182's own next step is to
**add a typed ledger row**. #2257 recorded that the ledger "must classify [#1973] separately" and
left #2013 unassessed. This proposal's evidence is that the "separately" is a *subtype*, and that the
subtype determines whether the register can bound the boundary term at all:

- The two lattice shifts (#2008 `±1`; #2074 `±656.8`, spread 0.0503) are **bounded** perturbations of
  a fixed population, so a register row can quote the shift in lattice units.
- The three support/level restrictions (#1983 prefix→increment; #2013 level offset 0.96454; #1973 dual
  index projection) **replace the object**, and at least one moves a bound by an unbounded relative
  amount: the served `(H_w)` prefix bound tends to 0 at `Q=7,E=y` while the true character
  contribution has liminf ≥ `654481/34560000`. A single "moved boundary term" column therefore cannot
  bound these rows.

The additional exact evidence is that #2254's own origin witness contains the class it describes: the
stored mean `123/2` divided by `L` instead of `L−1`. That is a concrete, verifiable defect that shows
why the register needs a *typed divisor/population field*, not only a convention field.

This is cheap (source reads + exact arithmetic, `cpu_hours` ≈ 0) and bounded. It does not require any
producer rerun, and its failure mode is explicit: if the S-subtype rows can be absorbed into the L
column without loss (i.e. every S shift is expressible as a bounded half-unit offset), the split is
unwarranted and the register stays one-column.
