Conditional kappa 0.00308326 (+1.37e-6 over #5580): compensated shared P104 relay

research/p104-shared-residual-relay/LITERAL-CHANGES.diff

@@ -0,0 +1,31 @@
+--- PR5580/pricing.py
++++ p104-shared-residual-relay/pricing.py
+@@ -11,8 +11,8 @@
+ from fractions import Fraction as Q
+ import local as L
+
+-KAPPA, TESTED = Q('.00308189'), Q('.0030818905')
+-PREVIOUS = Q('.00308181')
++KAPPA, TESTED = Q('.00308326'), Q('.0030832605')
++PREVIOUS = Q('.00308189')
+
+
+ def encode(x):
+@@ -61,7 +61,7 @@
+             second_p[8*(j+1)] += 208
+     L.need((targets,paid) == (second_t,second_p), 'Independent full invoice')
+     L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks')
+-    L.need(sum(targets.values()) == 12814 and sum(paid.values()) == 66852, 'Complete field and call counts')
++    L.need(sum(targets.values()) == 12814 and sum(paid.values()) == 66816, 'Complete field and call counts')
+     L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus')
+     return targets,paid,counts
+
+@@ -139,7 +139,7 @@
+     L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory')
+     bad=outer_module.ledger(dict(params,bit_saving=Q('.0027')))
+     L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected')
+-    return encode({'kappa':KAPPA,'kappa_decimal':'.00308189','previous_open_pr5569':PREVIOUS,'gain':KAPPA-PREVIOUS,
++    return encode({'kappa':KAPPA,'kappa_decimal':'.00308326','previous_open_pr5580':PREVIOUS,'gain':KAPPA-PREVIOUS,
+                    'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],
+                    'raw_headroom':[lower-KAPPA,upper-KAPPA],'margin_at_previous':E.display(margin(PREVIOUS)),
+                    'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),

research/p104-shared-residual-relay/PROOF.md

@@ -0,0 +1,101 @@
+# A shared dirty public relay for two P104 owned deliveries
+
+This note describes the scalar and frame mechanism for the exact PR5580 word
+at head `6efa248cf456d6101d757e9d09ba29711d18a13a`. Source event numbers below
+refer to that word. The scalar argument below is complemented by the package verifier's complete
+native, ordinary-cost, productive-credit, caller and analytic predicate checks.
+Their inherited theorem assumptions remain as stated in the README.
+
+Let `P` be the unchanged public row133 copied into owned738. That owned field
+holds `-P/2`. Its three higher contacts add `P/2` to159, `-P` to203, and `-P`
+to148 before it reaches its final line597. We retain the159 contact and replace
+the other two contacts by one joint correction in the later public circuit.
+
+## The public relay
+
+The original public row734 at line597 is `x734-P/2`, where `x734` is its
+arbitrary original zero-frame input. Public row587 is unchanged before its
+first ascent, so after its original ADD from734 it contains
+
+`x587 - 4 x734 + 2 P = N + 2 P`, with `N = x587 - 4 x734`.
+
+The last read of587 while it is at zero is source event13610. Consequently
+its original events14633–14634 can be moved immediately after13610. The
+relay's next original frame773 contains frame652, so split its original
+line597-to773 ascent through652. At frame652, immediately after source
+event14010, insert `ADD 21,587,+1`.
+
+An exact rational suffix propagation gives the following useful identity:
+omitting the203 and148 owned reads, then inserting `2P` into21 at this
+point, leaves every non-full-nine-dimensional final public row unchanged.
+The actual relay inserts `2P+N`, so its only remaining error on those rows is
+`u N`, where
+
+`u = (e123 - e148 - e175 - e182 + e203 - e223)/2`.
+
+This is a joint identity. Neither owned contact is deleted on its own, and
+the relay is allowed to change an intermediate public dependency.
+
+## Exact treatment of the arbitrary nuisance inputs
+
+No helper input is assumed zero. All six fields in the support of `u` start
+at the zero frame. The full unchanged word maps their initial-direction
+combination `u` to the same combination on its non-full-nine-dimensional
+outputs. Also `N(u)=0`, because `N` uses only input fields587 and734.
+
+Precompose the word with `I-uN`: for each of those six initial fields,
+subtract its coefficient in `u` times `x587-4x734`. Twelve explicit
+common-zero-frame ADDs implement this transformation. Its source fields
+are disjoint from its destinations, so sequential implementation has no
+feedback. The inverse is `I+uN`. This cancels the entire `uN` output error
+for arbitrary values of all735 public inputs.
+
+After this preconditioning, compare the two words immediately before the
+original event24461, the first late cleanup update of row133. Exactly six
+public rows differ:
+
+* Rows21 and47 have an extra `P+N/2`.
+* Rows434,435,436,437 lack `P+N/2`.
+
+All six targets and sources133,587,734 are then at the full frame127.
+The three sources are exactly `P`, `x587`, `x734`; this is checked from
+their full original-input covectors. Eighteen explicit common-frame ADDs
+remove the six errors without modifying these sources. The remaining
+suffix is unchanged, so every final public row agrees exactly.
+
+## Transport saving and verification boundary
+
+Removing the two owned contacts replaces the owned ranks1,3,2 after159 by
+one rank6 descent. The new public587 stop replaces one rank3 ascent by
+ranks1 and2. This first changes the complete MOVE histogram by `H6-2H3`.
+
+The removed148 contact also makes its intermediate frame596 unused. Its
+original events13416 and14017 are public MOVEs467-to596 and596-to655,
+with ranks1 and2. No scalar read or write of148 remains between them.
+Remove the first MOVE and replace the second by467-to655, of rank3. A
+complete per-role adjacency audit, counting scalar source reads as well as
+writes, finds no further unused intermediate MOVE frame in the new word.
+The strongest verified complete histogram change is therefore
+
+`H6 - H1 - H2 - H3`.
+
+For `H_r(t)=r^t` and `0<t<1`, this is strictly negative by strict
+subadditivity: `(1+2+3)^t < 1^t+2^t+3^t`. This transport comparison alone does not
+establish a new full project bound.
+
+The explicit construction adds29 scalar ADDs and removes two MOVEs, for
+25167 events compared with the source's25140. It uses
+the same735 public fields, eight owned lifetimes, and owned peak1. No new
+owned storage or free nuisance erasure is required. Public endpoints,
+common frames, containment directions, and cleared owned outputs are
+unchanged. Independent exact replay compares all735 original-input columns
+and all743 final scalar rows, rather than testing sampled inputs.
+
+The submitted `construct.py` deterministically realizes these edits. The
+verifier reconstructs its complete payload from the frozen source and checks
+all final rows, signed native maps and the complete caller. The registered
+receipt supplies the exact conditional pricing and fixed-invoice ceiling.
+
+Prepared for flyingviper with substantial OpenAI Codex assistance and
+independent agent derivations. The underlying P104 word and retained
+source lineage are credited in README.md. Apache-2.0.

research/p104-shared-residual-relay/README.md

@@ -0,0 +1,132 @@
+# Conditional kappa 0.00308326 from a shared dirty public relay
+
+This construction raises the complete conditional kappa from **0.00308189** in
+[PR #5580](https://github.com/CrocSwap/integer-mult-bounds/pull/5580) to
+**0.00308326**, a claimed-endpoint gain of **0.00000137**. It replaces two owned
+deliveries by a shared public relay, then exactly compensates the relay's
+arbitrary initial inputs. The complete paid profile changes; this is not an
+improvement obtained by reporting more root digits or fewer scalar additions.
+
+For each of 18 local calls, the paid change is `H6 - H1 - H2 - H3`, where
+`Hr(t) = r^t`. Strict subadditivity makes this negative for every `0 < t < 1`.
+The complete bill has **66,816 paid jobs** and **12,814 productive targets**.
+All public endpoints and productive targets are unchanged. There are still
+735 arbitrary public inputs, eight owned lifetimes and owned peak one.
+The 25,167-event local word adds 29 ADDs and removes two MOVEs relative to
+the 25,140-event source; it remains below the inherited 26,000-event bound.
+
+Read [PROOF.md](PROOF.md), the deterministic [construction](construct.py),
+the [complete verifier](verify.py), and [RESULT.json](RESULT.json).
+The exact raw crossing lies in **(0.00308326461942, 0.00308326461943)**;
+the claimed endpoint is tested at 0.0030832605. The raw crossing gain over
+the source lies in (0.00000136965075, 0.00000136965077).
+
+## Mechanism and scope
+
+Public helper 587 already acquires twice the useful signal together with an
+arbitrary nuisance value. Moving this existing preparation earlier lets one
+new contact replace the two owned reads into 203 and 148. Twelve initial
+zero-frame ADDs cancel the nuisance at the lower-dimensional endpoints;
+18 later full-frame ADDs restore the remaining outputs. Here zero-frame means
+a zero-dimensional chart, **not a zero-valued input**. The input correction is
+explicitly invertible. No clean helper, free erasure or extra storage is assumed.
+
+Removing the 148 read also makes one intermediate public frame unused. Its two
+adjacent transports contract to one. The relay and this contraction are both
+included in the claimed profile and all verification below.
+
+This changes public scalar dependencies and therefore lies outside the
+fixed-contact shortest-path scope of
+[PR #5590](https://github.com/CrocSwap/integer-mult-bounds/pull/5590), and outside
+the fixed joint boundary studied in
+[PR #5591](https://github.com/CrocSwap/integer-mult-bounds/pull/5591).
+It is a small constructive P104 improvement, not a new controller or a claim
+of optimality. The selected record is untouched.
+
+The prepublication refresh found stronger concurrent claims:
+[PR #5565](https://github.com/CrocSwap/integer-mult-bounds/pull/5565) reports
+0.00308520 from a commuting-contact cascade, and
+[PR #5599](https://github.com/CrocSwap/integer-mult-bounds/pull/5599) reports
+0.00309839 from independent helper splits. This package therefore does **not**
+claim to be the best current pending P104 endpoint. It isolates a different
+paid-profile mechanism. Composition with those proposals requires an exact
+combined word, target inventory and complete caller/price replay; their
+headline gains must not simply be added.
+
+
+## Reproduce
+
+Python 3.12 and its standard library suffice. From the repository root:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/p104-shared-residual-relay
+```
+
+The registered normal and optimized modes each print
+`PASS_P104_SHARED_RESIDUAL_KAPPA_00308326`, followed by the launcher's
+`PASS_REGISTERED_RESEARCH_PACKAGE`. The complete checks authenticate source
+bytes and all 33 dependency payloads, regenerate every word field, replay all
+743 final rows on all 735 arbitrary inputs, check the dense transpose and
+2,918 distinct signed native maps, replay the physical caller, and check both
+rational interval engines, the compiler and all 58 outer predicates. Five
+negative controls reject missing initial/final corrections, a wrong relay
+coefficient, missing transport and an unchanged claimed invoice.
+
+Source bytes and provenance are recorded in [SOURCES.json](SOURCES.json).
+The PR5580 word, pricing source and loader, and the PR5545 source closure are
+retained unchanged. Regenerated gzip output is compared by its entire parsed
+payload, not by a platform-dependent compressed-byte hash. The five pricing
+declaration edits are shown in [LITERAL-CHANGES.diff](LITERAL-CHANGES.diff);
+the inherited mathematical tests are unmodified.
+
+## Limits and ceiling
+
+The inherited framework assumptions remain: native all-column implementation,
+owned erasure, uniform compiler closure, precision and fixed-tape costs, and
+analytic recovery. Independent acceptance of the source's helper-endpoint
+contract is still required. The uniform word and complete rounded multiplier
+are not materialized. This is an exact finite certificate and conditional
+bound calculation, not proof-kernel verification of the multiplication theorem.
+
+The verifier proves that this fixed invoice has strictly decreasing signed
+moment on [0, 0.0034]. Its funding ceiling is the raw crossing above. Remaining
+headroom above the claimed endpoint is between 4.61942e-9 and 4.61943e-9.
+That ceiling does not constrain other words, dependencies or suppliers.
+Larger proposed numerical endpoints with unresolved additional compiler or
+attachment premises are not asserted to be weaker than this result.
+
+## Independent checks and credit
+
+Three separately tasked Codex agents derived or checked the dirty-relay
+identity, invertible initial correction, full-frame residual and final
+unused-frame contraction. The shared-owned and literature agents independently built words matching
+the submitted generator's complete payload. A third agent used a differently
+ordered equivalent construction and directly replayed the submitted word. The root ran the full native/caller/pricing
+verification. These are independent agent calculations, not independent human
+review or independent implementations of every inherited framework check.
+
+The base is canonical main `5e0052ca0aa3036a3afa8b0438927377c8d97d53`.
+The source is Ali Romman's PR5580 at
+`6efa248cf456d6101d757e9d09ba29711d18a13a`. His source preserves credit to:
+Joel Pulikkan (@GamingPuzzled) for the PR5569 helper-706 handoff and PR5472
+successor handoff; @DreamingOfClouds for the PR5561 free-endpoint word and
+event-level toolkit; @thu-nmrc for PR5551 coupled contacts; Ali Romman for
+PR5544/PR5545 caller and closure; Gareth Davidson, David Arias and Cinna Davis
+for the P104 word, coalescing and private reuse; Cinna Davis for the controller;
+Jacob Alan Sussman for productive recursion; and zxv and Cao Yifan for the
+interval, compiler and native framework. Earlier geometry, BIT and analytic
+notices remain in the unchanged source capsule.
+
+New construction, proof and verification prepared for flyingviper with
+substantial OpenAI Codex assistance and independent agents. Apache-2.0.
+
+## Open next questions
+
+Can coupled relays replace further owned reads while allowing their nuisance
+terms to be cancelled at the common initial frame? First test the changed
+word's exact endpoint map on every nonzero-frame input; a free correction of
+helper-only nuisance cannot repair a remaining live-input obstruction. Only
+then construct an invertible initial correction, restore full-frame outputs
+and price every changed transport. Independent review of this construction
+and the inherited framework obligations remains valuable. Structured next
+questions and the refined task scope are in [TASK.json](TASK.json).