P104: classify rational owned recodings and prove a joint sharing floor (no kappa)

research/p104-owned-coding-boundaries/JOINT-BOUNDARY.md

@@ -0,0 +1,124 @@
+# A joint moment floor for the complete eight-owned-block boundary
+
+Source: PR5580 head `6efa248cf456d6101d757e9d09ba29711d18a13a`, compressed word
+SHA256 `b2a98c4bd0dbe86c09e9d15ee060dcf1aab09dbef90aa1e2127676f4039f406b`.
+No new kappa or construction is claimed.
+
+## The deliberately enlarged boundary
+
+The replacement interval is `[13378,13485)` in the source program, from the
+first owned INIT to just after the last owned CLEAR. Its public boundary has
+41 roles: eight distinct copied producers and 33 distinct recipients. No
+other public role is read or modified within the literal interval.
+
+Treat these 41 public entry values as independent coordinates. The verifier
+checks that their actual prefix rows have rank41 on original arbitrary public
+inputs. It also checks that the fixed suffix observes all41 public coordinates
+with column rank41. Therefore an exact whole-word replacement using only these
+roles must implement the same local public map: from `S(R-T)P=0`, right and left
+inverses imply `R=T`. It may not rely on correlated values in outside registers.
+
+Every producer enters and exits at dimension8. Every recipient keeps its own
+arbitrary input and gains a nonzero multiple of exactly one producer. For each
+producer, at least one recipient exits at dimension1. Projection of these eight
+observations onto the eight independent producer coordinates has rank8.
+
+An allowed replacement can change every internal scalar dependency, introduce
+arbitrarily many zero-initialized owned fields, share private work across all
+eight original lifetimes, and use arbitrary rational scalar operations. It
+must preserve all public entry/exit values and frames, clear private outputs,
+use common-frame scalar operations, ascending public transports and paid
+descending owned transports. It introduces no public helper or new productive
+credit. This is stronger than seven separate fixed-star theorems, but weaker
+than a global lower bound allowing earlier preparation or outside information.
+
+## Seven information cuts
+
+Fix a dimension threshold `k` in `{2,3,4,5,6,7,8}`. Project every current scalar
+value onto its eight producer coordinates. Let `V_k` be the span of every such
+projected row ever observed in a register with frame dimension less than k.
+The span retains past observations after storage is erased or moved away.
+
+Initially `V_k=0`: the only boundary coordinates containing producer information
+are the eight producer registers themselves, all at dimension8. Other input
+coordinates are independent recipient values, whose producer projections vanish.
+
+Scalar combinations at a common frame below k do not enlarge `V_k`. Operations
+above k stay above k. INIT is zero, CLEAR cannot add information, and a public
+ascent cannot carry information from above the threshold to below it. Only an
+owned descent from dimension `a>=k` to `b<k` can enlarge the span. That event
+transports one scalar row, so increases the span's rank by at most one.
+
+The final eight dimension1 observations have producer-projection rank8.
+Consequently every allowed replacement has at least eight owned descents
+crossing each of these seven thresholds. This argument permits sequential
+outputs, arbitrary private erasure, multiple private fields and shared work.
+
+## Convert crossing counts to the recursive moment
+
+Let `H_r(t)=r^t` for `0<t<=1`. An owned transport of rank `r=a-b` crosses
+`c=#{k in {2,...,8}: b<k<=a}` of the seven thresholds, where
+`c<=min(r,7)`. For every positive integer r,
+
+```
+H_r(t) >= c * 7^(t-1).
+```
+
+For `r<=7`, this follows from `r^(t-1)>=7^(t-1)` and `c<=r`. For `r>=7`,
+it follows from `r^t>=7^t` and `c<=7`. Summing over all owned transports and
+then summing the seven rank-eight cut requirements gives
+
+```
+total owned paid moment >= 56 * 7^(t-1) = 8 H7(t).
+```
+
+The source's public boundary has total ascending dimension change31, spread
+over31 fields each changing by one dimension. Every physical public field must
+retain its own endpoint. Its required rank-one ascent costs H1, independently
+of the owned transports counted above. Thus every replacement pays at least
+
+```
+31 H1(t) + 8 H7(t).
+```
+
+The literal word instead pays
+
+```
+33 H1(t) + H2(t) + H3(t) + 7 H7(t).
+```
+
+Therefore the maximum possible raw recursive saving inside this full shared
+boundary is at most
+
+```
+2 H1(t) + H2(t) + H3(t) - H7(t).
+```
+
+Both have the same rank mass87 at t=1. The cap is the exceptional role738's
+fragmentation penalty. The argument does not prove this cap attainable; extra
+middle-level delivery constraints may make the actual optimum higher.
+
+## Crucial distinction from original-input dimensions
+
+The original word's relevant inputs mostly enter on dimension0 or1 frames.
+Those original variables do NOT justify dimension cuts requiring eight
+high-dimensional sources. The theorem is valid here only because it uses the
+later 41-role boundary, treats its coordinates independently (with verified
+prefix and suffix ranks), and disallows reading outside public side information.
+Moving the boundary earlier can invalidate the source-dimension hypothesis.
+
+This is not a sum of the nonadditive original-support loss-space bounds. It is
+a new joint information-flow argument under a stronger boundary contract.
+It gives no unrestricted whole-word tariff optimum, new productive credit,
+ordinary-pass improvement, native admission or new multiplication bound.
+
+## Certificate
+
+`joint_boundary.py` reconstructs all source scalar rows and frame/lifetime
+legality; finds the interval and its41roles; proves both boundary ranks; checks
+the exact recipient map, eight one-dimensional independent observations,
+public31H1 tariff and each of the seven source crossing counts. A scope control
+duplicates one observation and correctly lowers the observation rank to7.
+
+Prepared with substantial OpenAI Codex assistance. Apache-2.0. Retain the PR5580,
+PR5569, PR5561 and complete P104 predecessor attribution in the source package.

