Prove exact chronological helper spill and repair rank (no new κ)

research/chronological-helper-repair/PROOF.md

@@ -0,0 +1,195 @@
+# Chronological helper spill and sharp boundary repair
+
+This is a scoped all-field linear-algebra proof. It gives no native price,
+physical supplier or multiplication exponent. The contribution was produced
+by Nick Petalas. Apache-2.0.
+
+## The fixed replacement model
+
+Let F be any field and let h in F^k be k arbitrary initial helper values.
+An invertible scalar word returns h unchanged. It can have any number of
+invertible events. Fix k ordered cuts. At cut i the original prefix is P_i.
+Choose a cut row a_i and column b_i such that a_i b_i=1. Define
+
+```text
+c_i = a_i P_i,       d_i = P_i^-1 b_i,
+C   = matrix with rows c_i,
+D   = matrix with columns d_i.
+```
+
+Assume C is invertible. No invertibility assumption is made on D or CD.
+The choice of cuts, rows and columns is fixed before seeing any data.
+There are k further arbitrary independent inputs z_1,...,z_k, all public
+from the start. At cut i return t_i=a_i x, retain that output, and replace
+the live state by
+
+```text
+x <- x + b_i (z_i - t_i).
+```
+
+This is an invertible replacement, not an erasure. Since a_i b_i=1,
+decompose x=b_i(a_i x)+(x-b_i a_i x). The event swaps the first coordinate
+with z_i and preserves the second. The old coordinate t_i remains an
+output. Any realization by local bases still has to pay for those bases.
+
+This is the independent-input replacement semantics of Ali Romman's
+[PR #5599](https://github.com/CrocSwap/integer-mult-bounds/pull/5599),
+applied to several fixed cuts of one identity helper word. Its physical
+common-chart hypotheses are additional requirements, not consequences
+of the scalar model here. Main fields, owned lifetimes and nonidentity
+helper endpoints are outside this theorem unless a separate reduction
+to this identity block is supplied.
+
+Write the pairing matrix as
+
+```text
+K = CD = I + L + U,
+```
+
+where L is strictly lower triangular and U is strictly upper triangular.
+The diagonal is one because c_i d_i=a_i b_i=1. Let f denote the final live
+helper vector, after the original word's terminal identity has completed.
+
+## The complete causal map
+
+The following identities hold for every h,z over every field:
+
+```text
+(I+L)t = Ch + Lz,
+Cf     = (I+U)z - Ut.                         (1)
+```
+
+To prove them, pull the current live state back through the original prefix.
+If u is this boundary-coordinate state, replacement i changes it by
+d_i(z_i-t_i). The original scalar events between cuts do not change u.
+Consequently,
+
+```text
+t_i = c_i h + sum_(j<i) K_ij (z_j-t_j),
+f   = h + D(z-t).
+```
+
+The first equation gives the first line of (1). Multiplying the second by
+C and substituting Ch=(I+L)t-Lz gives the second line. No simultaneous-cut
+commutation, joint basis or pairwise-independence premise was used.
+
+Let A=(I+L)^-1, which exists because L is nilpotent. The two cross-input
+coefficient maps have exact ranks
+
+```text
+rank(z -> t, holding h fixed) = rank(AL) = rank(L),
+rank(h -> f, holding z fixed) = rank(-C^-1 UAC) = rank(U).       (2)
+```
+
+Both statements are invariant under separate invertible changes of basis
+within the early-output bank and within the final-helper bank.
+
+Thus individual equations c_i d_i=1 do not certify independent splits.
+The early outputs depend only on old inputs exactly when L=0. The final
+helpers depend only on new inputs exactly when U=0. Both requirements hold
+without communication between the two output banks exactly when CD=I.
+Here independence means the prescribed old/new input partition; allowing
+a new input basis that mixes h and z changes the contract.
+
+## Exact repair tariff when the early targets are already valid
+
+Suppose L=0. The early bank is then t=Ch and can remain untouched. Define
+r=rank(U). Grant free invertible linear operations confined to either bank.
+A cross-bank update adds B times one bank to the other and costs rank(B).
+Rank-one updates therefore cost one unit. Coefficients and local basis
+operations are unrestricted over F. This is a relaxation of physical
+delivery, not a native rank tariff.
+
+The least total cross-bank cost that makes all final helpers independent
+of h, preserves the early outputs, and restores every auxiliary field is
+exactly r. Any finite clean or dirty workspace is permitted on either side
+of a fixed bank partition. Auxiliary fields must return to their original
+values. Cross-bank updates in either direction are allowed.
+
+For the lower bound, fix z and every auxiliary input, and vary h. The
+coefficient of h in all live-side fields initially has rank r by (2).
+Adjoining fixed clean or dirty workspace only appends zero rows. An
+invertible operation confined to the live side preserves this rank.
+An operation confined to the early side leaves it unchanged. A cross-bank
+update into the live side with matrix B changes the coefficient matrix
+by rank at most rank(B). The inequality
+
+```text
+|rank(M+E)-rank(M)| <= rank(E)
+```
+
+therefore forces total charge at least r before that coefficient can be
+zero. At the desired endpoint every final helper and every restored
+live-side auxiliary is independent of h. Updates into the early side
+cannot reduce this lower bound. The proof uses neither a workspace limit
+nor a sign, characteristic or nonzero-state assumption.
+
+For attainment, take any rank factorization
+U=sum_(s=1)^r v_s w_s^T. Execute
+
+```text
+f <- f + (C^-1 v_s)(w_s^T t),       s=1,...,r.
+```
+
+These are r rank-one updates from the retained early bank. Equation (1)
+then gives Cf=(I+U)z. The live-side normalizer (I+U)^-1 C returns f=z.
+The early bank remains t=Ch; no workspace is needed. This proves both
+the exact cross-bank charge and a constructive endpoint decoder.
+
+If the early outputs are physically unavailable for later reading, this
+attainment is unavailable. The rank lower bound still applies to any
+implementation in the stated larger relaxation. Similarly, free local
+bases in this tariff must receive their actual scalar, native, routing,
+precision and storage charges before use in a supplier invoice.
+
+## A sharp obstruction of arbitrary size
+
+For every k>=2 choose C=I and D=I+N, where N has ones on the first
+superdiagonal and zeros elsewhere. Then L=0 and U=N has rank k-1.
+Every individual replacement is normalized, and every early output is
+exactly t_i=h_i. Nevertheless,
+
+```text
+f_i = z_i + z_(i+1) - h_(i+1)       for 1<=i<k,
+f_k = z_k.
+```
+
+The final helpers retain k-1 independent old-input directions. They need
+exactly k-1 cross-bank rank units to repair. In particular, counting k
+individually valid cuts as k independent target splits misses a deficit
+of arbitrary size in this fixed-direction model.
+
+An explicit scalar repair adds t_(i+1) to f_i for all i<k. Processing
+i=k-1,...,1, subtract the already normalized f_(i+1) from f_i. This word
+uses k-1 cross-bank additions and k-1 within-bank additions, returns
+f=z, and preserves every early output. Optimality is claimed for the
+cross-bank rank charge only, not the total scalar addition count.
+
+## Evidence and scope
+
+`verify.py` builds an explicit identity source word with changing invertible
+prefixes, performs the literal cut replacements on all input coefficients,
+and compares its endpoint with (1). It checks (2), the full reversible
+endpoint and the attaining rank-factor repair. Finite-field and rational
+domains are bounded and enumerated in its output. A separate binary
+outer-product enumeration rejects every one-unit repair of a rank-two
+sharp-family defect. Incorrect diagonal, basis and field fixtures fail.
+
+The universal result rests on this written proof. The finite replay is
+corroboration, not proof-kernel or independent human acceptance. Causal
+elimination, nilpotent triangular inverses, rank factorization and rank-cut
+lower bounds are classical. The proposed new contribution is their exact
+chronological helper-replacement application, with both leakage ranks,
+the sharp repair tariff and the explicit family. No general literature
+priority is claimed.
+
+Ali Romman's #5599 supplies the single-cut replacement contract and its
+retained P104 lineage. His [#5615](https://github.com/CrocSwap/integer-mult-bounds/pull/5615)
+supplies the dyadic single-cut pairing context. This theorem does not
+compute a dyadic module capacity or recheck either predecessor.
+
+No actual P104 cut is constructed here. Distinct output charts, physical
+availability of retained early outputs, restricted coefficient alphabets,
+native operators, dirty-state physical restoration, the complete signed
+moment, compiler and outer transfer remain separate obligations. The
+selected frontier and all five selected framework assumptions are unchanged.

research/chronological-helper-repair/README.md

@@ -0,0 +1,132 @@
+# Chronological helper spill has an exact repair rank
+
+This scoped written proof determines how multiple individually normalized
+helper replacements interfere. The contribution was produced by Nick Petalas.
+It does not change kappa or the selected frontier.
+
+For a scalar identity helper word, transport the row and column at ordered
+cut i to the input boundary as c_i,d_i, with c_i d_i=1. Assume the k rows
+form an invertible helper basis C, and put the columns in D. Write
+CD=I+L+U, with strictly lower L and strictly upper U. For arbitrary old
+inputs h, independent replacement inputs z, early outputs t and final
+helpers f, the complete map is
+
+```text
+(I+L)t = Ch + Lz,
+Cf     = (I+U)z - Ut.
+```
+
+The early outputs have new-input leakage rank exactly rank(L). Final
+helpers have old-input leakage rank exactly rank(U). Both banks are
+independent under the prescribed old/new input partition without repair
+exactly when CD=I. Separate invertible basis changes within either bank
+cannot remove these leakage ranks.
+
+When L=0, exactly rank(U) cross-bank rank units suffice and are necessary
+to repair the final helpers. This allows arbitrary finite restored clean
+or dirty workspace and grants free invertible operations within either
+bank. It is an optimistic linear communication tariff, not a physical
+Gaussian rank tariff. For every k>=2 an explicit family has k individually
+valid cuts, already independent early outputs, and repair cost k-1.
+
+[PROOF.md](PROOF.md) contains the all-field derivation, workspace-robust
+lower bound and attaining decoder. Classical elimination and rank-cut
+methods are credited as methods. The new contribution is this precise
+chronological helper-replacement application. No general literature
+priority is claimed.
+
+## Reproduce
+
+From the repository root, using standard-library CPython 3.12:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/chronological-helper-repair/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/chronological-helper-repair/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/chronological-helper-repair
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/chronological-helper-repair --check-source-history --check-modes
+```
+
+Another CPython 3.12 executable can replace the absolute interpreter path.
+The direct commands print `PASS_CHRONOLOGICAL_HELPER_REPAIR` and a generated
+SHA256 receipt covering all six package files. The registered replay also
+prints `PASS_REGISTERED_RESEARCH_PACKAGE`.
+
+The verifier replays changing original prefixes and literal cut events
+on every input coefficient. It compares this direct endpoint with the
+closed form, checks both leakage ranks and full reversibility, and emits
+minimal rank-factor repairs when L=0. Its finite domains are:
+
+- All 10,752 pairs of an invertible binary 3-by-3 C and a unit-diagonal
+  binary 3-by-3 K, and all 729 ternary unit-diagonal 3-by-3 K with C=I.
+- All 25 quinary unit-diagonal 2-by-2 K with C=I, and 72 rational fixtures
+  through k=6, including nontrivial dyadic C and nonzero L and U.
+- Twenty-five sharp-family cases over Q, F2, F3, F5 and F7 through k=6.
+  An independent enumeration rejects all 64 binary outer products as
+  one-unit repairs of a rank-two defect.
+- Eight invalid-domain fixtures and four semantic controls, including
+  reversed chronological pairing and the biorthogonal positive control.
+
+The three finite-field domains contain 1,376 cases with L=0. The
+rational domain contains 43. Every such case checks the attaining repair;
+the sharp-family checks are additional fixtures and can overlap those
+domains. Counts are enumerated by the verifier, not extrapolated.
+
+## Scope and predecessor credit
+
+The target was an original causal-composition question under the current
+`coverage-law-change` card, not a follow-up question taken from another
+package. It changes the single-cut premise to multiple prescribed cuts.
+The task and exact provenance are in [TASK.json](TASK.json) and
+[SOURCES.json](SOURCES.json), based on canonical main
+`19fdb086ea96af9a9f87936a2b888e10af4ed810`, priority revision 8.
+
+Ali Romman's [#5599](https://github.com/CrocSwap/integer-mult-bounds/pull/5599)
+supplies the independent-input replacement contract and the retained
+Pierre-Loic Doulcet, Cinna Davis, Jacob Alan Sussman and P104 lineage.
+His [#5615](https://github.com/CrocSwap/integer-mult-bounds/pull/5615)
+supplies the dyadic single-cut pairing context. They are cited premises,
+not audit or scientific-replay deliverables of this package. Historical
+multi-cut response-kernel work concerns a different replacement operation.
+
+The result is a written proof with exact finite corroboration. It is not
+a finite search failure, native certificate, complete multiplier theorem
+or independently accepted formal proof. Physical cut eligibility, common
+charts, availability of retained early outputs, scalar bases, coefficient
+restrictions, native alignment, ownership, precision, stock, complete
+signed moment, compiler and outer funding remain payable. All five
+selected framework assumptions remain. No selected supplier cold replay,
+Lean or Docker run is performed.
+
+Independent human and formal proof-kernel review are unclaimed.
+Apache-2.0.
+
+## Open next questions
+
+1. Does one changed P104 word contain a full or separately justified
+   partial family of eligible cuts with zero lower pairing and nonzero
+   upper pairing? Extract exact transported rows and columns from a named
+   word. The blocker is physical eligibility and chart compatibility,
+   not the scalar formula.
+2. Can a real consumer deliver the necessary early-output reads within
+   a favorable complete signed moment? Start with a rank factorization
+   of that actual U and charge every read, basis operation and restore.
+   The tariff here grants free operations that a physical caller must pay.
+
+## Verification design
+
+The kept code has no recursion, dynamic code execution or external
+scientific dependency. Functions are at most 33 lines. Matrices have at
+most 12 rows and columns; input helper dimension is at most six. Scientific
+domains and all loop counts are fixed by the enumerations above. Runtime
+checks remain enabled under `-O` and enforce dimensions, unit diagonal,
+invertibility, coefficient bounds and exact residuals. Warnings are errors
+in both registered commands. The only filesystem reads in the scientific
+replay generate the six-file receipt, each bounded to one MiB.
+
+Power-of-Ten rule 3 has a managed-runtime deviation in `verify.py`. Python
+integers, lists and Fractions allocate during arithmetic. The scope is the
+fixed finite replay only. The compensating controls are bounded dimensions,
+fixed coefficient grids, streamed cases, no retained case history and the
+receipt size limit. Normal and optimized replays check the same domains.
+An embedded implementation would need fixed-capacity integer storage and
+a separate bit-capacity analysis; this verifier is not such an implementation.

research/chronological-helper-repair/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8",
+      "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/p104-helper-subspace-splits/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "ca979984444a431b02b62da7094a3b23d5341742",
+      "sha256": "f4c68acf9373e34d88e14e1a7791b4b739c8b5297a1ae4c0121f579a02fde04e"
+    },
+    {
+      "path": "research/dyadic-helper-channel-capacity/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "c97a6edce3070414c81f0ef6e6c099ebb17f3a90",
+      "sha256": "b258a217f2cd0fc48461285fe8ae24de26b0c5963668d9d8f0955fc6e759e929"
+    },
+    {
+      "path": "docs/research/current-priorities.md",
+      "usage": "provenance",
+      "git_blob": "6f5d40d13d8f3bdc12ce7954c8c3eb4ab1f8be91",
+      "sha256": "70f61c8d140ae6e892f2b8f065bba4eae3e76f7a8f55f632fd4e2f9f34039bdc"
+    }
+  ]
+}