[aliromman]

Reusing the same two native stages does not give a short scalar decoder for the pinned center-free code. This is a scoped negative result: every nonempty reduced product with at most 32 alternating power blocks, and arbitrary nonzero integer exponents, still needs a scalar ADD count that grows with tensor width. There is no cheaper circuit or new complete kappa bound. The selected conditional kappa remains 0.0030217758.

The proof, exact receipt and moment certificate contain the result. The new finite witness proves independence for every choice of coefficients: the 64 nonconstant reduced projection words through degree 32 remain independent after removing the central-address output. Their 64-by-64 Gram determinant is exactly 52006 mod 65521.

This witnesses a surviving native path which moves the central axis. A tensor-entry contraction then proves ADDs >= max(0, 2f - 3r), where r is a finite product-dependent constant. No small value of r is claimed. The code identity C_s^a = I + ((-13)^a - 1) P_s extends the result to arbitrary nonzero integer powers and inverse products.

The scope has one shared binary axis, two private eight-axis blocks, and the exact owner code and signed normalizers. Adjacent inverse powers can cancel before reduction. The result does not cover longer reduced words, three or more stages, changed normalizers, paid Gaussian decoders, or callers with retained correlated inputs. It does not rule out another architecture.

Reproduce with Python 3.12 and NumPy 2.5.4:

python3.12 -B scripts/research_package.py --package research/repeated-native-code-separation

Expected scientific marker:

PASS_REPEATED_NATIVE_CODE_DEGREE32_NO_NEW_KAPPA

The registered dense replay and optimized certificate check pass. A separate C++17 replay, compiled with -O3 -Wall -Wextra, reproduces all 7,280 moment entries through the eight-mode factorization; the dense replay uses the full owner matrix instead. Its binary64 operations are exact integer products and sums below 2^24, with checked bounds. No floating-point rank test is used. Modular elimination and fraction-free integer elimination give the same determinant. Six boundary/rejection controls pass. Three optimized corruption runs reject changed phase bytes, a changed moment, and a forged receipt. Committed-byte, 16-file official export, export-integrity and Git-free optimized certificate checks pass. The validation record and README give commands and limits. Hosted CI is separate and was not yet available when this description was prepared.

This is a certificate-assisted written proof with two replay implementations. Independent human or proof-kernel acceptance is not claimed. No full supplier/controller admission, compiler/outer replay, selected cold replay, Lean or Docker build was run. No full-history ancestry check was run in this shallow checkout.

Base: canonical main 1ec1119972c9aefe42525172d07b332fcff81cb4, priority revision 7. Only the new scoped package changes. Source pins bind all consumed bytes. The canonical investigation distinguishes this work from the coupled-helper caller, paid-cache, geometry and border-grading tasks. A live prepublication check found no replacement for this exact repeated-code certificate. Sparse local-note coverage remains incomplete.

Credit Dillon's PR #4933 for the physical code and normalizers; Dugongue's PR #4929 for the center-free offer and spectrum; Cinna Davis's PR #5065 for the two-stage terminal predecessor; and Ali Romman's PR #5408 and its pinned proof for fresh-stage separation and path contraction. The present change replaces fresh-stage uniqueness by a repeated-stage Gram witness. Cao Yifan, zxv, Jacob Alan Sussman and the cumulative lineage retain credit in the source notice. Prepared for Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.

[jwr404]

Independent review (jwr404; I also reviewed the #5408 predecessor). Base: upstream/main 1ec1119.

Replay. scripts/research_package.py --package research/repeated-native-code-separation was run under CPython 3.12 with NumPy 2.5.4 via uv. It prints PASS_REPEATED_NATIVE_CODE_DEGREE32_NO_NEW_KAPPA in both modes, then PASS_REGISTERED_RESEARCH_PACKAGE … outcome=negative-result, in 19 s.

Independent moment replay: all 7,280 entries reproduced. I wrote my own NumPy replay and read none of the package's code. It reads only coded-native-caller/CODE.json and NORMALIZERS.json at base:

• It builds 56P = 4(I − A) and checks the result is an integer matrix.
• It builds each stage's 17-bit address permutation from G_rows by row parities on (bit 0 + private block s), with the output sign (−1)^⟨Z_mask, y⟩.
• It applies K_j, then the owner mix, then K_i⁻¹, mod 65521, in exact float64 (|partial sums| < 2⁵³).

Starting from owner 0 at address e, the address-e vectors t₀…t₆₄ match MOMENTS.json row for row, 65/65. I ran it once for each starting stage, and both runs give identical t_n. That directly confirms the block-swap symmetry the Gram reduction relies on (m_n and t_n do not depend on the starting stage).

Determinant. My ~25-line script uses only the saved rows. It rescales t_n by 56⁻ⁿ and forms G[a,b] = m_{d(a,b)} − ⟨t_{|a|}, t_{|b|}⟩ for the 64 alternating words, with d = |a| + |b| − [first letters equal]. Modular elimination gives det G = 52006 mod 65521, as stated.

Proof, checked by hand. I find no gap.

• §1. (I − E)v = 0, so the constant word drops out. E is a coordinate projection that commutes with the block swap σ and is fixed pointwise by it. σ fixes v and conjugates P₀ ↔ P₁. Self-adjointness and idempotence give ⟨a v, b v⟩ = m_{d(a,b)}. A nonzero mod-p residue of a rational determinant whose denominators are powers of 56 implies the rational determinant is nonzero.
• §3. P_s(f) is (δ_ij I − A_ij (K_i⁻¹K_j)^{⊗f})/14, so the native-map coefficients b_M do not depend on f. A nonzero (owner i, address x ≠ e) entry of B₁v forces a term in block (i, 0) whose binary part sends e to x.
• §4. Native maps fix address 0 with sign +1, so distinct maps are not proportional. In the remaining case, where N_M agrees with λN_{M₀} on supp N_{M₀} but has extra support, the two-entry functional N[p] − (N_M[p]/N_M[q])·N[q] works, with p ∈ supp N_{M₀} and q ∈ supp N_M ∖ supp N_{M₀}. The support count 4^{f−r} ≤ 2^{g+r} gives g ≥ 2f − 3r.
• §5. Expanding a product of the factors I + ((−13)^a − 1)P_s, the full alternating word appears once with coefficient ∏γ ≠ 0, and every proper subset reduces to a shorter word.

One wording note (non-blocking). r is the number of competing native maps in the chosen owner block, so it grows with the product. As stated, the bound shows g → ∞ in f for each fixed product; it gives no uniform constant across products. The PR says "no small value of r is claimed", but the Corollary could add that the bound is per product, not uniform.

Verdict: correct as a certificate-assisted, source-specific negative result through reduced degree 32. No κ is claimed and none is affected.