research/p104-owned-coding-boundaries/PROOF.md

@@ -0,0 +1,107 @@
+# Rational recoding and shared-boundary limits for P104 owned values
+
+All assertions below are about the literal PR5580 word at head
+`6efa248cf456d6101d757e9d09ba29711d18a13a`. They do not assert a new
+construction, global optimum, native implementation, or multiplication bound.
+
+## 1. A complete classification of the unchanged producer span
+
+Let `D_0,...,D_7` be the eight public scalar rows copied into owned fields
+735 through 742. Rows are rational covectors on **all 735 arbitrary public
+inputs**, including the original zero-frame helper inputs. The verifier
+reconstructs the prefix from the identity, rather than assuming those helper
+inputs vanish. It confirms that these producer values do not change between
+the first owned INIT and their respective COPY events.
+
+For a covector `x`, define its original-entry support to be the binary span
+of the original entry frames of inputs with nonzero coefficient in `x`.
+This is a property of its covector, not an assertion that `x` can be built
+at that frame with no paid work.
+
+Every proper subspace of the ambient `F_2^9` lies in a hyperplane `ker(h)`
+for some nonzero binary normal `h`. For each of the 511 normals, project
+the eight rational covectors onto original input coordinates whose entry
+frames are not contained in that hyperplane. A combination `sum a_i D_i`
+has support inside the hyperplane exactly when its coefficient vector `a`
+is in this projected matrix's rational kernel.
+
+Exact Fraction elimination gives 495 matrices of rank eight and 16 of rank
+seven. The latter have one-dimensional kernels. Every listed kernel mode
+has support dimension exactly eight, checked by binary elimination. Hence:
+
+* No nonzero rational combination of the unchanged producers has
+  original-entry support dimension at most seven.
+* Exactly 16 projective combinations have proper support: the eight
+  original producers and eight mixed modes listed in RESULT.json.
+* Every other nonzero combination has support dimension nine.
+
+This is an exhaustive rational statement, not a bounded coefficient search.
+The independence minor below also excludes a nonzero coefficient vector
+representing the zero covector.
+
+## 2. Direct nested delivery does not remove an original mode
+
+Let `L_i` be the fixed one-dimensional final delivery frame for `D_i`.
+A mode with support hyperplane `ker(h)` can descend directly from that
+hyperplane to `L_i` only if `h` annihilates `L_i`. The verifier tests every
+one of the sixteen classified modes at every final delivery line.
+
+After removing `D_i`, exactly three mixed modes remain eligible at `L_i`.
+Their coefficient vectors have rational rank three; adjoining the unit
+vector for `D_i` raises that rank to four. RESULT.json records an exact
+separating functional for each destination, annihilating all three
+alternates and taking value one on `D_i`.
+
+This obstruction survives arbitrary corrections from original inputs
+whose entry frame is zero. The eight producer covectors restricted to
+nonzero-entry inputs have rank eight, witnessed by the explicitly checked
+minor on columns `[0,1,2,4,5,6,9,12]`. Therefore a producer combination is
+a zero-entry-input correction only when all eight coefficients vanish.
+
+This is a direct nested 8-to-1 delivery obstruction in the unchanged producer
+span, starting at each mode's original-entry support hyperplane and using
+fixed final delivery lines.
+It does not rule out earlier owned preparation, intermediate payloads
+outside that span, moving through a different recipient schedule, or
+changed public dependencies. Nor does an entry-support hyperplane by
+itself establish legal preparation of its mixed mode there.
+
+## 3. Joint transport floor across all eight blocks
+
+See [JOINT-BOUNDARY.md](JOINT-BOUNDARY.md) for the independent information-cut
+argument and full contract. The interval `[13378,13485)` has 41 public
+boundary fields: eight producers and 33 distinct recipients. Their entry
+rows have rank 41; the unchanged suffix observes their exits with rank 41.
+These verified facts force a replacement using only these public fields
+to preserve the exact local map.
+
+The map carries eight independent producer coordinates from dimension-eight
+inputs to dimension-one observations. At every dimension threshold 2 through
+8, at least eight scalar values must cross downward in owned fields.
+Common-frame scalar operations and public ascents cannot create a downward
+crossing. The argument allows arbitrary rational dependencies, any number
+of zero-initialized owned fields, erasures, and sharing across the blocks.
+
+For `H_r(t)=r^t`, `0<t<=1`, the cut count implies an owned cost of at least
+`8 H_7(t)`. The fixed public endpoint changes separately require `31 H_1(t)`.
+Thus the shared-boundary floor is `31 H_1+8 H_7`, compared with the source
+cost `33 H_1+H_2+H_3+7 H_7`. Their difference is an upper bound on possible
+local savings, not an attainable replacement.
+
+The fixed-boundary theorem does not assume that original input symbols
+start at dimension eight. They mostly start at dimension zero or one.
+Earlier preparation and outside public side information invalidate the
+boundary hypothesis and remain meaningful research directions.
+
+## Verification scope
+
+The joint-boundary checker also replays all scalar rows and frame/lifetime
+legality of the retained word. It verifies the final map on arbitrary input
+values and clear owned outputs. These are finite algebraic checks, not a
+proof-kernel verification or a replay of signed native maps, the physical
+caller, interval pricing, compiler, BIT stock, or outer analytic framework.
+Those unchanged obligations belong to the pinned source and are not newly
+claimed here. No selected-frontier file is modified.
+
+Prepared for flyingviper with substantial OpenAI Codex assistance and
+independent agent derivations. Apache-2.0.

