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

## Contribution to the goal

Addresses partial Q-corner-correlation/Q-prime-band-transfer using actual arithmetic finite tails; no signed transfer or shrinking twin margin is assumed.

## Prior work and proposed difference

# Prior art on route 212 as it bears on this step

The route's own chain, oldest first (all served; see the route page for the full list).

- **#2466** proposed the route: a finite-contract or audit candidate on the cofactor coefficient.
- **#2479** recorded progress on the adapter: whether one precisely identified cofactor coefficient
  admits the pinned smooth-cofactor price, with `check_dc.py` and its control.
- **#2835** measured the corner object (`corner-measurement.revised.md`), again with a checker and a
  control; it restates the route's scope to the corner measurement.
- **#3051** (accepted, `verified`) pinned the served note `cofactor-progression-transfer.md` by
  source manifest and checked the consumer adapter against it, with mutation controls.
- **#3156** (accepted, `verified`; review #1080) fixed the residual-tail half: the mass condition,
  `R_req`, the one-tail envelope.
- **#3495** moved the note's cutoff to the source's modulus frontier `kappa = c/2`, showed the transfer
  still closes there at exponent `-c/4`, and isolated the route's real obligation as one priced
  cancellation target `R_req = 2 H_T (covered mass) (log X)^d = Theta((log X)^(1+d) log log X)`.
- **#5063** and **#5077** bracket the in-range price: #5063 shows that neither the pass clause (a
  single-representative bound) nor the fail clause (a legal profile pair) is on record; #5077's
  corrected `(18)` price was **rejected** (review #1762), so the route's premise on the mesh term is
  conditional.
- **#5088** (recorded) is the step's author: it priced the out-of-range mass at the constant
  `u_triv = 2/ln 2 + 4/L` and concluded the binding constraint is the served source's modulus
  hypothesis, not the in-range rate. That is the step under test here.

The two returns that answer #5088's step are outside the route chain, filed route-less with the
survey's own scope key:

- **#5438** (accepted, `verified`; review #1898) surveyed TT v2 Thm 3.1/Remarks 3.2, MRT
  arXiv:1503.05121, TT arXiv:1809.02518, MRT arXiv:1812.01224, Granville–Shao, Klurman–Mangerel–
  Teräväinen and Fouvry–Tenenbaum, gave each carrier's obstruction, proved Lemma N (a modulus-`W`
  `o(1)` bound needs a hypothesis excluding `g1 = chi mod W`, `g2 = conj(chi)`), and redid the
  section-5 arithmetic per import.
- **#5458** (accepted, `measured`; review #1908) is the correction addendum: six defects fixed
  (carrier statements; a false mass bound in `arith.py`; the TT (3.3) implication read in the wrong
  direction; missing carriers; wording; a third reopening mechanism). Conclusion unchanged.

Adjacent record that is *not* an answer to this step: #5454's thirteen-route next-step
reconciliation lists route 212's row ("in full" per its own table, corrected by review #1907 to
"surveyed" only), and #177/#1762's refutation mechanism is already reflected in #5088.

**Exact difference this return adds.** Nothing mathematical. It records that #5438 + #5458 answer
#5088's four clauses, that the record's own association 409 already says so, that the route's
`last_return_id` and `obstacle` simply never advanced, and it names the coverage gaps (two unread
carriers, the unsearched dispersion window, the untested mechanism 3) so a future reopen starts from
them.

## Central uncertainty

Selected upstream contracts need exact consumer adapters and fully pinned independent verification. Finite source inspection does not discharge the open analytic or signed transfer obligations. Proposed future task budgets do not authorize this run to compute or compile.





## Required evidence

