Repository navigation
Certify conditional kappa 0.0033999964 via the p19 word without the coded overlay (complex 0.007578535, BIT 0.0034, zero field bill) - #5270
Conversation
… verification open) Adds the p19 coded-reverse packages: the exact physical thin source and local S/L/R boundary pair, and the materialized controller word with its paid accounting. The word is emitted as an explicit 259-gate listing and replayed against the standard word: 19 gauge loads, 19 unloads, 20 forward stages, 19 reverse stages, 19 letters, 36 retained idle calls, 108 bridges and 19 closing swaps. Replay differs on 0 of 229,376 entries at p=2 and 0 of 2,179,072 at p=19, with the per-role gauge invariant checked after every gate that writes a role. The code is rank-free: every port map is a signed address permutation and the scalar program moves no address, so the 77 recodings cost 17,248 monomial field maps, 68,992 scalar adds and 1,232 owned clears per call and no Gaussian child. The rank invoice prices the word at 0.007578535 under the PR4929 profile and reproduces the published p16 root; the tail ratios at the endpoint are alpha 0.99579414, gamma 0.963763, delta 0.951561. With the admitted BIT saving 0.0034 the strict outer ledger passes at kappa = 951999/280000000 = 0.0033999964 and at exactly 0.0034 fails only actual_bit_above_effective. Draft status: the endpoint rests on the retained PR4433 power majorant (the logarithmic majorant caps the tested saving at 611329/200000000 and that cap is recorded), on the 0.97 tail limit in place of the source's 19/20, and on the 7,752-unit helper block remaining inherited. PR-DRAFT.md lists the open verification items.
|
Independent review of the draft (James Reed, with Claude Code). Head This answers checklist items 1 and 2 and diagnoses the CI failure. Items 3 and 4 (helper disjointness, idle role-rank) and the word replay were not checked. Nothing here endorses a selected-frontier change. 1. Compiler majorant: wrong constants, but fixable, and the κ survives this step
#4416's derivation, which
The comment "changing only the new unit's ranks" refers to re-running that p7 unit at This unit has a different shape.
The correct function is already in a pinned source.
Both premises hold here:
So the power majorant still closes, with ranks about 10× larger. Finite N is all the ledger needs, so I don't see this step killing κ = 951999/280000000. But the receipt should call the query-thinned bound, or an equivalent re-derivation, and drop the "changing only the unit's ranks" justification. The logarithmic route remains genuinely unavailable at Not resolved here: whether the source's finite integer-batch compiler premise ( 2. Tail limit: 0.97 is fineThe source argument (query-thinned PROOF.md §3) uses Replacing 19/20 by 3. CI failure is packaging, not scienceThe hosted
Small consistency issues
Reproduce my arithmetic: a ~40-line exact- |
|
Follow-up (James Reed, with Claude Code). My review above left the word replay unchecked. #5349 now reports that
The three causes are confirmed by reading both sources:
Details: #5349. So the listed word needs correcting and rebinding before the invoice can be attached to it. This is in addition to the compiler-majorant constants from my review. |
|
My agent's feedback, while attempting to integrate this work:
|
|
Observation on the physical binding (Mark / @Matarener, with Claude). Not a theorem; no selected-result change proposed. Following #5349 and zxv's note, I tried to estimate what κ survives once the listing is bound to the actual native call. I believe the obstruction sits earlier than the transcription: at the terminal gauge, and the invoice has no room for it. 1. One role per pair ends with a Q-conjugated code. The retained native backward call is atomic, The p19 listing avoids this only because it applies the full 2. The invoice cannot pay for any of it. With the PR4929 profile, the p19 moment margin at
κ = 0 here means the unit no longer breaks even. For scale: 1103 extra rank-1 units bring the complex root below the 0.0034 BIT cap, 1204 bring it below the selected 0.00302015. Script (standard library)# kappa of the p=19 coded-reverse invoice under four terminal-gauge outcomes (exact census, float root).
from collections import Counter
H = {4: 28, 7: 7, 8: 47, 9: 326}; PROF = {1: 2201, 2: 412, 3: 510, 4: 127, 5: 40}
p, pat, thick = 19, 'I'*9 + 'T'*9, frozenset(range(1, 38, 2))
def invoice():
full = frozenset(range(2*p+1)); T, D, outs = Counter(), Counter(), [full, full]
for i, ch in enumerate(pat, 1):
outs += [frozenset(range(0, 2*i+1)) if ch == 'I' else frozenset(range(2*i, 2*p+1))]*2
for s in outs: T[1+8*len(s & thick)] += 112
for i, ch in enumerate(pat, 1):
D[8*len((frozenset(range(0, 2*i)) if ch == 'I' else frozenset(range(2*i+1, 2*p+1))) & thick)] += 224
for j in range(1, p): D[8*len(frozenset([2*j]) & thick)] += 224
for r, n in H.items(): T[r] += 19*n
for r, n in PROF.items(): D[r] += 19*n
D[1] += 112*(2*p+1-19); T.pop(0, None); D.pop(0, None)
return T, D, [1+8*len(s & thick) for s in outs[0::2]]
def root(T, D):
f = lambda c: sum(n*r**(1-c) for r, n in T.items()) - sum(n*r**(1-c) for r, n in D.items())
if f(0) <= 0: return 0.0
lo, hi = 0.0, 0.05
for _ in range(100):
mid = (lo+hi)/2; lo, hi = (mid, hi) if f(mid) > 0 else (lo, mid)
return lo
T, D, even = invoice()
print('margin at c=0: %d of %d' % (sum(n*r for r, n in T.items()) - sum(n*r for r, n in D.items()), sum(n*r for r, n in T.items())))
print('base root', round(root(T, D), 9))
A = Counter(T); [A.__setitem__(r, A[r]-112) for r in even]
print('A 19 coded banks not admitted as targets ', root(+A, D))
B, DB = Counter(T), Counter(D)
for r in even: B[r] -= 112; B[r-1] += 112; DB[1] += 112
print('B paid Q per owner, then cheap B^-1, credit 8k ', root(+B, +DB))
DC = Counter(D); DC[2] += 112*19
print('C rank-2 decoder child per owner, credit kept ', root(T, +DC))
DD = Counter(D); DD[1] += 224*19
print('D letter R = DQ (one Q per owner-role-stage) ', root(T, +DD))
for lim in (0.0034, 0.00302015):
lo, hi = 0, 10**5
while hi-lo > 1:
m = (lo+hi)//2; X = Counter(D); X[1] += m
lo, hi = (m, hi) if root(T, +X) > lim else (lo, m)
print('extra rank-1 units tolerated before root < %.8f: %d' % (lim, lo))Scope. The gauge argument is a hand derivation from |
…99964) The invoice never sees the code: invoice(p, pattern, thick, profile) takes no coding argument, so the coded reverse was an overlay that adds cost and no price. Two audits showed the cost is unpayable - the physical reverse call is D(X - QCY), so the letter is D while [C,D] and [C,Q] differ from zero, and every coded role leaves a Q^-1 B_i Q terminal gauge: one decoder per owner per thick stage, 2128 rank-1 units against a 1103-unit root budget. No proper subset of coded pairs diagonalises (p = 3, 4, 5), so the code is all-or-nothing and always costs 112*p. This commit replaces the hand-transcribed coded listing with the controller's own gate trace, which is replayed in the controller algebra and required to equal controller() exactly. At p=19 it is 241 gates (20 forward, 19 reverse, 39 stage letters, 36 retained idles of rank 198, 108 bridges, 19 swaps), it diagonalises to the standard outputs with denominators [1], and it carries no recoding bill and no decoder. Also corrected here: the compiler constants. power_majorant_comparison hard-codes the p7 unit (h = 1/7, B = (4+7h)v, H0 >= 7v), whose premises 10 < 2^4 and 121 < 2^7 fail for a unit that splits at 20, completes at 21 and has ambient rank 153. The shape-correct constants of query-thinned-controllers::tail (h = 1/64, B = (5+8h)v, H0 >= 8v) give H0 = 5170423668736 and H1 = 49222448837637726209, with 20^64 < 21^63 and 153 < 256. The 19/20 tail guard is recorded as settled: the source uses its limits only through the 128th-power decay, which closes at 0.97, and gamma also meets the source's stricter 31/32. SOURCES now pins canonical main and no longer declares the companion package, whose only caller was a try-block that could not run without NumPy. Claim: complex supplier 0.007578535, BIT supplier 17/5000, kappa = 951999/280000000 = 0.0033999964, +12.31% over 0.00302728823.
DaysSky
changed the title
… compiler ranks Physical binding is proved by a lifting lemma instead of sampled: Phi from the retained-stage monomial ring to address operators is a ring homomorphism (distinct-axis Gaussians commute, powers add, Phi(1) = I, and every gate kind is the Phi-image of its monomial), so the gate-list identity lifts to address operators for every block count. The p=2 replay stays as a randomised control and is labelled as such. The lemma caught a real bug: monomial selection bits are exponents, so applying one gate per selected stage breaks multiplicativity at exponent 2. Both scripts now use exponent powers. Helper compatibility is discharged mechanically (the trace touches only roles 0..2p-1); the 7752 helper units stay inherited and priced. Compiler obligations are a table: completion and splitting discharged on this census, normalizers/owner allocation/rank-one surplus inherited with the no-new-job argument.
DaysSky
changed the title
|
HANDOFF Research discussion / PR / artifact: Delta-only independent review of the new Exact commit: What is established:
What remains uncertain: Neither check rules out a new adapter, a different producer, a fully priced joint caller, or a cancellation proved for an actual physical whole word. I did not run the submitted p19 routines, the large bank replay, price engine, compiler, or a full global endpoint audit. This review does not accept a new kappa or establish a universal decoder lower bound. Earlier terminal-gauge and budget reviews retain their separate scope. Smallest useful next task: First bind IDLE stage lists to their intended operators and add a retained-terminal control, such as p2 pattern T and the p19 pair17 event. Then exhibit the actual native implementation of the uncoded local step, or an explicit whole-word replacement proof, with every adapter, helper ownership change, ordinary operation, precision and recursive charge included. An ideal-operator lift alone is insufficient for that source-to-invoice bridge. Reproduction command and expected runtime: The following is a minimal illustrative CODE/event calculation, run from this head with its pinned source files. The executed independent checker additionally hash-pins and AST-matches the actual emitter, decoder and retention rule; this snippet alone does not bind that protocol. Neither checker imports a submitted evaluator. Two independent root-guarded checks of the source bindings/zero diagonal and AST/event witness passed in 0.101s and 0.202s respectively, under 5s/128MiB limits. No author replay was run. from pathlib import Path
from fractions import Fraction as F
import hashlib, json
b = Path('research/coded-native-caller/CODE.json').read_bytes()
if hashlib.sha256(b).hexdigest() != '8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0':
raise ValueError('wrong source CODE')
A = [[F(v) for v in row] for row in json.loads(b)['A']]
if len(A) != 112 or any(A[j][j] != 0 for j in range(112)):
raise ValueError('native diagonal witness changed')
sel, thick = (37, 38), set(range(1, 38, 2))
required = {s: 1 for s in sel if s in thick}
decoded = {s: 1 for s, value in enumerate(sel) if value and s in thick}
print(required, decoded) # {37: 1}, {1: 1}Predecessor credit: DaysSky's trace and new lifting work; Dugongue's PR4929 producer; Dillon's PR4933 physical code; Cayden Burkart / SethBurkart123's PR4940 controller; Cinna Davis / 1337isnot1337 and retained native/compiler predecessors. Matarener, jwr404, zxv and #5349/#5385 retain credit for the earlier ABI, transcription, geometry and compiler reviews. This comment contributes a check against the new head and the new IDLE protocol mismatch, not a rediscovery of their earlier claims. Review by Chris R / Clear1nsight with substantial OpenAI Codex assistance. |
Draft. Conditional κ claim whose only remaining assumptions are inherited from the
selected construction. Every obligation that is new to this word is discharged in the
package; the inherited interfaces are consumed unchanged and that is shown, not asserted.
Status against the required bar
p19_claim.py: invoice root 0.007578535, guards, BIT chain, ledgerp19_plain.py: p=19 trace ==controller(), 241 gates, diagonalises with denominators[1]P19_CLAIM.json: 0 recodings, 0 maps, 0 adds, 0 clears, 0 decoderp19_lift.py:Φis a ring homomorphism on the monomial ring (multiplicativity on 24 sampled pairs, powers add, distinct axes commute), so the gate-list identity lifts to address operators for every block count; the p=2 replay is the implementation control, 2^17 addresses per rolemax target rank 153 < 256,20⁶⁴ < 21⁶³0…2p−1; no gate reads or writes helper-owned stateWhat changed since the last revision
field_level_billis emittedall-zero from the uncoded receipt, and the coded overlay is quarantined as
record_only_overlay("historical record, NOT the priced word").verify.pyassertsboth, so they cannot drift apart again.
randomised p=2 replay, and the replay is labelled a control.
gate per selected stage is not multiplicative at exponent 2, which the p=19 word hits
constantly. Both the lemma checker and the replay now use exponent powers.
60403/20000000 = 0.00302015(+12.58 %) and the maintainer-reported0.00302728823(+12.31 %), the former read from
certificates/selected-result.jsonat run time.SOURCES.jsondeclares its base as a historical canonical source snapshot pinned bycommit and blob hashes.
The claim
κ = 951999/280000000 = 0.0033999964 from a complex supplier of 0.007578535 and the
admitted BIT supplier 17/5000. The word is the p=19 controller trace: 241 gates, 39
stage letters, 36 retained idles of rank 198, 108 bridges, 19 closing swaps, and no
code, because the invoice takes no coding argument. The coded overlay is retained as a
record only: its terminal-gauge decoder costs 2,128 rank-1 units against a 1,103-unit
budget, which is why it was dropped.
Reproduce
Reviewer's checklist
identity) suffice for the block decomposition you have in mind, including the shared
centre?
sufficient, or does the word need its own normalizer/owner schedule checked?