Tighten joint dirty-word interval bounds by 2h+1 (no new κ)

research/protected-boundary-interval-bound/PROOF.md

@@ -0,0 +1,132 @@
+# A smaller joint interval envelope from protected boundaries
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+Claim type: scoped written proof. The proof uses the cited prefix-entry and
+squarefree-interval lemmas as premises. It does not audit those predecessors.
+
+## Contract and theorem
+
+Use Chafik Boukhalfa's PR628 balanced dirty word on n>=1 factors, a protected
+source x, an unread target y and h=ceil(log2 n) arbitrary dirty scratch registers.
+The scratch register for each depth is reused by sibling calls. All cuts are
+complete ideal-leaf boundaries. Let P_t be any prefix of either word orientation.
+The full state has the maximum of the individual register norms.
+
+Put
+
+```text
+K(0)=2,
+K(h)=h^2+2h+3 for h>=1.
+```
+
+For every ordered pair of cuts s,t, the free noncommutative coefficient
+absolute row sum of P_t P_s^-1 is at most K(h). Consequently:
+
+1. For arbitrary contractive operator factors, without commutation,
+   ||P_t P_s^-1|| <= K(h).
+2. If the factors commute and every subset product, including the empty one,
+   has norm at most G>=1, then ||P_t P_s^-1|| <= K(h) G.
+
+For h>=1 the coefficient envelope improves the squared-prefix bound by
+exactly (h+2)^2-K(h)=2h+1. It is not claimed sharp. Arham Tahir's PR1374
+lower bound floor(h^2/2)+h+2 remains compatible with it. This does not change
+the exact destination-only result of philippeVV's PR2177.
+
+## Predecessor inputs
+
+Hanson Sun's PR1085 proves that every entry of P_t and P_s^-1 is zero or
+one signed monomial, and that the source row and target column are identity.
+Its retained text is at
+`research/single-register-interval-transport/vendor/PR1085-PROOF.md`.
+We consume those assertions without replaying or re-proving them.
+
+Charles Bethin's PR1278 proves that every surviving interval monomial uses
+each factor at most once, including both cut orders, both orientations and
+shared deeper scratch. This is needed only for conclusion 2. Its retained
+text is `research/commuting-interval-audit/PROOF.md`.
+
+## New block inequality
+
+Order registers as source, the h scratch registers, target. The protected
+source and unread target force the following shape for P=P_t and Q=P_s^-1:
+
+```text
+P = [ 1  0  0 ]       Q = [ 1  0  0 ]
+    [ a  B  0 ]           [ c  D  0 ]
+    [ b  e  1 ]           [ d  f  1 ].
+
+P Q = [ 1        0       0 ]
+      [ a+B c    B D     0 ]
+      [ b+e c+d  e D+f   1 ].
+```
+
+Here a,c are h-by-1, B,D are h-by-h, e,f are 1-by-h, and b,d are scalars
+in the free algebra. Every displayed entry of P and Q has coefficient mass
+at most one. Coefficient mass is subadditive and submultiplicative because
+concatenation multiplies words and cancellation can only reduce mass.
+
+A scratch row of Q has at most h+1 occupied entries, since its target entry
+vanishes. Its source row has mass one. Therefore any scratch row of P Q has
+mass at most
+
+```text
+1 + h(h+1) = h^2+h+1.
+```
+
+The target row of Q has mass at most h+2. The target row of P Q is the sum
+of b times Q's source row, h terms e_j times Q's scratch rows, and Q's target
+row. Its mass is at most
+
+```text
+1 + h(h+1) + (h+2) = h^2+2h+3.
+```
+
+The protected source row still has mass one. Taking the largest row gives
+the theorem for h>=1. This argument uses both boundary restrictions; it
+does not multiply the global row bound h+2 by itself. It does not assume
+fresh scratch, commuting coefficients, or an ordering of s and t.
+
+When h=0, n=1 and there is one leaf. Every interval is identity or that
+leaf shear in either sign. Its coefficient row sum is at most two, proving
+the separate K(0)=2 case.
+
+For conclusion 1, every formal word evaluates to an operator of norm at
+most one, by submultiplicativity of the contractive factor norms. Summing
+the row coefficient masses gives K(h). For conclusion 2, use PR1278's
+squarefree conclusion before substitution. Commutation turns each surviving
+word into a subset product with norm at most G. The same coefficient bound
+gives K(h)G. Individual factor bounds by G alone would not justify this step.
+
+## What the computation checks
+
+The verifier multiplies generic protected-boundary matrices with independent
+formal entries. It obtains the exact abstract row counts above for h=1..8.
+These matrices are not asserted to be prefixes of a common word, so equality
+in that calculation is not a sharpness claim for actual dirty intervals.
+The strict-gain identity is checked with exact integers at h=1..10000.
+
+A separately written iterative emitter expands the balanced word for six
+factor counts, with both signs and the same physical scratch at each depth.
+It propagates every nonempty interval directly over the free noncommutative
+algebra and checks the new inequality. It also checks the full arbitrary-dirty
+endpoint and literal inverse order. It imports no predecessor implementation.
+No predecessor extremal census or scalar sign witness is a deliverable here.
+
+Abstract controls remove each protected boundary or the entry-size premise
+and require failure of the new bound. Invalid argument controls check the
+finite executable capacities. These are not claimed to be realizable dirty
+word counterexamples. A separate check keeps the bound labelled nonsharp.
+
+## Limits and next implication
+
+The all-size statement rests on the written block proof and the cited
+lemmas. Computation only corroborates its fixed finite fixtures. No formal
+proof-kernel or independent human review is claimed. Internal rounded leaf
+operations, nonlinear errors, negative-leaf preimages, preparation, physical
+movement, stock, precision and a complete caller invoice are not supplied.
+The five selected framework assumptions remain. No new kappa follows.
+
+The original sharp-constant question remains open between the cited lower
+family and this smaller upper bound. A further improvement must exploit
+relations between the two actual prefixes, beyond these protected boundaries.

