[DaysSky]

Change and mathematical scope

The p19 coded-reverse chain is materialised, replayed and priced, and the target census it realises is the census the invoice prices. The accepted conditional endpoint is κ = 951999/280000000 = 0.0033999964.

Comparison	Conditional κ gain
Selected record 605457647/200000000000 = 0.003027288235	+12.31%
Earlier record 60403/20000000 = 0.00302015	+12.58%

The complex supplier is 0.007578535190 and the BIT supplier 17/5000 binds the endpoint: at exactly 0.0034 one outer predicate fails (actual_bit_above_effective), so the claim sits five grid steps below it. Guards at the endpoint with the unchanged invoiced census are α 0.995794142, γ 0.963763313, δ 0.951560608; both decay blocks stay under 1/16 and the power-1024 tails under 2^-32. The compiler majorant is shape-correct at v = 1024, h = 1/64, B = (5+8h)v, H0 >= 8v, giving H0 = 5,170,423,668,736 with 20^64 < 21^63 and maximum target rank 153 < 256. All 54 strict and four functional outer predicates are positive.

The word has 259 gates: 19 gauge loads, 20 forward, 19 reverse, 19 letters, 36 retained idles, 108 bridges and 19 closing swaps. It carries 77 recodings, 17,248 monomial field maps, 68,992 scalar adds and 1,232 owned clears, with no recursive Gaussian children. The ambient target rank is 153. Replay against the standard word differs on 0 of 2,179,072 entries at p=19 and 0 of 229,376 at p=2.

Target census

A target is what a role ends holding, an entry of the factorisation diagonal, not the row or column closure of the thinned matrix. Measured on the diagonal, the realised multiset equals the designed one at every tested size.

p	Realised diagonal supports	Designed
3	{1:4, 3:2}	identical
4	{1:4, 2:2, 4:2}	identical
5	{1:4, 2:4, 5:2}	identical
8	{1:4, 2:4, 3:4, 4:2, 8:2}	identical
19	{1:4, 2:4, 3:4, 4:4, 5:4, 6:4, 7:4, 8:4, 9:4, 19:2}	identical

At p=19 this is the invoiced histogram {9:448, 17:448, 25:448, 33:448, 41:448, 49:448, 57:448, 65:448, 73:448, 153:224}. An earlier version of this package measured the row closure, concluded the census did not match, and derived several results from that reading; the row-closure measurement is the wrong observable, and those results are retained only as superseded diagnostics.

Receipts

Receipt	What it establishes
P19_DIAGCENSUS.json	the diagonal target census equals the invoice at p=3,4,5,8,19
P19_LOWERING.json	the gates are the primitive PHYSICAL.md states — R = D∘Q, X ← X − Q·C·Y, C^-1 after Q^-1, gauge cancellation, idle powers
P19_NATIVE_APPLY.json	the frozen base word's event encoding and frame/tariff trace executed: 21,449 records and 20,991 state steps per orientation, frames ending on the recorded final frames, derived profile {1:2201, 2:412, 3:510, 4:127, 5:40, 8:8} and tariff 158,120 forward / 158,168 backward
P19_LIFT.json	operator identity for every block count, by multiplicativity over 263,169 exponent pairs and every axis pair
P19_UNITS.json	19 units, 19 loads / 19 unloads / 19 signed swaps, endpoints [1] and [1,13]
P19_CLAIM.json	guards, compiler ranks, BIT chain and the outer ledger
p19_gates.py	62 checks over the receipts and their pinned hashes

The paid profile is the base program's, derived from its own frozen trace and reused here as an inherited input; it is not derived from a p19 trace. Rank 8 is absent for the same reason the chain emits no CENTRE gate: the PR4929 profile applies and invoice() prices exactly the dict it is given (coded-reverse-controller/verify.py:167-168). The frozen comparison word keeps its eight centre calls, which is why its declared profile shows 8:8.

Limitations

The inherited producer/compiler contract must admit this finite p=19 unit composition with the recorded native lowering, endpoint, field-state, ownership, precision, helper, fixed-tape, compiler-schedule, hosting and review interfaces. P19_PRECOMPILATION.json reports FINDING_PRECOMPILATION_CONTRACT_MISSING: no serialized chain-to-event compiler exists in the repository, so that admission is not discharged here. The macro, forward, reverse and resource receipts are owned-work and operator checks, not native event programs, and none is presented as a compiler. The claim records physical_attachment: CONDITIONAL and kappa_attached_to_physical_chain: false.

Not claimed: unconditional attachment, a proved lowering of this chain to native events, a new selected κ, resolution of the precompilation finding, or any global optimality statement.

Verification

Registered replay PASS_REGISTERED_RESEARCH_PACKAGE outcome=completed against a 980 s four-command budget. The gate table reports 62 checks and no failures; package metadata and pins pass. Python 3.12, standard library only.

Credit

