Raise conditional kappa to 0.00310045 with independent helper splits

research/p104-helper-subspace-splits/NOTICE

@@ -0,0 +1,21 @@
+New helper-subspace construction, proof and replay:
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+The same assistant performed the construction and author-side checks.
+
+Retained contributions:
+Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source.
+Ali Romman: PR5580 contact step and PR5544/5545 complete P104 caller.
+Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff.
+DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools.
+thu-nmrc: PR5551 contact improvements.
+Gareth Davidson (bitplane): PR2305 source composition.
+David Arias: PR2152 coalesced P104 word.
+Cinna Davis: PR2219 private reuse and the controller lineage.
+Jacob Alan Sussman: productive mixed-target recursion.
+zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage.
+GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept.
+The retained source notices preserve earlier geometry, BIT and analytic credit.
+
+The elementary rank-one basis identity is not claimed as a new general
+linear-algebra theorem. The contribution is its explicit independent-target
+use on this P104 word and the complete conditional kappa improvement.

research/p104-helper-subspace-splits/PROOF.md

@@ -0,0 +1,208 @@
+# Independent helper splits and the complete cost
+
+This proof changes the helper input and output contract of the exact PR5565
+word. It retains every main endpoint, paid Gaussian call and owned lifetime.
+All scalar identities below are over the rationals. The native check supplies
+exact phases and the rule for every positive tensor width.
+
+## 1. A split criterion
+
+Let a group of helpers have the same initial chart U and final chart V.
+The complete source word returns each of these helpers unchanged in normalized
+coordinates and has no helper contribution to any other output.
+Let F be a strict intermediate chart, with U contained in F and F contained
+in V. At one chronological cut, let P be the scalar prefix matrix and S the
+scalar suffix matrix. The matrices include every public input and output.
+Owned fields follow the source initialization and erasure contract.
+
+Suppose a row a and a column b use only fields at chart F. Suppose c and d
+use only the specified helper group, and
+
+```math
+aP=c,\qquad Sb=d,\qquad ab=cd=1.
+```
+
+Choose a helper role p at F. There are invertible scalar matrices G and J
+with
+
+```math
+e_p^T G=c,\quad Gd=e_p,\qquad e_p^T J=a,\quad Jb=e_p.
+```
+
+Here G acts only on helpers with boundary charts U and V. J acts only on
+fields at F. The construction emits these matrices as ADD and dyadic-unit
+SCALE operations. Its row and column elimination uses the unit pairings.
+The emitted program and its inverse are explicit; no dense matrix operation
+is assigned zero implementation cost.
+
+Apply G inverse at the input. At the cut, apply J. Role p then contains the
+independent coordinate t=c h. Retain p as an output at F. Introduce one new
+independent input z at F. Use its new role in place of p in J inverse and in
+the complete suffix. Finally apply G at V, with the same role substitution.
+The suffix state changes by b(z-a P h), so its helper output is
+
+```math
+h+d(z-ch).
+```
+
+The final change of basis gives
+
+```math
+G[h+d(z-ch)]=Gh+e_p(z-t).
+```
+
+Thus the former p coordinate is replaced by the independent z coordinate;
+all other helper coordinates and every main output retain their required
+values. The old t coordinate has already been returned at F. This replaces
+one U-to-V target by a U-to-F target and an F-to-V target.
+
+This uses a new input, not two outputs computed from one input. It does not
+assume a helper is zero. The early output is a public field and stays live
+until the caller returns. The successor input is public from the start and
+is first used at the cut. No new COPY, CLEAR or owned lifetime is introduced.
+The source's owned erasures remain charged under the inherited contract.
+
+All three basis changes use common physical charts. They therefore commute
+with the relevant chart operator. Native normalization gives ranks
+`dim(F)-dim(U)` and `dim(V)-dim(F)` with their exact phases. Scalar coefficients
+stay outside the tensor substitution. The frame induction applies at every
+positive width; it is not a test at width one alone.
+
+## 2. The first explicit split
+
+The source is PR5565 at `9af814164b9dfc21f19ec737959d67cb71488c95`.
+Use the cut after zero-based event 13775, chart 120 of dimension five, and
+pivot 648. The boundary group has initial chart 3 (dimension zero) and final
+chart 127 (dimension nine). With e_r the coordinate at role r, the exact
+vectors are
+
+```math
+a=e_{652}^T,\quad b=e_{652}-e_{648}+e_{650}-e_{649},
+```
+
+```math
+c=e_{652}^T,\quad d=e_{652}-2e_{205}-e_{648}+e_{650}-e_{649}.
+```
+
+The complete prefix gives aP=c; the complete suffix gives Sb=d.
+Both pairings are one. The boundary basis uses six scalar events and the
+local basis uses five. With their inverses, the split adds eighteen ADDs
+and four sign SCALEs. It replaces H9 by independent H5 and H4 targets.
+The full sequence, including each updated event index, is in `SPLITS.json`.
+
+`check_cut` reconstructs each prefix functional and propagates each suffix
+column. It checks that all other input and output coefficients are zero.
+The verifier then checks every public and owned row after each complete
+split. A separate dense-integer transpose replay checks all 571,536 entries
+of the final 756 by 756 interface.
+
+## 3. The complete target change
+
+The thirteen splits are
+
+- six H9 to H4 + H5;
+- five H9 to H2 + H7;
+- two H9 to H1 + H8.
+
+They add 13 independent helper inputs. The source's 735 public fields become
+748, of which 540 are helpers and 208 are main fields. Eight owned lifetime
+roles remain; only one is live at a time. The 25,133 source events become
+25,475. Every source paid occurrence remains, with the same ordered pair of
+charts, rank and ownership. Some register names change to identify the
+successor input. The new local helper profile is
+
+```text
+{1:2, 2:5, 4:89, 5:11, 7:5, 8:16, 9:412}.
+```
+
+The verifier also replays the retained PR5580 source. It checks that PR5565
+changes its local paid profile by `-8H1-H3-2H4+4H5` and its helper profile
+by `-H8+H9`. These source changes are by Pierre-Loic Doulcet (hexapode). The new splits retain
+that paid profile. The earlier fifteen-split component on PR5580 is frozen
+at `31a4de233bbdd65c04c63dc3398ecf0eed8e1375`. Two of its cuts are absent
+from the PR5565 composition, but the lower paid cost gives a larger kappa.
+
+For every 0<t<1 and positive a,b, strict concavity gives
+`a^t+b^t>(a+b)^t`. Each split strictly increases the target moment and leaves
+the paid moment fixed. The signed local target change is
+
+```math
+2H_1+5H_2+6H_4+6H_5+5H_7+2H_8-13H_9.
+```
+
+Its rank mass is zero, as required. A source-bound complete caller, not a
+standalone packing relaxation, supplies the resulting exponent claim.
+
+## 4. Native maps and the caller
+
+The exact signed-Pauli and phase verifiers check every paid chart change,
+every helper target and every main adapter. The local replay checks a strict
+nested chart relation on each public move and the source's descending owned
+moves. Each helper target is strictly productive.
+
+Cinna Davis's p16/a7 controller and Ali Romman's all-forward implementation
+from PR5544 remain literal inputs. All 18 full calls use the new local word
+with fresh independent helpers. Sixteen backward main interfaces use the
+retained signed exchanges and central-square translations. These wrappers
+act only on the main pair. They do not alter a new helper output.
+
+The physical caller check retains all 104 central ports, 7,488 boundary
+contacts, 53,248 central-square column checks, 3,328 main Gaussian targets,
+15 thin query sites and 3,120 whole idle jobs. It checks native routes,
+spectators, exact phases and every whole target. The complete counts are
+
+```text
+paid calls:         66726
+productive fields:  13048 = 18*540 + 32*104
+rank mass surplus:  760
+maximum target:     145
+maximum paid rank:  72
+```
+
+The invoice is counted twice, once from literal events and once from the
+controller path lengths. Input and output normalizers, added scalar basis
+operations, routes, owned allocation and erasure, queries and idles are all
+included. The new independent field count enters the completion-tail bound.
+It is not left at the old 12,814 value.
+
+## 5. Strictification, compiler and outer transfer
+
+Two independent rational interval engines evaluate the complete moments.
+The exact raw crossing is in (0.00310045630724, 0.00310045630725).
+`RESULT.json` gives its rational endpoints and the strict tested margin. The claimed kappa is 0.00310045 and the tested saving is
+0.0031004505. Their gap funds the finite compiler and outer parameters. An exact negative
+derivative bound on [0,0.0034] makes this crossing the raw ceiling for this
+fixed invoice under the retained BIT cap. It is not a global optimum.
+
+Power 1024, cutoff 17, target floor 18 and tail offset 1/5 are retained.
+The extra independent fields require a different tail bound: both charged
+tail ratios are below 39/40, and `(39/40)^128 < 1/16`. Eight such blocks still
+give the retained `2^-32` remainder. The fixed reserve is `10^-10`.
+The complete normalized cost is strictly less than one. The old cutoff 20
+fails and is retained as a control.
+
+The compiler checks its finite integer threshold, initial range, shifted
+exits, complement capacity, logarithm power 1024 and predecessor integer point. The old logarithm
+power 1000 does not meet the new complement-capacity inequality.
+The ordinary BIT saving remains 0.0034. All 54 strict outer conditions and
+four functional conditions are checked with exact rational arithmetic.
+The scalar growth bound uses fewer than 26,000 local operations and the
+retained per-operation bound. The native growth bound uses the actual sum
+of local paid ranks. The complete ordinary-work allowance remains below
+`10^9`; the local scalar and route allowance remains below `10^7` per call.
+
+## 6. Scope of acceptance
+
+The five selected framework assumptions remain: native implementation at
+all widths, owned erasure, uniform compiler closure, precision and tape
+cost, and analytic integer recovery. The source helper-endpoint contract
+also remains. This package proves the new finite interface, the chart
+identities and every new numerical condition within that framework.
+
+The enormous uniform word and complete rounded multiplier are not
+materialized. These are author-side checks by the same AI-assisted author.
+They are not independent human acceptance or a proof-kernel theorem.
+The final exact discovery screen tests 52 boundary groups and finds no
+further candidate in its finite basis-pair class. It does not prove a maximum
+over bases, cuts, scalar programs,
+frames, controllers or multiplication algorithms.

