Prove no D-exponent-0 owner index clears the x1 block

research/owner-indexed-x1-obstruction/PROOF.md

@@ -0,0 +1,221 @@
+# No D-exponent-0 owner index clears the three-term x1 block
+
+Prepared by unpaidmoon with substantial Cursor Grok assistance. Apache-2.0.
+
+No new κ is claimed. The selected frontier is unchanged.
+
+Evidence class: **proof** in the predecessor's formal algebra, under the
+hypotheses below. The multiplier space is infinite. This is not an
+enumeration of words, not a bounded search, and not a theorem about every
+quotient or every physical caller.
+
+## Object
+
+Use the published two-edge feed in
+[research/coded-active-feedback](../coded-active-feedback/PROOF.md),
+replayed by `search.replay(one, C1 Q^2)`. After the left endpoint the
+replay stores four banks. Bank 2 carries
+
+```text
+A = D1 Q^{-1}
+```
+
+together with the y0 coupling and the three-term x1 block. The reading on
+one owner is a left combination of these four banks by D-exponent-0
+elements `m0, m1, m2, m3` of the predecessor's `Q, C1, C3` algebra. It
+does not mix owners. The four stored banks are only read. A fresh image is
+this combination and nothing else.
+
+Negative D exponents, owner-mixing maps, and a feedback edge outside the
+published two-edge feed are outside this statement. The declared
+alternating-family lock and the one-edge `C1 Q` row are not re-proved.
+
+The algebra is the one installed by `search.algebra()`: words in the free
+product `C4(Q) * C2(C1) * C2(C3)`, with formal D exponents, and with `D_i`
+conjugating only `C_i` by `Q^{-1}`. A D-exponent-0 left factor therefore
+concatenates words and preserves the D degree of the right factor.
+
+## The banks
+
+The replay equals the following columns. Here `D(1,0)` is `D1` and
+`D(1,1)` is `D1 D3`.
+
+```text
+bank 0:  x0 = (Q^{-1} C1 + Q^2 C1) D1
+         y0 = Q^{-1} D1
+         x1 = -Q^2 C1 D1
+         y1 = 0
+bank 1:  y0 = C1 Q D1
+         x0 = x1 = y1 = 0
+bank 2:  x0 = A = Q^{-1} D1
+         y0 = (Q^{-1} C1 Q - Q^{-1} C1 Q^2) D1
+         x1 = (Q^{-1} C1 Q C1 - Q^{-1}) D1 + Q^{-1} C3 D1 D3
+         y1 = 0
+bank 3:  x0 = C3 Q^{-1} C1 D1 D3
+         y0 = C3 D1 D3
+         x1 = (-I - C3 Q^{-1} C1 + C3 C1) D1 D3
+         y1 = C3 Q D1 D3
+```
+
+`verify.py` compares these polynomials with the replay. Bank 3's x0 column
+is the only x0 column on the `D1 D3` line, and it is a monomial. Its
+two-sided inverse in the algebra sends `m3` times that column to `m3`.
+The target `A` has no `D3` component, so every solution of `S_x0 = A` has
+`m3 = 0`.
+
+## The forced shape
+
+Write `x` for bank 0's x0 column times `A^{-1}`, and write
+
+```text
+const = Q^{-1}(C1 Q C1 - I) = -Q^{-1} + Q^{-1} C1 Q C1.
+```
+
+Direct multiplication gives
+
+```text
+x = (Q^{-1} + Q^2) C1 Q = Q^2 (I + Q) C1 Q,
+Q^{-1} + Q^2 = Q^2 (I + Q),
+bank0_x0 = x A,
+bank2_x1 = const D1 + Q^{-1} C3 D1 D3.
+```
+
+The second formula for `x` uses `Q^2 Q = Q^3 = Q^{-1}`. Thus every
+D-exponent-0 solution of `S_x0 = A` has
+
+```text
+m2 = 1 - m0 x.
+```
+
+Bank 1 has zero x1, and `m3 = 0`, so
+
+```text
+S_x1 = bank2_x1 + m0 (bank0_x1 - x bank2_x1)
+     = (const - m0 C1) D1 + (1 - m0 x) Q^{-1} C3 D1 D3.
+```
+
+The same two element identities
+
+```text
+bank2_y0 + const · bank1_y0 = 0,
+bank0_y0 - C1 · bank1_y0 - x bank2_y0 = 0
+```
+
+give, for `m1 = const - m0 C1`, the y0 column `S_y0 = 0`. Banks 0, 1, and
+2 have zero y1, so `S_y1 = 0` as well. Imposing y0 zero fixes `m1` and
+does not appear in `S_x1`.
+
+## The D1 D3 summand never vanishes
+
+Right multiplication by the group element `Q^{-1} C3` is bijective on the
+D-exponent-0 algebra: its two-sided inverse is `C3 Q`, and
+
+```text
+(Q^{-1} C3)(C3 Q) = I = (C3 Q)(Q^{-1} C3).
+```
+
+A D-exponent-0 left factor does not change D degree, so
+
+```text
+(1 - m0 x) Q^{-1} C3 D1 D3 = 0
+```
+
+if and only if `1 - m0 x = 0`.
+
+Suppose `m0 x = 1`. Substitute the factorization of `x` and cancel the
+unit `C1 Q` on the right:
+
+```text
+m0 Q^2 (I + Q) = Q^{-1} C1.
+```
+
+Let `φ` be the linear map on the D-exponent-0 algebra that sends a word
+to `(-1)` raised to the number of letters of absolute value 1, and a
+linear combination to the corresponding combination of those signs. Then
+`φ(I + Q) = 1 + (-1) = 0` and `φ(Q^{-1} C1) = -1`.
+
+This `φ` is an algebra homomorphism. Multiplication concatenates words
+and then runs the installed reducer. Each reducer step preserves the
+parity of the Q-letter count:
+
+- cancelling an adjacent pair `C_i C_i` removes two letters that are not
+  Q letters;
+- a Q run of `n` letters `±1` has exponent sum `s ≡ n (mod 2)`, and the
+  normal form of the exponent modulo 4 has letter count `0, 1, 2, 1` in
+  the four residue classes, hence letter count congruent to `s` modulo 2.
+
+Concatenation adds the counts, so `φ` multiplies on words and therefore
+on the whole algebra. Apply it to the displayed equation:
+
+```text
+φ(m0 Q^2) φ(I + Q) = 0 ≠ -1 = φ(Q^{-1} C1).
+```
+
+No such `m0` exists. Therefore `1 - m0 x` is never zero, and neither is
+the `D1 D3` summand of `S_x1`.
+
+In particular, no fresh image of this form has `S_x1 = 0` while
+`S_x0 = A`. Clearing the block means that zero column: together with
+`S_y0 = S_y1 = 0` it would be the autonomous row `[A, 0, 0, 0]`. The
+subfamily that also keeps `S_y0 = 0` is included. A later
+D-exponent-0 left multiple `u` of such an image still has x0 block `u A`.
+Since `A` is a monomial, `u A = A` forces `u = I`, so that later multiple
+does not clear the summand either.
+
+## The unique index that clears the D1 line
+
+Right multiplication by `C1` is bijective because `C1^2 = I`. The `D1`
+summand vanishes if and only if
+
+```text
+m0 = const C1 = Q^{-1} C1 Q - Q^{-1} C1,
+```
+
+and the y0 equation then forces `m1 = 0`. For this single index the four
+products in `m0 x` are
+
+```text
+(-Q^{-1} C1)(Q^{-1} C1 Q) = -Q^{-1} C1 Q^{-1} C1 Q,
+(-Q^{-1} C1)(Q^2 C1 Q)    = -Q^{-1} C1 Q^2 C1 Q,
+(Q^{-1} C1 Q)(Q^{-1} C1 Q) = I,
+(Q^{-1} C1 Q)(Q^2 C1 Q)    = Q^{-1} C1 Q^{-1} C1 Q.
+```
+
+The first and fourth cancel, so
+
+```text
+m0 x = I - Q^{-1} C1 Q^2 C1 Q,
+m2 = Q^{-1} C1 Q^2 C1 Q.
+```
+
+Right multiplication by `Q^{-1} C3` cancels `Q Q^{-1}` and leaves the
+fresh image
+
+```text
+S = m0 · bank 0 + m2 · bank 2,
+S_x0 = A,  S_y0 = 0,  S_y1 = 0,
+S_x1 = Q^{-1} C1 Q^2 C1 C3 D1 D3.
+```
+
+That x1 column is one monomial, not zero, and it is not the published
+three-term block. The three multiplier monomials are the algebraic charge
+of this near-miss. They do not clear the block. No scalar-field minimum
+and no tape cost are claimed for them.
+
+The constant index `m0 = 0`, `m1 = const`, `m2 = 1` is the predecessor's
+image. Its x1 column is the original three monomials. Both indexes obey
+the same nonvanishing statement.
+
+## What is not proved
+
+A multiplier with a nonzero D exponent can mix the `D1` and `D1 D3`
+lines; this note does not classify it. Owner-mixing maps and any feedback
+operator other than the published pair `(I, C1 Q^2)` are not classified.
+The formal algebra does not impose `D^4 = I` or any further physical
+relation. In a quotient that sends `Q^{-1} C1 Q^2 C1 C3` to zero while
+keeping the displayed character argument's target nonzero, the image of
+the identity `m0 x - 1 = m2` remains true, but this particular monomial
+could vanish. No such quotient is proved here.
+
+The result is not an autonomous decoder, not a new caller bill, and not
+a change of the selected conditional κ.

