Record the owner-indexed y0 defect and its monomial charge

research/owner-indexed-y0-clearance/PROOF.md

@@ -0,0 +1,183 @@
+# An owner-indexed reading clears y0 and keeps the restored x0 block
+
+Prepared by unpaidmoon with substantial Cursor Grok assistance. Apache-2.0.
+
+No new κ is claimed. The selected frontier is unchanged.
+
+## Object
+
+Use the published two-edge feed in
+[research/coded-active-feedback](../coded-active-feedback/PROOF.md).
+After the left endpoint the replay stores four banks. Bank 2 carries the
+restored coefficient
+
+```text
+A = D1 Q^{-1}
+```
+
+together with the y0 coupling `B` and a three-term x1 block. Bank 1 is the
+pure y0 monomial `G`. Banks 0 and 3 are the other endpoint banks. All four
+are among the 39 saved banks. This note does not rerun the declared
+alternating-family lock.
+
+An owner index assigns to every owner `o` and every final bank `b` a
+D-exponent-0 element `m_{o,b}` of the predecessor's `Q, C1, C3` algebra.
+The reading on that owner is the left combination of the four banks. It
+does not mix owners. The published operators are owner-scalar: the
+predecessor's coupling rank is `112` times a frequency factor. An arbitrary
+input supported on one owner therefore forces the same operator equation
+on that owner. Negative D exponents, owner-mixing maps, and a new feedback
+edge are outside this statement.
+
+## Normal forms
+
+The pinned replay gives the D-exponent-0 quotients by the unit `A`
+
+```text
+x = X0 A^{-1} = Q^{-1} C1 Q + Q^2 C1 Q
+g = G A^{-1} = C1 Q^2
+b = B A^{-1} = Q^{-1} C1 Q^2 - Q^{-1} C1 Q^{-1}
+```
+
+with `X0` the x0 block of bank 0. Write `s = Q^{-1} C1 Q^2` and
+`t = Q^{-1} C1 Q^{-1}`, so `b = s - t`. The four products are
+
+```text
+(Q^{-1} C1 Q) s = Q
+(Q^{-1} C1 Q) t = Q^2
+(Q^2 C1 Q) s = 1
+(Q^2 C1 Q) t = Q
+```
+
+using `Q^4 = 1` and `C1^2 = 1`. Hence
+
+```text
+x b = (Q - Q^2) + (1 - Q) = 1 - Q^2.
+```
+
+Also `C1 g = Q^2`, so `x b - 1 = -C1 g` and `(x b - 1) g^{-1} = -C1`.
+The inverse is `g^{-1} = Q^2 C1`, and
+
+```text
+s g^{-1} = Q^{-1},
+t g^{-1} = Q^{-1} C1 Q C1,
+b g^{-1} = Q^{-1} - Q^{-1} C1 Q C1.
+```
+
+The constant defect is therefore
+
+```text
+const = -b g^{-1} = -Q^{-1} + Q^{-1} C1 Q C1
+       = Q^{-1} (C1 Q C1 - I).
+```
+
+Both words are outside the short declared family of alternating `C1`/`C3`
+words, with or without a right `Q^2`. The first word is not an even-Q word.
+Let `E` be the span of normal forms whose every Q run has even exponent.
+Products stay in `E`: adjacent even exponents add to an even exponent, and
+reduction by `Q^4` subtracts a multiple of 4. `C1` lies in `E`, while
+`const` does not, so `m0` and `m1` are never both in `E`.
+
+Bank 3's x0 and y0 columns are single monomials on D-exponent `(1, 1)`.
+Left multiplication by a D-exponent-0 element preserves that line. The
+target `A` has no D3 component, and a monomial has an inverse in this
+algebra, so the bank-3 coefficient in any solution is 0.
+
+## The identity
+
+For an arbitrary D-exponent-0 element `m0`, set
+
+```text
+m3 = 0
+m2 = 1 - m0 x
+m1 = const - m0 C1.
+```
+
+Right-multiplying the x0 and y0 equations by `A^{-1}` reduces them to
+`m0 x + m2 = 1` and `m0 + m1 g + m2 b = 0`. The second is the calculation
+above. Equivalently, every solution satisfies
+
+```text
+m1 + m0 C1 = const.
+```
+
+The two coefficients in `const` are `±1`. No choice of `m0`, and no choice
+of owner, changes either coefficient in this combination. Choosing
+`m0 = -Q^{-1} C1` moves the pure `Q^{-1}` term from `m1` into `m0`; the
+combination is still `const`. This is an identity in the predecessor's
+algebra, not a search over a bounded ansatz. In a quotient that identifies
+further words, the image of this identity remains true, but a collapsed
+word could make the same element look cheaper. No such quotient is proved
+here.
+
+## The constant-index map
+
+Use the same multipliers on every owner:
+
+```text
+m0 = 0,  m1 = const,  m2 = 1,  m3 = 0.
+```
+
+Write them into a fresh image
+
+```text
+S = bank 2 + const · bank 1.
+```
+
+Bank 1 has zero x0, x1, and y1, so
+
+```text
+S_x0 = A,  S_y0 = B + const · G = 0,  S_y1 = 0,
+```
+
+and `S_x1` equals bank 2's x1 block. That block is the published coefficient
+
+```text
+(Q^{-1} C1 Q C1 - Q^{-1}) D1 + Q^{-1} C3 D1 D3,
+```
+
+three monomials, none of them removed. The four stored endpoint banks are
+only read. They stay equal to the replayed left endpoint.
+
+## Charge
+
+The algebraic charge is the pair of monomials in `const`, with coefficients
+`-1` and `+1`, on every owner. The field ledger below is one circuit for
+the constant-index choice. It is an upper bound for that circuit under the
+predecessor's published units. It is not a minimum circuit cost, not a
+tape proof, and not a new κ.
+
+The predecessor charges one F-transpose at 896 scalar ADDs, 224 monomial
+passes and 16 mode CLEARs; one 112-field addition at 112 ADDs; one capture
+at 112 COPYs; and one uniform `Q^2` at 112 monomial passes. This ledger
+uses those units. Each of `Q` and `Q^{-1}` is charged as one uniform
+monomial pass, the same unit as `Q^2`, because each is one monomial per
+field. If `Q^{-1}` must be expanded as three factors, the monomial count
+rises by 224 and this table is only a lower figure for that alternative.
+That expansion is not established here.
+
+The factored circuit, overwriting scratch and keeping both sources stored,
+is:
+
+| Step | Inherited unit | Count |
+| --- | --- | ---: |
+| Copy bank 1 into `U` | 112 COPYs | 1 |
+| `V ← C1 U` | one F-transpose | 1 |
+| `V ← Q V` | 112 monomial passes | 1 |
+| `V ← C1 V` | one F-transpose | 1 |
+| `V ← V - U` | 112 scalar ADDs | 1 |
+| `V ← Q^{-1} V` | 112 monomial passes | 1 |
+| Copy bank 2 into `S` | 112 COPYs | 1 |
+| `S ← S + V` | 112 scalar ADDs | 1 |
+
+The totals are 2016 scalar ADDs, 672 monomial passes, 32 mode CLEARs,
+224 COPYs, 336 extra fields, and the predecessor's 8 mode fields reused.
+No Gaussian child is added. Banks 0, 1, 2, and 3 are not written.
+
+## What is not proved
+
+The x1 block of `S` is unpaid. Owner-mixing maps, multipliers with a
+nonzero D exponent, and a feedback edge outside the published two-edge
+feed are not classified. The formal algebra is the predecessor's
+sufficient identity model. Native tape, precision, compiler, and outer
+costs are not repriced. The selected conditional κ is not changed.