research/p104-owned-coding-boundaries/README.md

@@ -0,0 +1,105 @@
+# P104: rational recoding and joint owned-block boundaries
+
+**Scoped negative results; no new construction or multiplication bound.**
+
+This package tests whether the eight owned transfers in
+[PR #5580](https://github.com/CrocSwap/integer-mult-bounds/pull/5580) can become
+cheaper by rational recoding or by sharing work across their full joint
+boundary. It provides three exact results:
+
+1. Every nonzero rational combination of the eight unchanged producer values
+   has original-entry support dimension at least eight. Exactly 16 projective
+   combinations have dimension eight: eight original and eight mixed modes.
+   All others have dimension nine. The verifier classifies all 511 binary
+   hyperplanes with exact rational elimination; this is not a coefficient grid.
+2. At each final delivery line, the three eligible mixed modes cannot reconstruct
+   its original producer, even modulo arbitrary corrections from original
+   zero-entry-frame inputs. Exact separators and an independence minor are
+   retained in [RESULT.json](RESULT.json).
+3. With the complete 41-role public boundary fixed, arbitrary sharing across
+   all eight owned blocks costs at least `31 H1(t) + 8 H7(t)` for `0<t<=1`.
+   The source costs `33 H1(t) + H2(t) + H3(t) + 7 H7(t)`. Their difference
+   bounds possible local savings; attainability remains open.
+
+The first two statements concern the unchanged producer span and direct nested 8-to-1
+delivery starting at each mode's original-entry support hyperplane. The third allows arbitrary internal rational dependencies and private
+fields, but excludes earlier preparation and outside public side information.
+Those distinctions matter: the certificates do **not** rule out changed public
+dependencies, partial residuals outside that span, or a larger boundary.
+
+See [PROOF.md](PROOF.md) and [JOINT-BOUNDARY.md](JOINT-BOUNDARY.md).
+
+## Reproduce
+
+Python 3.12; standard library only. From this package directory:
+
+```sh
+python3.12 -I -B verify.py
+python3.12 -I -O -B verify.py
+```
+
+Both print `PASS_P104_OWNED_CODING_BOUNDARIES`. Normal replay writes no files.
+The source word is retained locally and authenticated before use. The verifier
+also checks all scalar rows on arbitrary public inputs, chronological frame and
+ownership legality, exact boundary ranks and four semantic corruption controls.
+It compares the fresh receipt to the committed result; `--write` explicitly
+regenerates the latter.
+
+The registered metadata/provenance launcher, from repository root, is:
+
+```sh
+python3.12 scripts/research_package.py --package research/p104-owned-coding-boundaries
+```
+
+This launcher needs Git history for provenance; the direct verifier works in a
+Git-free package export. No solver, network, native checker or external package
+is required. The unchanged native maps, physical caller, pricing, compiler and
+outer analytic obligations are not part of this scoped replay. The full source
+replay was run separately during discovery; it is not a new proof claim here.
+
+## Relation to previous work
+
+[PR #5584](https://github.com/CrocSwap/integer-mult-bounds/pull/5584) established
+single-block optima, delivery obstructions and a rank witness, while explicitly
+leaving cross-block sharing open. This package supplies a joint information-cut
+argument under a stated 41-role boundary, plus the complete rational recoding
+classification. It does not add individual nonadditive loss-space bounds.
+
+Ali Romman's [PR #5579](https://github.com/CrocSwap/integer-mult-bounds/pull/5579)
+already covered fixed public windows; that obstruction is not claimed as new.
+The public compensated-source work in
+[Discussion #5575](https://github.com/CrocSwap/integer-mult-bounds/discussions/5575)
+and the event-retiming work in
+[Discussion #5574](https://github.com/CrocSwap/integer-mult-bounds/discussions/5574)
+are adjacent active approaches. The later
+[PR #5590](https://github.com/CrocSwap/integer-mult-bounds/pull/5590) addresses
+all frame paths with scalar contacts fixed; our joint-boundary theorem permits
+changed internal scalar dependencies but fixes the larger public boundary.
+These are different contracts. Open-PR and discussion checks were bounded
+coverage checks, not a proof of novelty. The canonical base and frozen sources
+are recorded in TASK.json and SOURCES.json.
+
+## Open next questions
+
+* Can an earlier residual assembly or changed outside side information lower
+  the complete paid-minus-productive moment? First identify actual value
+  versions, a legal transfer and all preparation/restoration costs.
+* Can the exceptional owned block attain the joint lower bound while meeting
+  every middle-level delivery? The information cuts alone do not resolve this.
+
+The user-authorized broader investigation continues separately; this package
+is an independently reviewable checkpoint, not a claim that the overall
+research goal is complete.
+
+## Credit
+
+Prepared for flyingviper with substantial OpenAI Codex assistance. Separate
+agents derived and checked the joint-boundary argument and delivery gate;
+the all-hyperplane classification was independently reconstructed by the
+primary agent and reviewed by another agent. These are computational research
+checks, not human review or proof-kernel acceptance. New work is Apache-2.0.
+
+The retained word is Ali Romman's PR5580 source, with Joel Pulikkan,
+DreamingOfClouds, thu-nmrc and the full P104 predecessor credit retained in
+[inputs/README.md](inputs/README.md). No predecessor construction is attributed
+to this package.