Conditional κ = 0.00304057 (+1.3281765e-5 over #5413)

research/p104-productive-controller/PROOF.md

@@ -0,0 +1,212 @@
+# Productive P104 caller and complete conditional cost
+
+This construction gives conditional `kappa = 304057/100000000 = 0.00304057`.
+It changes the complete recursive profile. It does not change the selected
+record. The five retained framework assumptions are native all-column
+implementation, owned erasure, the uniform compiler, precision and tape cost,
+and analytic recovery. This package checks the new finite interfaces and
+all parameters of that conditional calculation. It does not claim an
+unconditional integer multiplication theorem.
+
+## 1. The complete source word
+
+Use Gareth Davidson's PR2305 composition of David Arias's PR2152 coalesced
+P104 word and Cinna Davis's PR2219 private reuse. `local.construct()` rebuilds
+that exact word from its archived source and compares the full report with
+PR2305. It does not run or reuse the old owner-price model. `WORD.json.gz`
+contains the emitted word, all binary frames, all public boundaries and the
+104 retained port indices. It has 25,311 events and 735 independent public
+inputs. The 208 live main fields are X_r and Y_r for the 104 retained indices.
+All other public fields are independent helpers, including the 16 punctured
+main roles. Eight distinct owned lifetime labels can use one physical slot.
+
+At each frame V let Phi_V be the pinned nine-axis native chart. A register
+in frame V contains Phi_V times its logical value. A MOVE applies
+Phi_new Phi_old^(-1). Each ADD or SCALE uses the same frame on every operand.
+COPY reads into a cleared owned field; each final private CLEAR uses the
+retained owned-erasure contract. The exact endpoint is
+
+```text
+X_r -> X_r
+Y_r -> Y_r + X_r        for every retained port r
+h   -> h               for every one of the 527 helpers
+owned -> 0             for all eight owned lifetime labels
+```
+
+The first interpreter checks this matrix on all 743 public and owned rows,
+including arbitrary owned entrance values before initialization. A separate
+interpreter applies the transposed instruction matrices in reverse order.
+It uses dense integer rows with binary denominators. Both checks cover all
+552,049 coefficients, including zeros. The private slot is initialized before
+use and is cleared after use; its peak occupancy is one. It receives no
+productive credit. The source word, correction and reuse are predecessor
+results, not new local circuits.
+
+For each positive width f replace every chart by its factorwise tensor power.
+Every common-chart scalar step still acts on the same logical values, with
+its scalar coefficient outside the tensor power. The frame induction and
+rational endpoint therefore hold at every f. Native phase checks include the
+absolute scalar phase. Equality of an unsigned tableau alone is not used.
+The pinned compiler produces each native recipe; a separate Gaussian
+interpreter checks every Pauli image and the global phase. This establishes
+the ideal linear identities. The retained all-column implementation and
+rounded arithmetic hypotheses remain explicit.
+
+## 2. The local productive interface
+
+All public paths are nested. For each helper h, the complete boundary map
+Phi_final Phi_initial^(-1) has Gaussian rank
+`dim(final) - dim(initial)`. Native lowering checks this rank and supplies
+its two monomial boundary maps. These maps give independent ordinary
+Gaussian targets at these ranks:
+
+```text
+helpers = {4:51, 5:36, 7:24, 8:122, 9:294}
+paid    = {1:2429, 2:557, 3:389, 4:112, 5:108, 6:16, 7:13, 9:1}
+```
+
+There are 527 helper targets and 3,625 paid calls. The paid rank mass is
+5,894. Helper rank mass is 4,174. The main boundary progress is
+`2*104*8 = 1664`, leaving 56 paid private-copy ranks. The unused helper 711
+keeps its paid H9 and its productive H9; they cancel in the moment. It is
+not silently removed from one side of the calculation.
+
+The 2,981 distinct native maps include every paid occurrence and every helper
+boundary. The 208 intrinsic main adapters have rank zero. Their phases give
+these physical maps on port q:
+
+```math
+Q_q=\frac{1+i}{2}I+\frac{1-i}{2}X_q,\qquad
+F_s=D_s\begin{pmatrix}1&0\\Q_q^{-1}&1\end{pmatrix}.
+```
+
+At stage zero, `D_0=H9 Q_q^(-1)`. At later stages D_s acts on eight fresh
+axes. The complete source accepts arbitrary main fields and arbitrary helper
+fields, so this is a full interface, not a main-input subspace restriction.
+Each full call uses a fresh independent helper inventory.
+
+## 3. A forward source supplies both caller orientations
+
+Retain Cinna Davis's literal p16/a7 controller from `joint-helper-lattice`.
+Its 18 full sites formerly used two forward and sixteen backward interfaces.
+Use the inverse of the direct wrapper in Ali Romman's PR5398. Put
+
+```math
+R=\begin{pmatrix}0&1\\-Q^{-2}&0\end{pmatrix},\quad
+B_s=R^{-1}F_sR
+   =D_s\begin{pmatrix}1&-Q\\0&1\end{pmatrix}.
+```
+
+For each backward site, the emitted execution order is
+
+```text
+x <- Q^-2 x
+(x,y) <- (y,-x)
+execute the unchanged complete forward supplier
+y <- Q^2 y
+(x,y) <- (-y,x)
+```
+
+All 18
+full invocations now use the published forward word. No instruction-level
+transpose of its COPY or CLEAR operations is needed. The wrapper acts only
+on the two main fields; every helper and owned exit remains the source exit.
+
+Exact Gaussian arithmetic gives `Q^2=Q^-2=X_q`, with phase +1. It is a native
+address translation, at every positive tensor width. Scalar minus signs stay
+outside tensor substitution. D_s commutes with Q. Thus both signed exchanges
+and both translations are ordinary operations. They add no Gaussian call.
+The full Laurent replay retains Q as a formal invertible variable; it does
+not impose Q^2=I to prove the caller identity.
+
+The physical check binds all 104 ports at all 18 full sites. It checks the
+orthogonal route, inverse route, fixed central direction, four boundary
+contacts and exact cross term. This gives 7,488 boundary contacts in the
+265-axis layout. The 53,248 central-square column checks cover all nine-axis
+columns at every port. Each route changes at most 17 axes. The phase check
+also binds all 3,328 main targets and every whole idle job. If an idle includes
+stage zero, its first eight axes are the actual orthonormal basis of
+q-perpendicular; the residual translation is charged as ordinary work.
+Unused fresh axes are spectators and can be deleted by an injective relabeling.
+
+The 15 thin queries keep the existing paid implementation: initialize an
+owned field, COPY the source, perform Q or Q^-1, ADD to the target, and erase
+the owned field. There is one paid rank-one call per port and no target
+credit for that field. Q^-1 uses a positive Gaussian and its translation.
+The one physical owned slot is reused sequentially by full and thin calls.
+
+## 4. The complete invoice
+
+For each full site add the local paid and helper profiles. For each thin
+site add 104 H1 calls. For each idle with j stages add 208 H(8j) calls.
+Each main Laurent diagonal gives 104 targets of rank `1+8j`.
+A separate count from the two path lengths 7 and 8 gives the same invoice.
+The resulting complete counts are
+
+```text
+paid calls:        69930
+productive fields: 12814 = 18*527 + 32*104
+thin paid calls:    1560
+whole idle jobs:    3120
+rank mass surplus:  760
+maximum target:    145
+maximum paid rank:  72
+```
+
+`RESULT.json` gives both full histograms. Every helper boundary and main target
+has a native map. All COPY paths, source correction, cleanup, thin calls and
+whole idles are included. The old fixed-window owner assignment is not used.
+The retained mixed-target theorem supplies the productive matching and
+uniform recursion from this complete field interface. No new helper output
+is treated as free work without its corresponding paid path.
+
+Two rational interval engines check `sum(T_r*r^(1-k)) - sum(P_r*r^(1-k))`.
+A sign-changing crossing is enclosed in
+`(0.00304057807630, 0.00304057807631)`. This is a bound for the stated profile,
+not an optimum over local words or controllers. The tested saving is
+0.003040575. The claimed kappa 0.00304057 leaves more than 8.0763e-9 to this
+crossing and improves selected 0.003027288235 by 0.000013281765.
+
+The complete tail calculation uses power 1024, cutoff 17, target floor 18,
+offset 1/5, and reserve 1e-10. The paid ratio is less than
+0.999999996781291. The higher-moment ratio is less than 0.965182173 and the
+completion ratio is less than 0.963354733. Both tail ratios are below 0.97;
+`0.97^128 < 1/16`. Splitting and rounding give the strict normalized bound
+`5242880004882813/5242880536870912 < 1`. The old cutoff 20 fails for this
+larger helper inventory and is rejected by a control.
+
+With complement factor 63/64 and logarithm power 1000, the compiler uses
+`H=64215200000000` and `N=2^H`. The integer test exponent is 45,868;
+`(H+1)^1000 < 2^45868`, and the preceding grid point fails. The arithmetic
+checks all 54 strict outer predicates and four functional predicates.
+The retained ordinary BIT saving is 0.0034, above the new complex requirement.
+No stronger BIT result is needed. The uniform compiler word is specified by
+the retained finite algorithm and is not materialized.
+
+## 5. Ordinary work, storage and precision boundary
+
+The source scalar allowance is 217,428 real operations. The route allowance
+counts each paid map, both normalizers for every helper, all intrinsic main
+adapters, all four fresh-stage contacts per port, and the eight owned
+lifetimes. Each fixed map is on at most 17 active axes and has a 1,000-unit
+allowance. The sum is below 10^7 per full call. The global raw allowance is
+184,647,552, below the funded 10^9 bound. It includes thin COPY/ADD/erase,
+scalar boundary programs, all signed exchanges and translations. One owned
+field suffices in addition to the independent public fields. No helper
+initialization assumes its arbitrary dirt is zero.
+
+The source checks fewer than 26,000 events and `1+abs(coefficient) < 2^16`
+for every scalar update. A safe local scalar growth bound is 2^(16*26000).
+Each rank-r tensor Gaussian has row l1 norm at most 2^(rf). The complete
+raw implementation therefore has a conservative growth bound
+`2^(10^9 + R*f)`, where R is the sum of the full paid ranks in RESULT.json.
+Independent local defects can be bounded by the number of raw operations
+and paid calls times this factor. These are finite upper bounds, not sharp
+or attained norms. They include the intermediate growth in the three-ADD
+signed exchange. They provide parameters for the retained precision/tape
+contract; a complete rounded integer multiplier is not executed here.
+
+The claim retains the five framework assumptions stated at the start.
+Normal and optimized Python checks, immutable source authentication, failure
+controls and a Git-free export are verification of this conditional package.
+They are not independent human acceptance or a proof-kernel theorem.

research/p104-productive-controller/README.md

@@ -0,0 +1,141 @@
+# Conditional kappa 0.00304057 from a productive P104 caller
+
+This construction gives **conditional kappa = 304057/100000000 = 0.00304057**.
+It improves the selected
+[PR #5413](https://github.com/CrocSwap/integer-mult-bounds/pull/5413)
+value 0.003027288235 by **0.000013281765**, about **0.439%**. The complete
+recursive profile changes. This is not extra precision on the old crossing.
+The selected files and other contributors' work stay unchanged.
+
+The contribution binds the completed P104 word from
+[PR #2305](https://github.com/CrocSwap/integer-mult-bounds/pull/2305)
+to the current mixed-target recursion. Its 527 independent helper outputs
+receive their actual Gaussian target ranks. An explicit caller uses that
+published forward word at all 18 full sites. Signed exchanges and central-square
+translations supply the sixteen backward interfaces. The word's COPY and
+CLEAR operations do not need an instruction-level transpose.
+
+Read [the proof and full cost boundary](PROOF.md),
+[the complete receipt](RESULT.json), [the emitted local word](WORD.json.gz),
+[the emitted caller](CONTROLLER.json), and [exact source pins](SOURCES.json).
+The source circuit and private reuse are credited predecessor results.
+The new result is their physical caller and complete productive admission.
+
+| Verified quantity | Result |
+| --- | ---: |
+| Independent local public inputs | 735 |
+| Productive helpers per full call | 527 |
+| Owned lifetimes / peak owned fields | 8 / 1 |
+| Full calls / thin calls / whole idle jobs | 18 / 15 / 3,120 |
+| Complete paid calls / productive fields | 69,930 / 12,814 |
+| Complete rank-mass surplus | 760 |
+| Native paid and helper maps / main adapters | 2,981 / 208 |
+| Physical caller boundary contacts | 7,488 |
+| Crossing enclosure | (0.00304057807630, 0.00304057807631) |
+| Tested saving | 0.003040575 |
+| Claimed complete kappa | 0.00304057 |
+
+The proof checks both complete matrices with different arithmetic and
+chronology, exact native phases, each helper boundary, all main targets and
+whole idles, every owned lifetime, and all scalar and route charges. Two
+rational interval engines check the moment. Cutoff 17 and floor 18 fund the
+completion tails; the old cutoff 20 fails. The finite compiler threshold is
+`N = 2^64215200000000`. All 54 strict outer inequalities and four functional
+inequalities pass with the retained ordinary BIT saving 0.0034.
+
+## Reproduce
+
+Use Python 3.12 and the standard library, from the repository root:
+
+```sh
+python3 -B scripts/research_package.py --package research/p104-productive-controller --check-only
+python3 -B scripts/research_package.py --package research/p104-productive-controller
+```
+
+The registered hook runs the full verifier normally and with `-O`. Its final
+marker is:
+
+```text
+PASS_P104_PRODUCTIVE_COMPLETE_KAPPA_00304057
+```
+
+Direct replay needs no Git, network or optimizer:
+
+```sh
+python3 -I -B research/p104-productive-controller/verify.py
+python3 -I -O -B research/p104-productive-controller/verify.py
+```
+
+The source archive is read and authenticated, then copied to temporary
+storage for reconstruction. Normal replay does not write artifacts. The
+explicit `--write` mode rebuilds the three local artifacts. Controls reject a
+missing COPY, a wrong frame, a wrong native phase, an omitted central
+translation, unearned helper credit, the old cutoff, and insufficient BIT
+stock. The compiler grid check rejects its preceding integer point.
+
+## Scope and coordination
+
+The scientific base is canonical main
+`32890bc5de034ab8fc93ac88ead7279a6a416d04`, priority revision 7. The
+[canonical claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154639)
+records this changed cost model. The
+[source handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/2299)
+released the old composition scope and left global binding open. The initial
+fresh cache covered 401 open PRs and 4,828 Discussion records. This scope does
+not take literal-slot P104 repairs, original split-contact charts, global
+border grading, the Global120 constructor or the p19 compiler. Full overlap
+search is coordination evidence, not a novelty theorem.
+
+The bound retains the selected framework assumptions: native all-column
+implementation, owned erasure, uniform compiler, precision and tape cost,
+and analytic recovery. The package supplies ideal uniform frame identities,
+finite growth bounds and all new parameter checks. It does not execute the
+complete rounded multiplier, materialize the enormous uniform compiler word,
+provide a proof-kernel theorem, or claim independent human acceptance.
+No fixed-profile or global optimality claim is made.
+
+## Sources and credit
+
+- **Gareth Davidson**, verified as `bitplane` in the retained source notice,
+  supplied [PR #2305](https://github.com/CrocSwap/integer-mult-bounds/pull/2305),
+  mathematical head `335e78619a17b7c418e11306f86a72fd366de35b`: the exact
+  [composition](https://github.com/CrocSwap/integer-mult-bounds/blob/335e78619a17b7c418e11306f86a72fd366de35b/research/p104-coalesced-private-reuse/compose.py)
+  and its complete local boundary. Its old owner-window price is not reused.
+- **David Arias** supplied the coalesced 735-register word in
+  [PR #2152](https://github.com/CrocSwap/integer-mult-bounds/pull/2152),
+  head `05f7aad0f08992ee48ec2dd93e896d9a4567847d`. The source archive retains
+  the original code, README and attribution unchanged.
+- **Cinna Davis** supplied the private-query reuse in
+  [PR #2219](https://github.com/CrocSwap/integer-mult-bounds/pull/2219)
+  and the productive controller lineage. The pinned
+  [p16 caller](https://github.com/CrocSwap/integer-mult-bounds/blob/32890bc5de034ab8fc93ac88ead7279a6a416d04/research/joint-helper-lattice/CONTROLLER.json)
+  supplies the finite path and boundary matrices.
+- **Ali Romman** supplied the direct conjugation identity in
+  [PR #5398](https://github.com/CrocSwap/integer-mult-bounds/pull/5398).
+  This package uses its inverse to admit only forward invocations.
+- **Jacob Alan Sussman** supplied the mixed-target recursion lineage in
+  [PR #4268](https://github.com/CrocSwap/integer-mult-bounds/pull/4268).
+  **zxv** supplied the retained higher-moment/compiler and outer machinery;
+  **Cao Yifan** supplied the source pricing lineage. Their exact interval
+  engines and outer ledger stay unchanged.
+- The P104 lineage retains **Rohan Arun**'s scalar channel, **Chafik Boukhalfa**'s
+  native binding, **Adam Gall**'s schedule, **Josie Elliston** and **Ali Romman**'s
+  geometry/decoder work, **icekylinx**'s frame compiler, and the PR1042/PR1094
+  scalar architecture. The unchanged source archive and
+  [native notices](https://github.com/CrocSwap/integer-mult-bounds/tree/32890bc5de034ab8fc93ac88ead7279a6a416d04/research/p104-native-channel/notices)
+  retain their earlier contributors and licenses.
+
+New caller, productive binding, independent replay, full cost and package:
+Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0.
+
+## Open next questions
+
+Can the P104 local word reduce its paid profile under productive accounting?
+Its original coalescing optimized a different owner model. Start from the
+emitted word, check active claims, preserve every independent boundary, and
+compare a fully paid change against this complete invoice.
+
+Can an independent review confirm this changed complete admission? The first
+step is the registered cold replay, followed by review of the forward wrapper,
+helper normalizers and compiler. [TASK.json](TASK.json) records these questions
+and their current limits. Neither question reserves work in another chat.