The controller and its invoice model come from research/coded-reverse-controller/ (PR4940 lineage) and the paid profile from the PR4929 construction. The retained native word is research/coded-native-caller/ over research/joint-helper-lattice/; its event specification is research/kappa-lean-verification-20261022/NativeCore.lean with native_generate.py, from the PR4470/PR4610 lineage. The lifting argument and the moment engine are shared with research/higher-moment-strictification/. See those packages for authorship. Prepared with Claude Code assistance; no subagents. New work is Apache-2.0.

[Matarener]

Independent check of the physical binding (Mark / @Matarener, with Claude). Head c0f52b5. No selected-result change proposed.

The priced 259-gate chain applies the full Gaussian R = D·Q as the stage letter to both roles at each of the 19 thick stages (p19_word.py: LETTER … 'R', replay compares with standard(p, v0, 'R', …)). The retained native backward call applies D (rank 8 on the fresh block) with Q only inside the coupling: F = diag(D,D)·L(C Q^-1) in coded-native-caller/PHYSICAL.md. The chain needs R because the gauge C^-1 on the odd roles commutes with R but not with its factors; your own control in p19_claim.py states this ("rank-8 letter does not commute with the code; full Gaussian letter commutes").

With this package's engine and listing at p=2 (letter_test.py, 47 s):

test	differing entries
[Q, C] on a random bank	57,343 / 57,344
[D, C]	57,343
[R, C]	0
coded chain vs standard word, letter R	0 / 229,376 (reproduces the PR)
coded chain vs standard word, letter D (the native letter)	114,681 / 229,376
letter-D chain + one Q^k on every role at the end, k = 0..3	114,681 / 229,374 / 229,375 / 229,375

So the chain is correct only with R; the native call supplies D; the extra Q is one rank-1 Gaussian on each of 224 fields at each of 19 thick stages = 4,256 rank-1 jobs per unit, interleaved with the gauge and not deferrable. invoice(p, pat, thick, prof) has no entry for them (it prices thick stages as 224 × rank-8k plus the base profile), and P19_BRIDGE.json maps LETTER → "warp", i.e. rank 0.

Re-pricing with the package's own invoice: margin at c = 0 is 2,016 rank-mass units of 265,533; +4,256 rank-1 gives no break-even (κ = 0). The invoice tolerates at most 1,103 extra rank-1 jobs before the complex root falls under the 0.0034 BIT gate and 1,202 before it falls under the selected 0.003027288235. This is outcome D of my #5270 comment; the docstring of p19_claim.py cites the overlay numbers (2,128 vs 1,103) and drops the overlay, but the letter itself is the same obstruction.

Minor: P19_SYMBOLIC.json records that the package's own fresh-block census of the main roles "differs" from the invoiced one (336 vs 448 at ranks 9..73, 1,232 vs 224 at rank 153); the lifting lemma works in a commutative monomial ring and cannot see [C, D_s] ≠ 0; on Windows verify.py fails at the P19_NATIVE_APPLY.json hash because the regenerated receipt writes backslash paths (cosmetic).

Scope: p=2 dense replay with the pinned normalizers and code; the p=19 statement follows from the same non-commutation at every stage. If the chain can be rewritten so that the gauge is applied only where the letter is R-realisable without a per-stage Q, or if those 4,256 jobs are admitted and paid, the conclusion changes; otherwise I don't see a path from this chain to κ above the frontier.

[zxv]

Reviewed c0f52b5b18bba78a6a5e8057edf9571bade88549, focusing on the conditional κ claim.

Verdict: the numerical calculation checks out for the stipulated invoice, but I cannot validate κ = 951999/280000000 as an improvement under the retained producer/compiler hypotheses. Admission of this p19 composition at that invoice is an additional, unresolved premise, and the supplied primitive binding has a concrete mismatch.

I ran p19_claim.py successfully, reproduced the raw complex root 0.007578535189897717… independently with 80-digit Decimal arithmetic, and confirmed its endpoint moment/guard, compiler-majorant and outer-ledger checks. The stated endpoint is 0.003399996428571…, with BIT cap 17/5000. These are valid numerical checks of the assumed histograms; they do not establish the billed native implementation.

[P1] The listed full Gaussian is not the retained native call's Gaussian letter. The native backward contract is diag(D,D) [[I,-Q C],[0,I]], with rank-eight D. The listing uses LETTER = R, and p19_lowering.py:57–64 verifies R = D Q, not equality to the supplied native D. Its PASS therefore does not prove that this is the same priced primitive.

I independently reproduced the obstruction in the earlier physical-binding review, using this package's listing, replay, standard and physical-code engine, seed 5, p=2:

Check	Differing entries
[Q,C] on one bank	57,344 / 57,344
[D,C]	57,344 / 57,344
[R,C]	0 / 57,344
Listed R-chain versus its R-reference	0 / 229,376
Substituting native D, versus the D-reference	114,685 / 229,376

The direct repair adds a Q on both 112-field banks at every one of the 19 thick calls: 4,256 rank-one jobs. Keeping all claimed target credits, the resulting invoice fails:

Saving	Original target-minus-paid moment	With those 4,256 jobs
0 (rank mass)	2,016	−2,240
Claimed κ	1,103.277074	−3,152.722926
Selected 605457647/200000000000	1,202.668300	−3,053.331700

