[Matarener]

Requested by Mark

Before: the merged research/selected-word-exact-grid (#5435) certifies the exact grid of the eight-relation word alone. For the complete selected #5413 caller, the precision record (FRESH-PRECISION.json) holds only crude heights: about 19,452 bits per local body and 377,688 for the global word.

After: the complete caller has an exact, attained grid:

• Body. The runtime backward body, with the Preserve all 632 native inputs in an eight-mode coupled helper provider #5402 provider expanded, needs ceil(9 lambda/2) + 6.
• Controller. One 145-axis controller level needs 74 extra fractional bits at every observed cut, and 74 is attained: a Gaussian-climb cut (provider event 11204) where bank 31 reaches y70 alone needs 2 + ceil((136+7)/2) = 74. The 224 rank-145 targets need 73; the body's 2^-6 adds nothing on top. (The first version claimed exactly 73; zxv's review found the unobserved climb cut.)

No new κ; this continues target 7 of #5428.

How. verify.py executes the literal body with the provider schedule expanded:

• there are no odd denominators, including in the ZW = 14 I provider;
• all 17 owned fields are zero at exit;
• the maximum v2 is 6, attained by a single-occurrence rank-9 term;
• the final X rows are x_p - y_p;
• every scalar, warp and Gaussian climb of the provider word is a cut of its own;
• each mode cache SWAP moves its 56-term cache row to the owner.

From the port wrappers it derives the per-port Q_p = A_y A_x^-1, which has Fourier rank 1, and Q_p^2 has rank 0. The final rows then give X = Phi(x - Q_p y), identifying Q_p with the controller's Q.

The controller is replayed in the exact Laurent ring of check_wholecaller_v1, and the diagonal endpoint is reproduced.

• Calls before the last carry at most 16 stages, so they need at most 4 + ceil(137/2) = 73.
• In the last call (stage 32, pair 15), bank 31 enters x as Q^2 D_T and y as Q D_T with 17 stages. Its two paths merge on Phi_x Q^2.
• Every in-word, t-field and cache cut there is evaluated with exact nine-plane ranks, with warps from the native table. The maximum is 74, at the climb cut above, where no x70 term merges; t-field and cache cuts need at most 73. Body operations outside the provider word are not cut separately (stated in the README).

test_verify.py rejects eight mutations: a drifted input, an odd division, a non-inverted block map, a missing Q_POWER, a missing owned CLEAR, a cache SWAP that drops the cache row, an unobserved climb cut and a tampered RESULT.json.

python3.12 -B scripts/research_package.py --package research/selected-caller-exact-grid

PASS locally on CPython 3.12 (Windows), about two minutes. check_research_commit.py and test_research_current_status pass. Scope: native correctness, the chart/wrapper/warp conventions and the Q identification (the body's specified endpoint, checked through its final rows) are inherited. This is an exact-grid statement, not a recursive price.

Task card formal-interface-lemma, scope changed (see TASK.json). Credit: Clear1nsight (#5413), dillona (#5402), Ali Romman (#5383, #5398), Cao Yifan (#4610), Ross Richardson (Clifford denominator lemma), zxv (#5428).

🤖 Generated with Claude Code

[zxv]

Reviewed commit a21c58f671f15c723629dd6e28b8a69dd98370a2. The registered package replay and all six controls pass on CPython 3.12.8 / Darwin arm64, but I found two correctness issues.

1. [P1] The omitted Gaussian-climb cuts invalidate the exact 73-bit claim. In provider() lines 214–219, a climb changes the frame without calling stat(), so its output never enters the rank census. Adding that observation alone produces a maximum of 74:

   • Last LOCAL: stage 32, pair 15.
   • Provider event 11204, zero based: ['climb', 'warp_retimed', 63, 292, 254, 4].
   • Row 63 contains input 182 (y70) exactly once, with coefficient 1/4 and no warp word; there is no x70 term to cancel it.
   • Original bank 31 reaches this y input as Q D_T, with 17 private stages. Using the PR's own wrapper/Q convention, the nine-axis operator has rank 7; its exact zero-column entry at coordinate 0 is (-1+i)/16.
   • The 136 private Fourier axes add 68 denominator bits. A basis input on original bank 31, port 70 therefore yields (-1+i)/2^74 at this cut: 2 + ceil((136+7)/2) = 74 bits are necessary.

   Minimal reproduction, run from this PR checkout (changes the verifier only in memory):

   from pathlib import Path
   p = Path('research/selected-caller-exact-grid/verify.py').resolve()
   s = p.read_text().replace(
       'self.frames[e[2]] = e[4]',
       "self.frames[e[2]] = e[4]\n                self.stat(('climb', t), e[2])")
   s = s.replace("require(best[0] == 73 and tbest <= 73 and cbest <= 73,",
                 "print('maximum including climb cuts:', best, flush=True)\n    require(best[0] == 73 and tbest <= 73 and cbest <= 73,")
   ns = {'__file__': str(p), '__name__': 'review_probe'}
   exec(compile(s, str(p), 'exec'), ns)
   ns['build']()

   Output: maximum including climb cuts: (74, '1/4', 143, 31, 70, 254, []), followed by FAIL: last call: every cut needs at most 73. Please observe every relevant operator/frame cut, add this witness as a regression, and revise the README/RESULT/TASK claims. This establishes at least 74, not a completed proof that 74 suffices for the entire caller.

2. [P2] The provider's cache SWAP deletes the value it should transfer. At line 248, self.rows[cs], self.rows[o] = self.rows[o], {} sets both rows to zero because the preceding assertion requires the owner to be zero. The nonzero cache row is discarded. I observed 56 terms in each of the eight cached rows, followed by zero terms in every owner. A literal SWAP must transfer the transformed cached row to o (and leave the old zero owner in cs). Consequently this is not currently a faithful replay of the full provider/body. Preserve that transfer and verify the reconstructed helper outputs, in addition to the owned-zero and X-row checks.

The successful declared replay is useful evidence for the checks it executes, but it does not certify the complete-caller 73-bit conclusion. The inherited native/chart/Q assumptions and recursive precision price were not independently re-proved in this review.

Review performed with OpenAI Codex assistance.

[Matarener]

Thanks, both confirmed and fixed in fa2ba8e.

1. Every scalar, warp and Gaussian climb of the provider word is now a cut. The maximum is 74, at your witness: event 11204, bank 31, port 70, frame 254, coefficient 1/4, operator rank 143. The verifier pins this witness, and an unobserved-climb control reverts to 73 and is rejected. Title, README, TASK, VERIFY and RESULT now say 74 over the observed cuts, attained. The README states that body operations outside the provider word are not cut separately, so this is not claimed for the entire caller.
2. The cache SWAP now moves the row: each of the eight owners receives its 56-term transformed cache row and the slot ends zero. The drop-the-row mutation is a control. The algebraic endpoint of those rows (C8 z) is certified in All-width certificate for the complete #5413 caller: group-algebra lifting lemma, 896 port identities, free body, abelian controller (no new kappa) #5442.