research/owner-indexed-x1-obstruction/README.md

@@ -0,0 +1,127 @@
+# No owner index clears the three-term x1 block
+
+**Scoped proof; no new κ.** On the published two-edge feed, every
+owner-indexed D-exponent-0 left map of the four final banks that keeps
+`x0 = D1 Q^{-1}` has x1 coefficient
+
+```text
+(const - m0 C1) D1 + (1 - m0 x) Q^{-1} C3 D1 D3.
+```
+
+The second summand is never zero, so the x1 column is never the zero
+element. Keeping y0 zero fixes `m1` and does not cancel that summand. The
+four stored endpoint banks are not overwritten. The autonomous row would
+be `[A, 0, 0, 0]`. Removing the three published keys still leaves one
+monomial, so that row is not reached.
+
+Exactly one index also clears the `D1` line. It keeps y0 zero and leaves
+the single monomial `Q^{-1} C1 Q^2 C1 C3 D1 D3`. That image is not a
+clearance of the three-term block. [PROOF.md](PROOF.md) gives the products
+and the parity character.
+
+The selected frontier is unchanged. This does not rerun the y0 defect,
+the declared alternating-family lock, or a feedback-edge test.
+
+## Result
+
+The predecessor replay stores `A = D1 Q^{-1}` on final bank 2 together
+with the published three-term x1 block, and stores a pure y0 monomial on
+final bank 1. For each D-exponent-0 element `m0`, the other coefficients
+that keep `x0 = A` and clear y0 are uniquely
+
+```text
+m3 = 0,  m2 = 1 - m0 x,  m1 = const - m0 C1.
+```
+
+Here
+
+```text
+x = Q^2 (I + Q) C1 Q,  const = Q^{-1}(C1 Q C1 - I).
+```
+
+The element `I + Q` is sent to zero by the Q-letter parity character,
+while `Q^{-1} C1` is sent to `-1`. That forbids `m0 x = 1`, so the
+`D1 D3` summand cannot vanish.
+
+The sharp index `m0 = const C1` uses the two monomials
+`-Q^{-1} C1 + Q^{-1} C1 Q` and the one monomial
+`m2 = Q^{-1} C1 Q^2 C1 Q`. Its fresh image has x0 block `A`, y0 block 0,
+y1 block 0, and x1 block the single monomial above. This is an identity
+in the predecessor's algebra, not a search over a bounded ansatz.
+
+## Reproduce
+
+From the repository root, Python 3.12, standard library only:
+
+```sh
+python3 -B scripts/research_package.py --package research/owner-indexed-x1-obstruction --check-only
+python3 -B scripts/research_package.py --package research/owner-indexed-x1-obstruction
+```
+
+Direct replay:
+
+```sh
+python3 -I -W error -B research/owner-indexed-x1-obstruction/verify.py
+python3 -I -O -W error -B research/owner-indexed-x1-obstruction/verify.py
+```
+
+The optimized command still executes the checks. They are `need` failures,
+not assertions. No network, native build, or full multiplier replay is used.
+
+## Scope
+
+Original card: `joint-query-controller`. Scope status: **refined**. The
+card asks for one source-bound caller identity, or an obstruction to that
+change, together with its charges. This package does not change the query
+demand. It takes the x1-column question in
+[research/owner-indexed-y0-clearance](../owner-indexed-y0-clearance/README.md),
+which is the remainder of handoff
+[discussion comment 19138525](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19138525)
+after that package cleared y0 and left the published x1 coefficient in
+place.
+
+Base commit: `17469fff78c22941280f04d39dc5a1faee09c840`. Pins are in
+[SOURCES.json](SOURCES.json). The catalogue and selected record are
+provenance. `search.py` and `gauge.py` are live inputs. The selected
+conditional value is the selected record, `781451/250000000`.
+
+Overlap at this base used `scripts/find_overlap.py` against a snapshot
+fetched on 2026-11-10: local notes at
+`17469fff78c22941280f04d39dc5a1faee09c840` (10178 paths, complete
+inventory), 317 open-PR records at 08:49:48Z, and 6971 discussion records
+at 08:50:49Z. Requiring both phrases `three-term x1` and `owner-indexed`
+matches the predecessor package and
+[discussion reply 19507118](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19507118),
+which ask this question, and no open PR. That search is not a novelty
+certificate. Closed PR bodies were not part of that snapshot.
+
+## Open next questions
+
+Can one owner-indexed multiplier whose D exponent is not zero cancel
+`Q^{-1} C1 Q^2 C1 C3 D1 D3` while keeping `x0 = D1 Q^{-1}`, keeping y0
+zero, and leaving the four final banks stored? The argument here separates
+the `D1` and `D1 D3` lines only for a D-exponent-0 factor. The first step
+is to add one term of D exponent `(0,-1)` to the sharp index above and
+recompute the four columns. This package does not solve that term.
+
+Does one physical relation omitted by this formal algebra send the
+residual word `Q^{-1} C1 Q^2 C1 C3` to zero without collapsing
+`Q^{-1} C1`? Nonvanishing is an identity in the predecessor's sufficient
+algebra, not a faithful physical impossibility. The first step is to name
+one source relation outside `Q^4 = C1^2 = C3^2 = I` and the inherited D
+conjugation rule, then reduce only that word. No such relation is imposed
+here.
+
+## Credit
+
+The trace, algebra, and published row are Cinna Davis's
+`research/coded-active-feedback`, using Dugongue's PR4948 chronology,
+Dillon's PR4933 code, and the passive ceiling packaged by Chris R /
+Clear1nsight. The y0 defect and the constant-index charge are
+`research/owner-indexed-y0-clearance`. The declared-family obstruction is
+`research/active-feedback-coupling-lock`. The one-edge `C1 Q` row is
+`research/active-feedback-outside-edge`. The gauge engine remains the
+inherited `research/coded-native-caller/gauge.py`.
+
+Prepared by unpaidmoon with substantial Cursor Grok assistance.
+Apache-2.0.

research/owner-indexed-x1-obstruction/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "base_commit": "17469fff78c22941280f04d39dc5a1faee09c840",
+  "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"
+    },
+    {
+      "path": "research/coded-active-feedback/search.py",
+      "usage": "input",
+      "git_blob": "60de5a87d3f64fc69e2595cdb2df771c91a0fe6e",
+      "sha256": "1383010827af29a1b0e595e2c1aa2ffad461b266ffc9f936efce1603ff9f5eb6"
+    },
+    {
+      "path": "research/coded-native-caller/gauge.py",
+      "usage": "input",
+      "git_blob": "44ae72b314cccf677b44d75c374be6dcac1c8167",
+      "sha256": "390391d291353741c89daea999d483660ca185987ed96a15b82576280c487cad"
+    }
+  ]
+}