This is stronger than a numerical root search. Using the repository's signed concave-order comparator, every positive-rank support breakpoint has
Σ_r (paid_repaired[r] − targets[r]) min(r,k) > 0 (minimum 2,240). Thus this repaired invoice has negative target-minus-paid moment for every r^t, 0<t<1. This does not exclude a different gauge schedule or a cheaper valid lowering; either requires a new proof and complete invoice. It does show that the missing letter cannot simply be paid for while retaining this claim.

The explicit FINDING_PRECOMPILATION_CONTRACT_MISSING, new_p19_condition: true, and kappa_attached_to_physical_chain: false qualifications are appropriate. Please retain this as a numerical model candidate under that new admission premise until an actual chain-to-native lowering and its paid/target census are supplied; the existing lowering receipt does not discharge the gap.

[P2] The committed verifier also rejects its own gain receipt. verify.py:248–249 requires gain_vs_selected_record_percent > 12.5, while both the committed and byte-identically rebuilt P19_CLAIM.json contain 12.312. That predicate is false at this head. Bind the comparison to the current selected record rather than the older 12.58% benchmark.

Validation scope: metadata/source pins pass; the bounded claim replay, independent invoice/concave-order audit and p=2 letter counterexample pass on CPython 3.12.8 / Darwin arm64, with no resource stop under a sampled 1 GiB descendant-RSS limit. I did not complete the full four-command registered replay or re-audit the inherited native/compiler theorem. Hosted replay 40102695556 times out in the first 300-second command; the final gain predicate above is a separate deterministic blocker even if preceding checks finish.

Review performed with OpenAI Codex assistance.

[gvconly]

Independent check of #5440 (κ candidate 0.0033999964)

I re-ran the p19 coded chain with an independent simulator. At p=2 and p=3 it matches #5440's own physical_code, signed_map, gaussian and replay entry for entry. Scripts and logs: https://github.com/gvconly/integer-mult-bounds/tree/check5440/research/pr5440-independent-check (#5440's head c0f52b5b1 plus one directory; standard library only).

What holds: the gate structure. With controller()'s conventions put back, the uncoded listing reproduces research/coded-reverse-controller's controller() exactly. The residual is 0 at p=2 and p=3, in both the collapsed and the fresh-block geometry.

What fails:

1. The 0-residual replay compares the coded listing with a different operator. p19_word.standard() uses:

   • letter R = D·Q;
   • R^k idles on all nine axes;
   • odd bridges role 2j+1 += ∓ role 2j+3.

   controller() is the operator whose census the invoice prices and which p19_bank.py evaluates. It uses:

   • letter D, the PHYSICAL.md primitive X ← D(X − QCY), Y ← DY;
   • D-product idles, thinned in the middle;
   • role 2j+3 += ∓ role 2j+1.

   Using only Price the p19 coded-reverse chain: conditional κ = 0.0033999964 #5440's modules, standard() and controller() differ on 229,372 of 229,376 entries at p=2.

2. With letter D the coded listing is not exact. Price the p19 coded-reverse chain: conditional κ = 0.0033999964 #5440's own replay(..., letter='D') differs from its standard word on 114,688 entries at p=2. With all of controller()'s conventions, the coded listing differs from controller() on 4,804 entries (p=2) and 11,015 (p=3) in the collapsed geometry. This is the fact physical_gauge_lift.py records: C commutes with R, not with D.

3. The invoiced fresh-block geometry (rank 1+8p) is never replayed coded. Price the p19 coded-reverse chain: conditional κ = 0.0033999964 #5440 replays the coded chain only on one nine-axis field, and p19_bank.py replays the uncoded trace only. In fresh-block geometry the coded listing fails under every policy tested. At p=2 I fixed the reverse codes to their own block and ran the other seven code gates over both blocks, 128 assignments:

   • with controller()'s semantics, 0 of 102 completed runs are exact (minimum residual 3,741; 26 runs hit a 30 s cap and are undecided);
   • with Price the p19 coded-reverse chain: conditional κ = 0.0033999964 #5440's semantics, 0 of 128 are exact (minimum residual 4,436).

   This is consistent with research/fresh-stage-code-separation.

4. Paying for the commutation exceeds the margin. Getting R from D needs a central Q on both roles at each reverse stage. That is 224 rank-one jobs, the same count as in research/physical-inverse-pair, or 4,256 per p=19 call. The p=19 invoice has a surplus of 2,016. Its root stays ≥ 0.0034 only up to 1,103 extra rank-one jobs, and above the selected 0.003027288235 only up to 1,202.

5. verify.py at the head exits with ValueError: both gains are recorded. P19_CLAIM.json records 12.312% against Complete coupled-output caller: conditional κ = 0.003027288235 (+5e-12 over #5400) #5413, while the check still requires > 12.5%.

What would settle it: a coded realization of controller() itself (letter D, fresh blocks), exact in the invoiced geometry with every Q/Q⁻¹ job charged. Alternatively, an exact gauge repair costing under about 1,100 rank-one jobs per p=19 call.

G. V. Chudnovsky with Anthropic Claude assistance