Prove the fixed five-call border needs two repair cuts (no κ)

research/border-single-correction/PROOF.md

@@ -0,0 +1,150 @@
+# The fixed border needs two repair locations
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+## Statement and predecessor
+
+Take Ali Romman's five-call border in
+[PR6398, BOUNDARY-MODULES.md, sections 2 and 3](https://github.com/aliromman/integer-mult-bounds/blob/dee2663ba0918be86993fd9d63c8d64b020f4c83/research/mixed-projector-root-headroom/BOUNDARY-MODULES.md).
+Its five chronological factors, parameterized by a nonzero scalar `e`,
+are fixed throughout this result. Three independent invertible commuting
+stage variables are `A,B,C`; the central involution is `S`.
+The target is `S diag(ABC,A,B,C)` on four arbitrary input fields.
+
+**Theorem.** Over any field of characteristic other than two, no linear
+repair confined to one of the six cuts can make this fixed word equal its
+target as a formal identity in `S,A,B,C` modulo `S^2=1`. The repair may be an arbitrary
+matrix depending on `S` and `e`, of any rank, but must be independent of
+`A,B,C`. Consequently a product of arbitrarily many such operations at one
+cut also cannot repair it. The minimum number of distinct repair cuts is two,
+attained by the predecessor's two rank-one corrections.
+
+The cut is fixed as part of the word, independently of the stage variables.
+There are four fields and no additional workspace. The theorem does not
+cover retuning the original factors, moving stage operations, using a stage
+or its inverse inside a repair, nonlinear recovery or approximate recovery.
+It is a scoped algebraic obstruction, not a supplier or kappa claim.
+
+The predecessor supplies the border and its two-correction construction.
+The new result is the exclusion of every single repair location, including
+arbitrary-rank and arbitrarily long central-only blocks. It does not replay
+the predecessor's native word, root search, counts or price exclusions.
+
+## Normalize the nonzero border parameter
+
+Write `Q_i(e)=I+(S-1)u_i(e)v_i(e)` for the five query matrices and `D_i`
+for their left stage multipliers. In chronological order, these are
+
+| i | u_i(e) | v_i(e) | D_i |
+| --- | --- | --- | --- |
+| 0 | (1,0,0,0) | (0,1/e,0,0) | diag(A,A,1,1) |
+| 1 | (-1/e,1,0,0) | (0,1,-e^2,0) | I |
+| 2 | (-e,0,1,0) | (-1/e,0,-1,0) | diag(B,1,B,1) |
+| 3 | (-e,0,1,-1) | (-1/e,0,0,0) | I |
+| 4 | (1,0,0,1/e) | (-1,0,0,e) | diag(C,1,1,C) |
+
+Let `E=diag(e,1,e^2,e^2)`. Each outer product satisfies
+
+`u_i(e)v_i(e) = E^-1 u_i(1)v_i(1) E`.
+
+All `D_i` and the target commute with `E`. Therefore the entire word,
+each prefix and suffix, and the unique required repair at any cut are
+conjugates by `E` of their `e=1` counterparts. Since `E` is invertible
+and independent of the stages, existence of a stage-independent repair
+is equivalent at `e` and at one. This similarity is an algebraic proof
+device, not a claim of free physical normalization.
+
+## A two-point middle-stage witness at every cut
+
+It suffices to specialize `S=-1`, `A=C=1`, and write `B=b`.
+These scalar stages are a valid restriction of a formal identity.
+In fact the two witnesses `b=1,-1` are already unitary scalar stages.
+Set
+
+`M_i = D_i (I-2u_i(1)v_i(1))`.
+
+For the three full sites `v_i u_i=0`, so the inverse of their query
+factor is `I+2u_i v_i`. At the other two sites `v_i u_i=1`, so their
+query factors are their own inverses. Thus every factor is invertible
+for `b!=0`. Define, for `0<=k<=5`,
+
+`P_k=M_(k-1)...M_0`, `L_k=M_4...M_k`, and `T=-diag(b,1,b,1)`.
+
+Empty products are identity matrices. Any inserted matrix `K` satisfying
+`L_k K P_k=T` is uniquely forced to be
+
+`K_k(b) = L_k^-1 T P_k^-1`.
+
+Direct multiplication gives the following complete table. Coordinates are
+zero-based and `E_ij` is a matrix unit. Each row lists `K_k(b)-I`.
+
+| cut k | Required displacement |
+| --- | --- |
+| 0 | `-2/b E_03 + 2 E_12` |
+| 1 | `-4 E_02 - 2/b E_03 + 2 E_12` |
+| 2 | `-2/b E_03 - 2 E_12` |
+| 3 | `2 E_03 + 4/b E_10 + 2/b E_12 - 4 E_23` |
+| 4 | `4 E_00 - 2 E_03 + 2/b E_12 + 8 E_30 - 4 E_33` |
+| 5 | `-2 E_03 + 2/b E_12` |
+
+For cuts zero through two, entry `(0,3)` equals `-2/b`.
+For cuts three through five, entry `(1,2)` equals `2/b`.
+Each changes by a nonzero multiple of four between `b=1` and `b=-1`
+in every characteristic other than two. The unique required matrices
+therefore differ. No matrix independent of `b` works at either cut for
+both inputs. This excludes all six cuts, without restricting the rank,
+determinant, central dependence or internal factorization of `K`.
+
+Conjugation by `E` proves the same exclusion for every nonzero `e`.
+Any central-only linear block at a single cut has one aggregate matrix
+independent of the stages, so the exclusion covers the whole block.
+
+The specialization is sufficient for the negative result: no interpolation
+in general stages or numeric approximation to the actual native operators
+is assumed. The failure already appears on two scalar stage characters.
+
+## Sharpness and the scope of the cost consequence
+
+The predecessor's corrections are
+
+`I+(S-1)e^2 E_12` at cut two, and
+`I+(S-1)e E_03` at cut five.
+
+Its exact identity proves that these two locations attain the target on
+arbitrary inputs. Both displacements have rank one and square to zero.
+Combining that cited upper bound with the new single-cut exclusion proves
+the exact minimum of two repair locations in the stated model. The verifier
+also executes the attaining word on its finite fixtures, solely as the
+positive witness accompanying this new lower bound.
+
+The predecessor already prices these two direct corrections and excludes
+their complete invoice at its candidate saving. This contribution does
+not recount or strengthen that price calculation. It establishes that
+concentrating all stage-independent recovery at one cut cannot replace
+them, even with a higher-rank central operation or unlimited local scalar
+mixing. Different two-cut recoveries, stage-sensitive operations, changed
+factors, additional fields and precision transfer remain open.
+
+## Exact evidence
+
+`verify.py` computes all required corrections by exact rational inversion,
+independently of the displayed formulas. It checks every cut at both
+middle-stage witnesses for each of six nonzero border parameters. It then
+uses the correction required at `b=1` on the `b=-1` word and requires that
+the purported endpoint fail at every cut. These are 36 explicit rejected
+recovery attempts, not a sampled assertion that all possible matrices fail;
+uniqueness supplies the quantifier over all matrices.
+
+There are also 36 normalized table checks and 48 attaining two-correction
+fixtures, plus five domain/singularity rejection controls. Each entry of
+`b K_k(b)` has polynomial degree at most two: exactly one inverse stage
+factor involves `b^-1`, and `T` has degree one. The displayed candidate
+table has the same bound. The checks at `b=1,2,3`, included in the six
+normalized values, therefore certify the table coefficients over the
+rationals by interpolation. All coefficients are integers before adjoining
+`b^-1`, so the identities transfer to every field. The two-point failure
+uses only `1,-1`, so it remains valid in every characteristic other than two.
+
+The all-parameter theorem rests on this written uniqueness, similarity
+and two-point argument. The finite fixtures are exact corroboration and
+a coefficient certificate, not formal proof-kernel acceptance.

research/border-single-correction/README.md

@@ -0,0 +1,104 @@
+# Two repair cuts are necessary for the fixed five-call border
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+**Claim type: scoped algebraic proof with exact finite evidence.**
+Ali Romman's [PR6398 five-call border](https://github.com/aliromman/integer-mult-bounds/blob/dee2663ba0918be86993fd9d63c8d64b020f4c83/research/mixed-projector-root-headroom/BOUNDARY-MODULES.md)
+cannot reach its exact diagonal target through a central-only linear repair
+confined to any single cut. This excludes an arbitrary-rank operation or an
+arbitrarily long block of such operations at that cut. The minimum number
+of distinct repair locations is **two**, attained by the predecessor's
+two rank-one corrections.
+
+For each of the six cuts, invertibility uniquely determines the inserted
+repair matrix. The required matrices differ between the two middle stages
+`B=1` and `B=-1`, already at `A=C=1` and central character `S=-1`.
+The repair cannot be independent of the stages. An exact diagonal similarity
+extends the argument to every nonzero border parameter, over any field of
+characteristic other than two. [PROOF.md](PROOF.md) gives the six required
+matrices and the complete argument.
+
+This answers a part of PR6398's different-recovery question. Increasing the
+rank or scalar complexity of a repair at one location cannot remove its
+need for stage information. A future recovery must cross a stage boundary,
+use stage-dependent operations, change the word or change another stated
+hypothesis. The predecessor's native construction, two-correction word
+and reported losing invoice retain their credit; they are premises rather
+than audit deliverables.
+
+## Reproduce
+
+From the repository root, using only CPython 3.12 and its standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/border-single-correction/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/border-single-correction/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/border-single-correction
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/border-single-correction --check-source-history
+```
+
+Other hosts may substitute a CPython 3.12 interpreter. The verifier prints
+`PASS_BORDER_SINGLE_CORRECTION` in a generated JSON receipt, including all
+36 cut/parameter witnesses, 36 normalized table checks, 48 two-correction
+positive fixtures and five domain/singularity controls. Every frozen
+one-cut correction is explicitly rejected on the other middle stage.
+All checks remain active under `-O`. The receipt binds package files by
+SHA256 and is printed to stdout; redirect it outside the checkout to save it.
+
+The package imports no predecessor solver and does not rerun a predecessor
+scientific suite. The source is cited at the exact public head above.
+Its definition is transcribed explicitly into the proof and standalone
+verifier. It is an external scholarly reference, not an unresolvable Git
+input pin. The declared Git provenance binds the base card and selected record.
+
+## Scope and limitations
+
+The theorem concerns a formal identity in three independent invertible
+commuting stage variables and a central involution. The negative-character
+specialization is essential; a concrete central operator equal to identity
+is outside the obstruction. There are exactly four arbitrary input fields,
+the original five factors stay fixed, and the repair location is fixed
+independently of the stage values. Repairs may depend arbitrarily on the
+central operator and nonzero border parameter, but not on the stages.
+
+Retuned original factors, adaptive cut selection, additional workspace,
+stage-sensitive recovery, approximate endpoints and physical implementations
+are excluded. This does not lower or rederive the predecessor's invoice,
+fund recursive precision, admit a supplier, change selected kappa or prove
+a complete multiplication theorem. No Lean, Docker, selected cold replay,
+native replay or predecessor root search was run. Independent human and
+formal proof-kernel review are unclaimed.
+
+Canonical main was checked at `7c49fe32c55de02c2c873655c804b16e4c3fef0a`,
+priority revision 8. The selected source-binding positive control passed;
+it is metadata orientation, not supplier validation. The original
+coverage-law-change card is narrowed to an exact recovery-location obstruction
+for a changed caller boundary. The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19360652)
+records that scope before the proof was packaged.
+
+Credit Ali Romman for PR6398's border and recovery question, its two-correction
+upper bound and source-specific pricing. Credit Cinna Davis for the caller
+interfaces, Jacob Alan Sussman for productive recursion, and the retained
+native, helper, compiler, BIT and analytic lineage identified in PR6398.
+The new uniqueness table and single-cut obstruction are the contribution here.
+All predecessor notices and credit remain unchanged by citation.
+
+Power-of-ten inspection: the verifier uses no recursion, matrices have four
+rows, words have at most seven factors, and every scientific loop ranges
+over a fixed finite set. Functions stay below 60 lines. Exact fractions and
+collections allocate dynamically, a managed-runtime deviation bounded by
+these fixed domains. Five rejection-control callbacks have explicit local
+targets. Matrix dimensions are internal invariants; zero parameters, invalid
+cuts and singular inversion fail explicitly. Warning-strict normal and
+optimized commands are registered. No output files or processes are created.
+
+## Open next questions
+
+- Can a changed two-cut recovery cost less than the existing two rank-one
+  queries? Start with explicit central operations on both sides of the
+  middle stage and a full signed invoice. The present result supplies a
+  location lower bound, not a complete tariff optimum.
+- Can a stage-sensitive operation or changed original factor yield a
+  favorable exact caller? Start from the required correction table and price
+  the missing middle-stage dependence, including inverse access and cleanup.
+  Physical stage delivery and complete recursive costs remain the blockers.

research/border-single-correction/SOURCES.json

@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    }
+  ]
+}