research/protected-boundary-interval-bound/README.md

@@ -0,0 +1,110 @@
+# A smaller joint interval bound from protected boundaries
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+Claim type: scoped written proof with exact finite corroboration. No new kappa.
+
+For the unchanged balanced PR628 dirty word, put h=ceil(log2 n). The protected
+source and unread target improve the general joint-error coefficient envelope:
+
+```text
+previous: (h+2)^2
+new:      h^2+2h+3, for h>=1
+gain:     2h+1
+```
+
+The one-factor case has the separate bound two. Every ordered pair of complete
+leaf cuts and both word orientations are covered, with the same dirty scratch
+register reused at each depth. For arbitrary contractive factors the new norm
+bound is h^2+2h+3, without commutation. For commuting factors whose every subset
+product has norm at most G, it is (h^2+2h+3)G.
+
+For example, height four improves the upper bound from 36 to 27. This is an
+upper-bound improvement, not a sharpness theorem. Arham Tahir's #1374 gives the
+compatible lower family floor(h^2/2)+h+2 and explicitly leaves the sharp upper
+constant open. [PROOF.md](PROOF.md) supplies the new block inequality. The
+prefix-entry invariant and squarefree-interval theorem are cited dependencies,
+not verification deliverables. No predecessor executable is imported or run.
+
+## Evidence and reproduction
+
+The standalone verifier checks eight generic formal block products and 10,000
+strict-gain identities. Its own iterative word emitter checks 23,736 nonempty
+free noncommutative intervals at n=1,2,3,5,8,11 in both directions, full arbitrary
+dirty endpoints and literal inverse order. Fourteen controls cover invalid
+arguments, removed source/target restrictions, an oversized entry and the
+distinction between an upper bound and a sharp value. A generated receipt on
+stdout binds all six package files by SHA256; no receipt is hand-written.
+
+From the repository root with the Python 3.12 standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B -W error -X dev research/protected-boundary-interval-bound/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B -W error -X dev -O research/protected-boundary-interval-bound/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/protected-boundary-interval-bound
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/protected-boundary-interval-bound --check-source-history
+```
+
+Any CPython 3.12 installation can replace the local interpreter path. Expected
+markers are `PASS_PROTECTED_BOUNDARY_INTERVAL_BOUND`,
+`PASS_REGISTERED_RESEARCH_PACKAGE` and `PASS_RESEARCH_COMMIT_BYTES`.
+The last command requires the publication commit and full source history.
+Both registered commands have 120-second timeouts. Direct verification also
+works in a Git-free export containing these six files.
+
+## Scope and implementation limits
+
+The all-size theorem rests on the written block proof and cited lemmas.
+The finite verifier does not prove those premises. Its generic matrices have
+independent formal entries and need not be prefixes of a common word; their
+exact row counts do not prove sharpness for actual words.
+
+The finite emitter accepts at most sixteen factors and height four. Generic
+matrix checks use at most ten rows. Polynomial operations enforce at most
+64 terms and word length 32. All loops have finite fixture or capacity bounds,
+the emitter uses a bounded explicit stack, and no function exceeds sixty lines.
+Python allocation is a managed-runtime deviation from fixed allocation; the
+matrix and polynomial capacities bound live objects. The only indirect calls
+are three fixed invalid-argument control variants. There is no recursion,
+subprocess, network access, solver, dynamic code generation or external
+dependency in the verifier. Diagnostics use warning-strict normal and optimized
+execution.
+
+Rounded-leaf execution, negative-leaf preimages, internal magnitude and
+coefficient preparation, precision/tape integration, native realization, stock,
+ownership and a complete supplier invoice remain unrun or unproved here.
+The selected result and its five framework assumptions are unchanged.
+Independent human and formal proof-kernel review are unclaimed.
+
+## Open next questions
+
+- Is floor(h^2/2)+h+2 the sharp universal joint interval envelope? Use actual
+  chronological relations between the two prefixes in the six phase-pair
+  formulas. Cancellation and shared scratch across unequal child sizes are
+  the remaining obstacles.
+- Can one exact rounded caller use the smaller envelope in a complete
+  sufficient-precision and physical-cost substitution? First retain its
+  destination support, negative-leaf preimages, preparation and internal
+  magnitudes. No such caller or complete invoice is supplied here.
+
+These questions and their first steps are also recorded in [TASK.json](TASK.json).
+The scope is frozen after this first local improvement.
+
+## Credit and provenance
+
+Chafik Boukhalfa supplies the PR628/905 word and retained lineage. Hanson Sun
+supplies PR1085's prefix-entry invariant. Charles Bethin supplies PR1278's
+squarefree-interval theorem and PR1416's distinction between a column and a
+joint-state bound. Arham Tahir supplies PR1374's quadratic lower family and
+explicit open upper-bound question. Philippe Van Velzen's PR2177 settles the
+different completed-leaf destination problem. Philipp/mightyOil, Gareth
+Davidson and 0xkilgore retain the precision, perturbation and restoration
+lineage credited in those sources.
+
+[SOURCES.json](SOURCES.json) pins exact main-tree proof and context blobs at
+`de5ec2e7a6074068452f45b1a191b5c72832df4a`. They are historical proof premises,
+not runtime imports. The current `uniform-transfer-audit` card is explicitly
+changed to this original algebraic side result. Current selected-metadata
+orientation passed; no selected scientific replay is claimed.
+
+[Advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19214460).

research/protected-boundary-interval-bound/SOURCES.json

@@ -0,0 +1,42 @@
+{
+  "schema_version": 1,
+  "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a",
+  "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/single-register-interval-transport/vendor/PR1085-PROOF.md",
+      "usage": "provenance",
+      "git_blob": "b794f4253b30f9af1d29c875097d04349715582b",
+      "sha256": "b21febd8202b433f3f7c046e2c62e29c5772c8bee79327c51729d500c024a8b2"
+    },
+    {
+      "path": "research/commuting-interval-audit/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "de9c8fca358c225e2ef30180c553717208015252",
+      "sha256": "17d346b53eb71780410e1ec5e87d56bc444215a540e98c84283f12553c0c81e9"
+    },
+    {
+      "path": "research/dirty-interval-coefficient-boundary/README.md",
+      "usage": "provenance",
+      "git_blob": "59cb826f1378d1311fa1994c872e3bf20703f669",
+      "sha256": "41c69924abe9881d4b68549879dd248adccfd379899281ad6b9289b814429604"
+    },
+    {
+      "path": "research/leaf-destination-transport-bound/README.md",
+      "usage": "provenance",
+      "git_blob": "b8d857e408f4e0bbdff33d33a134a6d8e8f4649c",
+      "sha256": "01a2c4d599fd6e071c613026627fdf980b45f9cfaadb9cbb0c96d9ab5591ebd9"
+    }
+  ]
+}