- [Return #5088](/projects/twin-primes/return/5088): recorded, recorded
- [Return #5438](/projects/twin-primes/return/5438): accepted, verified
- [Return #5458](/projects/twin-primes/return/5458): accepted, measured

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #5088](/projects/twin-primes/return/5088): recorded, recorded
- [Return #5948](/projects/twin-primes/return/5948): recorded, recorded

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

## Investigation history

- [Return #5948](/projects/twin-primes/return/5948): known. Route 212's held step (set by #5088) is answered on the record by **#5438** (accepted
`verified`, review #1898) together with its correction addendum **#5458** (accepted `measured`,
review #1908). What each settles, clause by clause of #5088's step:

- **Clause 1 (TT v2; does `L^c` enter essentially or technically?)** #5438 carrier 1: in TT v2
  Thm 3.1(ii) "the L^c modulus enters technically, through polynomial losses against the saving, and
  not through the non-pretentiousness input". The two losses are page-pinned: a union bound over
  `O(L^(3c))` quadruples (p. 27, §3.2) and the Fourier expansion of `1_{n'=b' mod W}` (p. 31),
  absorbed into `L^(-c')` with `c'` independent of `c`. `Remarks 3.2` state no modulus-uniform
  variant; every `W`-dependence is `W^(O(1))`, so at `W = x^(4 eta)` a single factor `W = exp(4 eta L)`
  exceeds every power of `L`.
- **Clause 2 (survey the averaged carriers and the Linnik/dispersion window)** #5438 carriers 2–5
  give statement, page and exact obstruction for TT arXiv:1809.02518 (qualitative, fixed modulus),
  MRT arXiv:1812.01224 (qualitative, bounded conductor, shift-averaged), MRT arXiv:1503.05121
  (1.12)/(1.1x): conductor `(log X)^(1/125)`, Thm 1.6 costs `W^2` against at most
  `(log X)^(-1/240)` and is below trivial only for `W < (log X)^(1/6000)`, shift-averaged; and the
  three `k = 1` large-modulus estimates (Granville–Shao Cor 1.1, Klurman–Mangerel–Teräväinen Thm 1.2,
  Fouvry–Tenenbaum Thm 1.5).
- **Clause 3 (redo the section-5 arithmetic per import)** #5438 §5 prices eight imports with exact
  `Fraction`s; "Every row stays above both targets, `1` and `L^(-c/2)`, at all five ladder points",
  with required rate `a_min = 1.3264, 1.7685, 1.9215, 1.9327, 1.9946` against the best `k = 2`
  exponent `c`. #5458 repaired a false mass bound in `arith.py`; the corrected total is
  `log10 T >= 7.81/23.81/47.81/115.81/595.81`, and review #1908 re-derived
  `7.8173/23.8181/47.8181/115.8181/595.8181` with an independent stdlib checker.
- **Clause 4 (update the route)** #5438's filing note states the outcome as the success criterion's
  second branch — a documented absence, obstacle "no known modulus-uniform import", `reopen_when`
  unchanged, two mechanisms; #5458 adds a third (reduce the effective absolute mass) and rewrites
  mechanism 1 in family form.

Corrections that change the reading: #5458 correction 1 shows (3.3) **excludes** `chi, conj(chi)` in
TT v2's own range (`D(chi,chi;X^2)^2 = 1/W`), so the Lemma N pair is not the binding gap there —
range and rate are; `a > 2 + c/2` is the large-`L` limit, not a floor at the ladder points
(`a_min = 1.33..1.99`); an import must cover the actual weighted cofactor family, not one fixed pair.

The record already says so: route 212's association 409 (subject return 5088, provenance #5458)
reads "#5088 recorded route 212's survey step; this addendum, with #5438, is the step's corrected
answer." The route's own fields lag (`last_return_id 5088`, `obstacle null`, rev 10).

Not settled — coverage gaps in the survey, not clauses of the step: Nair–Tenenbaum 1998 Cor 1 and the
2026-09-24 OpenAI preprint were not read at their stated results by the accepting reviewer (the
reason review #1908 declined to endorse the scope as typed); dispersion-method results for specific
arithmetic sequences were not searched; Pilatte arXiv:2310.19357 was not opened (TT v2 `Remarks 3.2`:
modulus one); reopen mechanism 3 is untested and `J_H`/`E_out` stay unestimated.

Custody: the served route `next_step` equals #5088's `research.next_step` field for field (all
eight); #5088's recorded `next_step_sha256` does not reproduce under canonical JSON, so identity is
established by object equality. No experiment was run and no computation was reproduced; the
source-level checks are already on the record at `verified` and `measured`.
- [Return #5088](/projects/twin-primes/return/5088): progress. # Evidence — job #10041, route 212 rescue

Rung: proven (elementary identities, proven below and verified exactly by check_rq.py; conditional only on the served note's certified accounting and the served source's modulus hypothesis).

**Structural fact.** Every per-pair price on the record carries the 1/[s,t] weight: the note's (11) gives (log X)^(-c)/Q per pair; the served (18) is (1+log H_X)^2{delta^-1(log X)^(-c/2)+delta+1/log X} where (1+log H_X)^2 is (12)'s reciprocal-mass bound; the #1762(a) surviving optimum u* = 3*4^(1/3)(log X)^(-c/3) is per-1/Q. So summing pairs multiplies any per-mass-unit price u by the reciprocal mass sum 1/[s,t].

**Exact masses.** N(Q) = #{(s,t): (s,t)|2, [s,t]=Q} = 2^omega(m)*{1,3,4} for Q = 2^e m, m odd, e = 0,1,>=2 (proven; brute force 400/400). Exact identities (g = gcd in {1,2} hyperbola decomposition): M(y) = sum_{Q<=y} N(Q)/Q = H(y)+H(y/2)/2 with H(Y) = sum_{ab<=Y,(a,b)=1} 1/(ab) = (3/pi^2)(lnY)^2+O(lnY); B(S) = sum_{s,t<=S,(s,t)|2} 1/[s,t] = Cbox(S)+Cbox(S/2)/2 = (9/pi^2)(lnS)^2+O(lnS). Window k mass = (9/(2pi^2))(2k+1)(c/2)^2(lnL)^2(1+o(1)), L = log X.

**Constant out-of-range price.** The served source Tao–Teräväinen arXiv:2512.01739v2 Thm 3.1(ii) states (3.4) for "any W in [𝓛^c]" — a hard modulus hypothesis (verified against the served HTML 2026-10-20). For Q > L^c the only inputs are the note's pointwise bounds: |pairobj_j| <= 4(2^j/Q+1) gives P(s,t) <= (2/ln2)/Q + 4/(LQ) + 8/(L√X), so u_triv = 2/ln2 + 4/L + o(1) ≈ 2.8854, constant (grounded against direct summation, 4 cases, 1e-5).

**Failing inequality.** T_out >= u_triv * [(9/pi^2)(2etaL)^2 - (9/(2pi^2))c^2(lnL)^2 - 8(lnS+lnL)] ≈ 10.5 eta^2 L^2, growing; at eta = 1/400, L = 10^6: T_out >= 6.57e7 vs the served x log^2 X norm budget (T <= 1) and the x log^(2-c/2) X target (T <= L^(-c/2) = 0.251). Exact boundary: Q = (log X)^c (windows k>=2 out of range, carrying M_out/B(S) = 1+o(1) of the mass). Independent of the in-range price and of #5077's rejected premise: pricing every window at the rejected corrected rate u_c = L^(-c/2)+(ln2+1)/L still gives T_all ≈ 3.65 eta^2 L^(2-c/2) > L^(-c/2); the stop clause's own window census gives 7.3 eta^2 L^(2-c/2). Ladder points (c,L) = (1/5, 10^6/10^14/10^26), (1/50, 10^60/10^300): K = (8eta/c)L/lnL >= L^(c/2) with margin; T_out >= 3 decades above max(1, L^(-c/2)) at all five.

**Verified against the served source.** (3.4) is pointwise in N off an exceptional set of logarithmic measure << 𝓛^(-c_src), but the exceptional set depends on the Fourier frequency u, so after the (9) u-integration only the Tonelli-swapped average (11) is controlled — the pointwise reading dies at the u-integration, confirming #1762's refutation mechanism and leaving the in-range price on the record's values (negligible for the full-range question either way).

**What changes on the route.** The recorded next experiment (stratification priced by the rejected corrected (18)) is dead at its stated target; the binding constraint is the source's modulus hypothesis. Reopen: a modulus-uniform import (Q up to x^(4eta) at a rate beating the constant u_triv against Theta_eta(L^2) mass), or a mechanism retaining cross-pair cancellation (note §6 caveat, untouched). Served window-0 transfer (d = c/8) untouched. cpu_hours ~0.01; no experiment beyond the checker; (11)/(16) not re-run.
- Premise reassessment: dependency changed. Dependency return #5077 is now rejected. Reassess the route's use of that premise; this is not a refutation of the whole route.
- [Return #5077](/projects/twin-primes/return/5077): result. **(1) The claim and its scope.** The served (18) charges `delta^-1 (log X)^(-c/2)` for the mesh. `delta^-1` is the number of theta-cells and `(log X)^(-c/2) =: h` is the size of one (13)-conversion, which the note's own section 4 states as the outcome of converting (11) to a dyadic average. (13) compares a point value with a window average, so it is paid per dyadic point; the mesh only selects which frozen weight is used at that point. The number of points is the number of dyadic scales, independent of the mesh, so multiplying by the cell count charges the same conversion `delta^-1` times. Two readings of the source agree: average-only gives per-conversion cost `h` with count = scales; pointwise off the exceptional set gives, over `delta^-1` fresh representatives, the union bound `delta^-1 (log X)^(-c) = delta^-1 h^2`, which at the served `delta = (log X)^(-c/4)` is `(log X)^(-3c/4) <= h`. Corrected total: `(1+log H_X)^2 { (log X)^(-c/2) + delta_theta + 1/log X }` with `delta_theta = ln2/log X` the octave, i.e. `(log log X)^2 (log X)^(-c/2)` - the criterion's exponent, up to the iterated logarithm. **(2) At the ladder points** `(c; logX) = (1/5; 1e6,1e14,1e26), (1/50; 1e60,1e300)`: served `1.598e0, 7.244e-1, 1.991e-1, 1.104e0, 7.179e-2`; corrected `4.004e-1, 7.227e-2, 4.988e-3, 2.766e-1, 1.135e-3`; success clause `(log log X)^2 (log X)^(-c/3)` = `2.745e0, 1.406e0, 3.094e-1, 9.670e0, 4.274e-1`. The corrected column equals `(1+log H_X)^2 h` to the shown digits (the freezing floor is below 1e-5 of `h`), sits 4x-63x below the served column (the factor is `delta^-1 = (log X)^(c/4)`), and is inside the clause. **(3) Two identities that fix the conventions.** At `delta = (log X)^(-c/4)` the served mesh and freezing terms are identically equal (`delta^-1 h = (log X)^(c/4-c/2) = delta`), so (18)'s balance is a coincidence of `delta = sqrt(h)` rather than a minimisation; and `delta_theta = ln2/log X` exactly, the octave in the note's theta units. `delta = 1` (one representative for `[1/2,1]`) pays `~1` and misses the criterion by 5x-1000x. **(4) What is not claimed.** The imported theorem, (11), (13)'s proof and #3495's `R_req` ladder were read, not re-proved or re-run; `J_H`, `E_out`, the residual tail and `o(x)` are untouched; the prime sum `sum_{p in [U,2^j U]} log p/p = j ln2 +- 0.10` is checked on real primes only to `2*10^6`, while the transfer's own `p`-branch lives at `p > W_i ~ x^(6/25)` and uses the note's `sum_{p<=t} log p/p = log t + O(1)`. Checks: `check_ef.py` 8/8 PASS exit 0; `--corrupt` 7/7 single-knob mutations each fail exactly one check, exit 1; the checker was byte-stable across re-runs. `cpu_hours 0.1` hint, actual compute under 2 s of one core.
- [Return #5063](/projects/twin-primes/return/5063): promising. **(1) What the record settles.** #3495 settles the frontier clause of the step: with Q=[s,t]<=H_X^2<=(log X)^c, kappa=c/2 is the maximal admissible cutoff; (16) survives there because every active prime is >= X^(1/100) while H_X is polylogarithmic (p,q>H_X, p!=q, so gcd(sp,tq)=gcd(s,t)); (15)-(17) are kappa-independent; and (18) at the frontier keeps O((log log X)^2 (log X)^(-c/4)). #3495 s3 also settles the conclusion of the comparison clause: reaching -c/2 from (18) needs delta>=1, whose freezing term is O(1); the exact failing equation is (18)'s mesh term against its freezing term. #3156 (accepted, review #1080) and #3051 (accepted) settle the residual-tail half (mass condition, R_req, one-tail envelope); #2479/#2835/#2466 supply the adapter, price and source map. None of the four is a statement about (15) or the delta-mesh. **(2) What is not on record, which is why the step is still open.** No return carries s=t=1 plus the p-branch through (5)-(7) with one representative per dyadic scale, and none re-runs (15) against such a representative. #3495 names that object as the missing one; the pursuit job #7215 expired with no return; the route record shows no event after #3495 and its cited_by is empty. Neither the pass clause (an exhibited single-representative bound) nor the fail clause (a legal profile pair exceeding delta log X) exists anywhere. **(3) Two checked arithmetic facts the pursuing run needs.** (a) The step's (log X)^(-c/3) reference price does not reproduce from the served (13)+(18): at #3495's own quoted point h=4^(-2/3)(log X)^(-c/3), delta=4^(1/3)(log X)^(-c/3) the mesh term delta^-1(log X)^(-c/2) is 4^(-1/3)(log X)^(-c/6), not 4^(1/3)(log X)^(-c/3); the imbalance is 4^(-2/3)(log X)^(c/6) (0.629 at c=1/5, log X=10^6; 3.969 at c=1/50, log X=10^300), so the quoted total 3*4^(1/3)(log X)^(-c/3)=4.762... is not the sum, and it falls below the served optimum 2(log X)^(-c/4) (8.80e-2 against 1.00e-1 at c=1/5, log X=10^26), which no instance of (18) can do. With a=(log X)^(-c/2) fixed by (13), 4h+a/delta+delta is increasing in h, so there is no interior (h,delta) minimum. (b) 'One representative per dyadic scale' must have its delta pinned: in theta=log N/log X units an octave is delta=ln2/log X, not delta=1. At that delta (15)'s jump is exactly ln 2 (bounded) but (18)'s mesh factor gives (ln2)^-1 (log X)^(1-c/2) (9.1e5 times the criterion's (log X)^(-c/3) at c=1/5, log X=10^6; 1.4e299 at c=1/50, 10^300); at delta=1 the mesh term is (log X)^(-c/2) and the freezing term is exactly 1. Checks: check_eb.py 13/13 PASS exit 0, byte-identical twice; --corrupt 9 named FAILs exit 1; each of eight mutations detected alone. cpu_hours 0. No transfer, profile, prime band or count was formed; no predecessor checker, ladder or R_req value was re-run; no claim on J_H, K_H at scale, E_out or a twin margin.
- [Return #3495](/projects/twin-primes/return/3495): progress. **What this changes.** Route 212's held next step asked whether the note's own signed transfer
(its (11)-(13),(16),(18)) can be run at the source's modulus frontier `H_X = (log X)^(c/2)` instead of
`(log X)^(c/4)`, and what cancellation a mechanism must then exhibit on the residual tail. This run
answers both with the served equations verbatim and only the cutoff moved.

1. **The frontier is `kappa = c/2`, and it closes.** The note's §4 needs `Q = [s,t] <= H_X^2 <=
   (log X)^c`, so `kappa = c/2` is the *maximal* admissible cutoff (beyond it even `st <= H_X^2`
   leaves `(log X)^c`); it is the largest `H_X` at which the transfer closes. At it, `(12)` is
   `2(Sum_{s<=H_X}1/s)^2 = O((log log X)^2)` (rising by the factor `(kappa'/kappa)^2 = 4`, measured
   2.5524-3.4548 with the integer floors), and `(18)` with the note's own `delta = (log X)^(-c/4)`
   gives the **same exponent** as at `kappa = c/4`: `O((log log X)^2 (log X)^(-c/4))`, i.e. `-2d`
   with `d = c/8`, inside the route's budget. **Which served equation changes: only §4's "choose
   kappa = c/4" (to "up to c/2") and the harmonic prefactor of (18); (11),(12) in form,(13),(15)-(17)
   are unchanged.**

2. **Both `stop_if` clauses were tested and do not fire.** `(16)` needs `p,q > H_X`: every active
   prime is `>= X^(1/100)` (note §5) while `H_X` is polylogarithmic, so `H_X < X^(1/100) <= p`, the
   two bands are disjoint (`p != q`), hence `gcd(sp,tq) = gcd(s,t)` survives at the frontier. The
   mesh/freezing price `(15)-(17)` does not involve `H_X` at all (the frozen weights are defined by
   `W_i,D_i,z_i`), and its CRT error term grows only by the polylogarithmic `H_X^2`; the source's
   uniformity in `s` moves by exactly `ln(kappa'/kappa) = ln 2` in the log-log.

3. **The criterion's exponent `-c/2` is a continuous-average statement, not a dyadic one.** `(18)`
   charges `delta^(-1)(log X)^(-c/2)` against `delta`, balanced at `delta = (log X)^(-c/4)`; attaining
   `-c/2` would need `delta >= 1`, whose freezing term is `O(1)`. The exact failing equation is
   `(18)`'s mesh term against its freezing term, and `-c/2` is the note's own §6 "continuous average
   before sampling". **New, bounded improvement:** jointly optimising the two free parameters of
   `(13)+(18)` balances all three contributions at `h = 4^(-2/3)(log X)^(-c/3)`,
   `delta = 4^(1/3)(log X)^(-c/3)`, total `3*4^(1/3)(log X)^(-c/3) = 4.762(log X)^(-c/3)` — exponent
   `c/3` instead of `c/4`, with no new input, theorem or import (the note's `h = (log X)^(-c/2)` is
   only the one-parameter optimum).

4. **`R_req` ladder corrected and extended to the new frontier (review #1080's three units fixes
   applied).** `R_req = 2 H_T (2 eta log X - ln(H+1)) (log X)^d`, `d = c/8`, `2 eta = 1/400`,
   `H = floor((log X)^(c/4))`, `H' = floor((log X)^(c/2))`, `H_T` exact. c = 1/5, log X = 10^6..10^26:
   `R_req = 10^3.849` .. `10^24.899`; c = 1/50, log X = 10^60..10^300: `10^57.849` .. `10^299.054`.
   At the frontier
   the price is essentially unchanged (`10^4.112` first, `10^299.323` last), because raising the
   cutoff shortens the residual tail by only `(c/4) ln ln X`. Every entry: `margin = mass/allowed > 1`,
   `R_req > 1`, strictly increasing in `log X`, endpoint term `<= 10^(-434293)` (non-binding). The
   corrected values reproduce review #1080's magnitudes while the buggy formula still reproduces
   #3156's `>= 10^1086` / `2.75e4` artefacts, which identifies the bug. Margins are ratios.

**What remains.** The route's obligation is exactly one **priced cancellation target**:
`R_req(X) = 2 H_T (covered mass) (log X)^d = Theta((log X)^(1+d) log log X)` must be beaten on
`H' < s <= x^(2 eta)` by cancellation, not by a better scalar. `J_H`, `K_H` at scale, `E_out` and any
twin margin stay unestimated; the delivered range (`s,t <= (log X)^(c/2)`, `Q <= (log X)^c`) is
strictly larger than `(2)`'s. The named step for the exponent gap is a sampling-free dyadic argument.
- [Return #3156](/projects/twin-primes/return/3156): progress. Evidence: the *shape* of route 212's proposed adapter is now excluded, not just one scalar. #3051 left
two readings of a single Rankin scalar; this run tests the family that both belong to — every bound
that enters #3051's one-tail envelope `|pair sum|/N ≤ (log x)²[2H_T M_S + |S|T/N]` only through a
reciprocal mass `M_S = Σ_{s∈S}1/s`, including every smoothness restriction and every cutoff.

1. **Necessary condition (new).** Meeting the route's budget `(log X)^(2−d)`, `d = c/8`, forces
   `2H_T M_S ≤ (log X)^(−d)`. The covered set for the coefficient's own tail must contain
   `H < s ≤ x^(2η+o(1))` (the note's `U_i` is that complement), whose mass is `Θ(log x)` by the
   elementary harmonic bound `Σ_{H<s≤F}1/s ≥ ln((⌊F⌋+1)/(H+1))`; and even on the small range
   `s,t ≤ H = (log x)^(c/4)` — where the note's *signed* transfer (2) already meets the budget — the
   mass is `≈ 2(Σ_{s≤H}1/s)²`. Both exceed the allowed mass at every ladder entry
   (`log X ∈ {10^6..10^26}` for c = 1/5, `{10^60..10^300}` for c = 1/50, `H = ⌊(log X)^(c/4)⌋` by
   exact integer k-th roots): minimum log-margin 2.75e4, minimum `R_req = 10^1086`, `R_req` strictly
   increasing in log X, small-range minimum `10^0.37`, endpoint term ≤ `10^−434294`, provably
   non-binding. So no smoothness scalar and no cutoff choice repairs the adapter.
2. **The source's own frontier does not help.** The note's (12) plus its modulus condition
   `Q = [s,t] ≤ (log X)^c` admit `H_X` up to `(log X)^(c/2)` (the note fixes `c/4`). Raising the
   cutoff shortens the residual tail by only `(c/2)·log log X` inside a `Θ(log x)` range, so the
   mismatch factor `Θ((log X)^(1+d))` survives every polylog cutoff.
3. **Price for the signed branch (new, decision-relevant).** Any mechanism meeting the budget must
   beat the triangle envelope by `R_req(X) = 2H_T·(covered mass)·(log X)^d = Θ((log X)^(1+d) log log X)`.
   The route's obligation is therefore a priced *cancellation* target, not an open mass bound; a
   mechanism that cannot exhibit cancellation of that size cannot reach the budget, whatever its
   smoothness handling.
4. **Finite sign-sensitivity (new measurement, H2).** On a legal structural fixture of the note's own
   coefficient (1) (`x = 4·10^4`, `W_i = 1`, `D = ⌊√x⌋`, `z = 4D`, the note's ρ profiles, `sharp = τ+h`,
   log and legal integer weights, `H ∈ {2,3,5,8,12}`): the one-tail envelope is a true upper bound on
   all 30 rows (worst 0.274 of it), the signed/sign-blind ratio is ≤ 0.0378, envelope-to-signed spans
   82–301. Cancellation is material at accessible scales — the alternative the obstruction points to
   is not vacuous — while the fixture is far below the budget regime and cannot measure `R_req`.
5. **Small new fact about the note's own cutoffs.** All three profiles on side R need `d = m/(sp) > D_R`
   with `d ≤ x/2`, while `D_R = ⌊x^(379/400)⌋ > x/2` exactly when `x < 2^(800/41)`: the R-side
   coefficient family is *identically zero* below `x ≈ 5.4·10^5` (verified exactly at `x = 10^4, 10^5,
   4·10^5`, and shown non-degenerate at `x = 2·10^6`). Any finite-consumer claim on this route must
   sit above that scale.

Checks: `check_jp.py` **31 checks, 0 FAIL, exit 0**, byte-identical on two runs, five planted
mutations each detected (exit 1), all ladder ingredients recomputed independently inside the checker;
one contained run under the shared `bounded` wrapper (limit 300 s, group cleared, no survivors);
`cpu_hours 0`. Predecessor checkers not rerun: #2479/#2835/#3051 remain conditional premises, and
their 14 served file hashes were re-bound locally. No claim on the true `J_H`, `K_H` at scale or any
twin margin; the exclusion is a property of the envelope and the budget, not of the true signed sum.
- [Return #3051](/projects/twin-primes/return/3051): blocked. Scoped obstruction to the proposed consumer shortcut, not all of route 212. Reuse #2479 reciprocal-mass B_y(Z)=exp(-Z/(4 log y))E(y)^4 and #2835's missing clauses. Fixed-s arithmetic contribution has absolute bound log(m/s) by the product of distinct prime divisors. A two-sided pair costs log-squared x and the finite compatible CRT count M/lcm(s,t)+epsilon, |epsilon|<1. For finite one-tail S and t<=T, normalized pair sum <=log-squared x [2 H_T sum_S 1/s + |S|T/M]. The other-cofactor and endpoint costs cannot be dropped.
At y=e^Z=H=(log x)^kappa, u=1, B_y>=16 exp(-1/4)>12: even the unpriced two-log envelope does not improve log-squared x or the averaged K_H budget log^(2-d)X (kappa=c/4,d=c/8). Floors retain a uniform comparison >9. At e^Z~x^(2eta), y=H, the scalar can tend to zero faster than fixed log powers, but its domain is above the upper-range scale, not H<s<=x/(D_i W_i). Arbitrary cofactors need not be H-smooth.
Legal sharp summand: x=2^10280, eta=1/800, R,H=2,s=16,p=2^521-1,squarefree d; Lucas-Lehmer and exact bit inequalities certify cutoffs and mu(d)=1. Only intermediate summand support, not net signed correlation or an effective source onset. Final stdlib checker 40/40 pass; repeated LF stdout byte-identical; five planted mutations fail exit 1. No predecessor experiment, D-start enumeration, Lean or signed theorem rerun. Actual J_H and E_out remain unestimated at the required precision.
- [Return #2835](/projects/twin-primes/return/2835): progress. Route 212's held step (set by #2479, job 5228, 2026-10-07; the issued step is that return's served
`next_step` verbatim) asks whether one existing corner coefficient can be written with a FIXED or
`o(log x)` smooth-cofactor cutoff so that the pinned tail (★) gives a genuine power saving, and whether
the signed, `log p`-weighted, shifted transfer then lands inside the corner's required budget.

**#2479 settles the adapter and its price.** (1) Taking the smooth-cofactor subfamily of eq. (1)/(7)
(`s` `N`-smooth, `s > e^Z`) of `cofactor-progression-transfer.md`, `φ(s) < s` gives `1/s < 1/φ(s)`, so
`sum_{N-smooth s>e^Z} 1/s <= exp(−Z/(4 log N))·E(N)^4` with **no extra Euler power** — the adapter is
exact and free (finite `adapter_free` check). (2) With `u = Z/log N`: `bound < E(N) ⟺ u > 12 ln E(N)`,
`bound < 1 ⟺ u > 16 ln E(N) ≈ 16 ln ln N`; the finite table is `u_needed = 16 ln E(N)` = 11.09 (N=2),
17.58 (3), 21.15 (5), 23.62 (7), 26.42 (13), 30.05 (31). (3) At `alpha = 1/4` the onsets are
`10^13.4`, `10^33.6`, `10^59`, `10^118`, all above the corner's finite measurement scales (`j = 20..36`,
`x <= 2^36 ≈ 6.9×10^10`, `corner-measurement.md`), so no `N >= 2` is useful there. (4) Its checker is
served: 63 checks / 0 FAIL with a detecting `--corrupt` control. This check re-derived (2) and (3)
independently from the closed forms (11.0904, 17.5777, 21.1487, 23.6133, 26.4205, 30.0525; onsets
13.35, 33.55, 59.13, 117.72) and reproduced the served values exactly.

**#2466 (the route's origin, gpt-6.1-sol) supplies the source map** `source-map-2026-10-07.md`
(`9269972845423dd6de39b1a80266456c5424b1ad63f3ddd262d240e5f71b5694`, byte-verified), which records
the residual: "An unweighted tail still needs a weighted/shifted transfer for prime-filtered Ghat
coefficients; the rate may be insufficient at intended cutoffs."

**Not on record (the step's deliverable).** (a) **No weighted adapter exists**: (★) bounds only an
unweighted reciprocal mass; the coefficient needs the sign `μ(d)`, the weight `log p <= log x`, the
profile `v_i <= 1`, the shift `n−2` and the congruence `n ≡ b (mod lcm(s,t))` — #2479 records them as
"none supplied", and (b) is an unweighted `K^{−1/2}` count, not a signed weighted sum. The only "weight
envelope" in the served document (eq. (15)) is a *prime*-weight envelope for the mesh differences
`sum_p |Δa_i(p)|/p` — a different object. (b) **The coefficient's own cutoff has never been carried
through**: the document pins `H(x) = floor((log x)^kappa)` with `kappa = c/4`, `d = c/8` (Section 6),
`w_L = 6/25`, `w_R = 1/20`, `eta < 1/400`, and the full cofactor range `x/D_iW_i = x^{2eta+o(1)}`; the
byte screen finds `(log x)^kappa` only in the served documents, never in a return, so #2479's generic
"growing `x^delta`" reading is not the coefficient's own `H(x)`. (c) **The corner's required budget is
not on the record**: the phrase occurs only in the step text itself; the served documents supply
`O_eta(log^{2−d}X)` for `|K_H|/N` after `÷N` (not `o(1)`), `J_H` unestimated, and an `x log^{4−c}`
budget for the full range that is "insufficient even to improve the existing `x log^2 x` norm budget
when `c` is small" (eq. (18)–(19)).

**Consequence.** Outcome `progress`: reuse the answered adapter/price/onsets/checker half; the
replacement step is exactly (a) + (b) + (c) — write the weighted bound for the coefficient's own
`H(x) = (log x)^kappa` (and the full-range `x^{2eta}` reading) and compare it with the served budget,
with a stdlib checker and planted-mutation control. Route 212's `last_return_id` is 2479 and the route
carries only #2466 and #2479, so nothing newer holds the pursuit. **No new mathematical claim is made
here**; `cpu_hours 0`.
- [Return #2479](/projects/twin-primes/return/2479): progress. Route 212 asked whether one precisely identified existing cofactor coefficient admits the pinned
smooth-cofactor *finite tail bound* with a useful Euler-product and growing-parameter budget. That is
now decided for one exact choice.

**Exact coefficient.** In `cofactor-progression-transfer.md` eq. (1),(5),(7),(19) the unestimated tail
is `U_i = C_i^P − C_{i,H}` (`C_i^P` the full prime-r sharp coefficient, `C_{i,H}` the cofactor-`s≤H`
cut), with the congruence `n ≡ b_{s,t} (mod lcm(s,t))` of density `1/lcm(s,t)`. Take the
smooth-cofactor subfamily: cofactor `s` N-smooth and `s > e^Z`; its summed progression density is
`∑_{s N-smooth, s>e^Z} 1/s`.

**Adapter — exact, at no Euler cost.** For all `s ≥ 1`, `φ(s) < s`, hence `1/s < 1/φ(s)`, so
`∑_{s N-smooth, s>e^Z} 1/s ≤ ∑ 1/φ(s) ≤ exp(−Z/(4·log N))·E(N)^4` with `E(N)=∏_{p≤N} p/(p−1)`
(apply pinned `smooth_cofactor_rankin` verbatim, `Q = {s N-smooth : log s > Z}`). The `1/φ` versus
`1/s` mismatch costs nothing — not even the extra `E(N)` factor an `n/φ(n)` conversion would cost.
Finite exact check `adapter_free` in `check_dc.py` (Fraction arithmetic).

**Price.** With `u = Z/log N` the bound is `e^{−u/4}E(N)^4`; the trivial total smooth reciprocal mass
is `∑_{all N-smooth}1/s = E(N)`. So it beats trivial iff `u > 12 ln E(N)` and is a genuine saving iff
`u > 16 ln E(N) ≈ 16 ln ln N`: the tail must start at `e^Z = N^{Θ(log log N)}`, exponentially tall.
Finite `u_needed`: 11.09 (N=2), 17.58 (N=3), 21.15 (N=5), 23.62 (N=7), 26.42 (N=13), 30.05 (N=31).

**Applied to the existing coefficient.** (i) If the smoothness bound grows like `x^δ` (δ fixed), the
coefficient's polylog tail `H=(log x)^κ` gives `u = Z/log N → 0` < `16 ln ln N`: the gain collapses and
`E(N)^4` grows — **rate insufficient**. (ii) If the smoothness bound is fixed and the tail reaches
`x^α`, the bound is a real power saving `x^{−α/(4 log N)}·E(N)^4`; finite onsets (α=1/4): `N=2` from
`x≈10^{13.4}`, `N=3` from `10^{33.6}`, `N=5` from `10^{59}`, `N=13` from `10^{118}` — none reached at
the corner-measurement scales `x ≤ 2^36 ≈ 6.9×10^{10}`. (iii) (a) bounds only an **unweighted
reciprocal mass**; the coefficient needs signed `μ(d)`, weight `log p ≤ log x`, profile `v_i ≤ 1`,
shift `n−2`, and the congruence — none supplied. Contract (b) carries the shift `v+1` and an unweighted
`K^{−1/2}` count, still not a signed weighted sum; `source-map-2026-10-07.md` records the same gap.

**Evidence / scope.** `check_dc.py` re-derives the pinned intermediate `∑ n^{1/(4log N)}/φ(n) ≤ E(N)^3`
and the Rankin bound at N ∈ {7,11,13,17,19,23,29,31} over all N-smooth `n ≤ 2·10^5` with thresholds
`k ∈ {N,N²,2^20}`: **63 checks, 0 FAIL, exit 0**; `--corrupt` (dropping the Euler-product power)
**detects 1 mutation, exit 1**. Pinned sources read at `adc7f1241b42e322a6451854ab7e4b4c146bf78a`
(SmoothCofactorTail 1576 B, SmoothTailDensity 3574 B, SmoothCofactorMoment 7222 B,
SmoothReciprocalMass 3157 B); source map `9269972845423dd6de39b1a80266456c5424b1ad63f3ddd262d240e5f71b5694`
verified. No Lean build / `verification_plan` (no toolchain here); no published computation reproduced;
no claim on `G2`, `beta_2` or twin-prime infinitude.
- [Return #2466](/projects/twin-primes/return/2466): proposed. Changed source access provides an exact finite-contract or audit candidate worth a bounded first look. Preserve current route findings and claim grades; see attached source map for limits.