research/owner-indexed-y0-clearance/README.md

@@ -0,0 +1,118 @@
+# Owner-indexed reading clears y0 and keeps x0
+
+**Scoped identity and field ledger; 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}` and clears y0 has the same defect
+
+```text
+m1 + m0 C1 = -Q^{-1} + Q^{-1} C1 Q C1.
+```
+
+The constant index `m0 = 0`, `m1 = const`, `m2 = 1` writes that defect
+into a fresh image. The four stored endpoint banks are not overwritten.
+The image's x1 block is the published three-term coefficient and stays
+unpaid. [PROOF.md](PROOF.md) gives the products and the circuit.
+
+The selected frontier is unchanged. This does not rerun the declared
+alternating-family lock, and it does not test a new feedback edge.
+
+## Result
+
+The predecessor replay stores `A = D1 Q^{-1}` on final bank 2 together
+with the y0 coupling, and stores a pure y0 monomial on final bank 1.
+Right division by the unit `A` produces three D-exponent-0 elements
+`x`, `g`, and `b`. Finite multiplication gives `x b = 1 - Q^2` and
+`C1 g = Q^2`, so every D-exponent-0 coefficient `m0` determines
+
+```text
+m3 = 0,  m2 = 1 - m0 x,  m1 = const - m0 C1,
+const = Q^{-1}(C1 Q C1 - I).
+```
+
+Both coefficients in `const` are forced. Moving `Q^{-1}` into `m0` does
+not delete it from the combination. The constant-index fresh image
+
+```text
+S = bank 2 + const · bank 1
+```
+
+has x0 block `A`, y0 block 0, and the original x1 block. Banks 0, 1, 2,
+and 3 stay equal to the replayed left endpoint.
+
+One factored circuit, using the predecessor's published field units and
+charging each of `Q` and `Q^{-1}` as one 112-field monomial pass, costs
+2016 scalar ADDs, 672 monomial passes, 32 mode CLEARs, 224 COPYs, and
+336 extra fields, with 8 mode fields reused and no new Gaussian child.
+That count is an upper bound for this circuit. It is not a minimum and
+not a tape proof. A three-factor reading of `Q^{-1}` is not settled.
+
+## Reproduce
+
+From the repository root, Python 3.12, standard library only:
+
+```sh
+python3 -B scripts/research_package.py --package research/owner-indexed-y0-clearance --check-only
+python3 -B scripts/research_package.py --package research/owner-indexed-y0-clearance
+```
+
+Direct replay:
+
+```sh
+python3 -I -W error -B research/owner-indexed-y0-clearance/verify.py
+python3 -I -O -W error -B research/owner-indexed-y0-clearance/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 and its extra charges.
+This package does not change the query demand. It takes the owner-indexed
+remainder of handoff
+[discussion comment 19138525](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19138525)
+after [research/coded-active-feedback](../coded-active-feedback/README.md)
+restored the missing coefficient. The declared-family obstruction is the
+fork package behind draft PR 152; its census is not repeated.
+
+Base commit: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`. Pins are in
+[SOURCES.json](SOURCES.json). The catalogue and selected record are
+provenance. `search.py` is a live input. The selected conditional value
+used for orientation is the selected record,
+`781451/250000000`, not the older decimal printed in the revision-8
+priority note.
+
+Local overlap at that commit searched the complete note inventory and
+found no note containing both "owner-indexed" and "y0 coupling". The
+remote overlap cache was absent. A live open-PR search for `y0` on
+CrocSwap/integer-mult-bounds returned no pull requests. That search is
+not a novelty certificate.
+
+## Open next questions
+
+Can a fresh image clear the three-term x1 block while keeping x0 equal
+to `D1 Q^{-1}`, keeping y0 zero, and leaving the four final banks stored
+unchanged? The y0 term is no longer the obstruction on this image. The
+first step is the same four-bank equation on the x1 column, with every
+new monomial charged. This package leaves the published x1 coefficient
+in place.
+
+Does one inherited monomial pass implement `Q` and `Q^{-1}`, or must
+`Q^{-1}` be expanded before the field ledger is a tape cost? The ledger
+uses the predecessor's `Q^2` unit for each uniform power. The first step
+is to bind the source monomial primitive for a single power of `Q`. No
+native word is replayed 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 one-point odd-Q correction from final bank 1, without
+this owner-index identity or this charge, is the fork package
+`research/active-feedback-coupling-lock`. 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-y0-clearance/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "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"
+    },
+    {
+      "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"
+    }
+  ]
+}