research/p104-helper-subspace-splits/README.md

@@ -0,0 +1,167 @@
+# Conditional kappa 0.00310045 from independent helper splits
+
+This construction raises complete conditional **kappa to 0.00310045**.
+The gain over [PR5565](https://github.com/CrocSwap/integer-mult-bounds/pull/5565)
+(0.00308520) is **0.00001525**, about **0.4943%**. The gain over selected
+0.003027288235 is **0.000073161765**. The selected record is unchanged.
+
+The mechanism changes the independent helper basis. At a common-frame cut,
+one helper combination can finish early and a fresh independent input can
+use the remaining program. Thirteen explicit splits replace 527 helper
+jobs by 540 helper jobs. They add 342 scalar events and no recursive Gaussian
+call. Both input and output support are checked over every field; a local
+pure row alone does not earn a new target.
+
+Read the [proof](PROOF.md), [exact cuts](SPLITS.json), [complete word](WORD.json.gz),
+[receipt](RESULT.json), [source pins](SOURCES.json), and [validation record](VALIDATION.md).
+The first split is an explicit 22-event change from one H9 target to independent
+H5 and H4 targets. The complete caller uses the new word at all 18 full sites.
+
+| Quantity | Result |
+| --- | ---: |
+| Local public inputs | 748 |
+| Independent helpers per full call | 540 |
+| Owned lifetimes / peak owned fields | 8 / 1 |
+| Local events | 25,475 |
+| Complete paid calls | 66,726, unchanged |
+| Complete productive fields | 13,048 |
+| Complete rank-mass surplus | 760, unchanged |
+| Tested saving | 0.0031004505 |
+| Complete conditional kappa | 0.00310045 |
+| Raw crossing | (0.00310045630724, 0.00310045630725) |
+| Exact native maps | 2,923 |
+
+The added helpers enter the complete completion-tail calculation. The tail
+bound changes to 39/40, with `(39/40)^128 < 1/16`. The compiler logarithm
+power changes from 1000 to 1024. Every native map, helper normalizer, main
+adapter, scalar basis operation, route, COPY/CLEAR cost, thin query and
+whole idle is included. The ordinary BIT saving remains 0.0034. Two exact
+moment engines and all 54 strict plus four functional outer conditions are
+checked. The receipt gives the raw crossing and the finite compiler threshold.
+A negative derivative bound supplies the raw ceiling for this fixed invoice
+on [0,0.0034]; it does not bound other constructions.
+
+## Reproduce
+
+Use Python 3.12 and the standard library, from the repository root:
+
+```sh
+python3 -B scripts/research_package.py --package research/p104-helper-subspace-splits --check-only
+python3 -B scripts/research_package.py --package research/p104-helper-subspace-splits
+```
+
+The registered hook runs normally and with `-O`. Its success markers are
+`PASS_P104_HELPER_SUBSPACE_KAPPA_00310045` and
+`PASS_REGISTERED_RESEARCH_PACKAGE`. Direct replay needs no Git or network:
+
+```sh
+python3 -I -B research/p104-helper-subspace-splits/verify.py
+python3 -I -O -B research/p104-helper-subspace-splits/verify.py
+```
+
+Normal replay is read-only. `--write` explicitly regenerates the two result
+artifacts. Inputs are authenticated before imported source code executes.
+Each replay uses a fresh bytecode-cache path. The checks reject contaminated
+prefix and suffix vectors, missing boundary basis operations, an unearned
+whole target, extra helper credit, a missing paid call, a wrong native phase,
+a missing central translation, an inadequate cutoff and insufficient BIT stock.
+
+## Scope and coordination
+
+The scientific base is canonical main
+`5e0052ca0aa3036a3afa8b0438927377c8d97d53`, priority revision 7.
+The [canonical claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19183208)
+records the changed question and local screens. The final publication overlap
+cache covered 334 open PRs and 4,863 Discussion records, with complete remote
+pagination and incomplete sparse local coverage. Source and coverage details
+are coordination evidence, not a novelty proof.
+
+The consumed PR5565 word is pinned to
+`9af814164b9dfc21f19ec737959d67cb71488c95`. It includes Pierre-Loic Doulcet's published
+commuting-contact cascade and the released PR5580/PR5569/PR5561 lineage.
+The source copy is retained in this branch at commit
+`bf64e66656843a64e798b8374cd9f53add3f6f46`. Its SHA256 and Git blob match
+the recorded PR5565 source. The PR5580 copy remains an active comparison
+input: replay checks the exact paid and helper changes supplied by PR5565.
+Registered replay needs this branch history and its main base; it does not
+need cached objects from unmerged PR branches.
+
+The earlier fifteen-split component on PR5580 remains frozen at
+`31a4de233bbdd65c04c63dc3398ecf0eed8e1375`. Two cuts are absent from this
+composition. PR5565's lower paid cost more than offsets that lost target
+gain. The complete claim increases by 0.00000206 over that component.
+This package introduces no new commuting-contact search.
+No new Gaussian itinerary is introduced. Active frame-extension work in
+[Discussion5575](https://github.com/CrocSwap/integer-mult-bounds/discussions/5575)
+is a separate investigation.
+
+The final refresh also found [parallel coupled-basis and handoff work](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154639).
+It uses the same rank-one mechanism and separately changes paid boundary
+work. The [public composition handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19183908)
+releases the earlier fifteen cuts and leaves the six paid-boundary changes
+with the parallel claim. That claim is testing their composition. This
+package composes only the released PR5565 source with helper splits. No
+exclusive method novelty or gain from the parallel paid changes is claimed.
+The new scalar contacts and input count change the hypotheses of
+[PR5590](https://github.com/CrocSwap/integer-mult-bounds/pull/5590)’s fixed-contact floor.
+
+The scope changes the scalar word, the input count and the target contract.
+It therefore differs from a scalar-only simplification or a fixed-input
+helper stop. The unchanged paid histogram now supports a different,
+fully independent target histogram.
+
+The five selected framework assumptions remain: native implementation at
+all widths, owned erasure, uniform compiler closure, precision and tape cost,
+and analytic recovery. The helper-endpoint contract also remains.
+The complete rounded multiplier and enormous uniform compiler word are not
+materialized. The same AI-assisted author constructed and checked this
+package. Independent human review, proof-kernel acceptance and global
+optimality are not claimed.
+
+## Sources and credit
+
+- **Pierre-Loic Doulcet / hexapode**: [PR5565](https://github.com/CrocSwap/integer-mult-bounds/pull/5565)
+  supplies the exact commuting-contact source word.
+- **Ali Romman**: [PR5580](https://github.com/CrocSwap/integer-mult-bounds/pull/5580)
+  supplies its preceding contact step; [PR5544](https://github.com/CrocSwap/integer-mult-bounds/pull/5544)
+  and [PR5545](https://github.com/CrocSwap/integer-mult-bounds/pull/5545) supply
+  the complete P104 caller and source replay.
+- **Joel Pulikkan / GamingPuzzled**: [PR5569](https://github.com/CrocSwap/integer-mult-bounds/pull/5569)
+  supplies the priced helper handoff; [PR5472](https://github.com/CrocSwap/integer-mult-bounds/pull/5472)
+  supplies an earlier successor-handoff construction.
+- **DreamingOfClouds**: [PR5561](https://github.com/CrocSwap/integer-mult-bounds/pull/5561)
+  supplies free helper endpoints and PR5568 supplies search tools.
+  **thu-nmrc** supplies the PR5551 contact improvements.
+- **Gareth Davidson / bitplane**, **David Arias** and **Cinna Davis** supply
+  the PR2305 composition, PR2152 coalesced word and PR2219 private reuse.
+  Cinna Davis also supplies the controller lineage.
+- **Jacob Alan Sussman** supplies productive mixed-target recursion.
+  **zxv** and **Cao Yifan** supply the retained interval, compiler and
+  native/pricing lineage. Source notices preserve earlier geometry, BIT
+  and analytic credit.
+
+The elementary rank-one basis identity is not claimed as a new general
+linear-algebra theorem. The contribution is this explicit independent-target
+construction and its complete conditional price. New work is by Ali Romman
+with substantial OpenAI Codex assistance; no subagents. Apache-2.0.
+See [NOTICE](NOTICE).
+
+## Open next questions
+
+An independent reviewer can check the first split and then replay the complete
+package. Further gains could use a different compatible cut order, basis or
+frame itinerary. Both prefix and suffix support must be proved before a
+new target receives credit. The finite discovery screen does not establish a global
+maximum. [TASK.json](TASK.json) gives the first checks and remaining obligations.
+
+The optional continuation screen is reproducible with:
+
+```sh
+python3 -I -B research/p104-helper-subspace-splits/search.py
+```
+
+It tests exact elimination-basis pairs at cuts immediately after MOVE events,
+inside equal-boundary helper groups. On the final word it finds no further
+candidate in 52 groups. This result covers those tested pairs. It does not
+exclude different cut sequences, arbitrary basis combinations or new frames.
+The complete-kappa verifier does not depend on a discovery search failure.