Independent verification: R420 compensation rank and minimum-weight kernel

research/r420-compensation-rank80/CLAIM.md

@@ -0,0 +1,59 @@
+# Local sprint claim
+
+- Track: independent verification (assignment seed **80**, drawn with
+  `secrets.randbelow(100)` from OS randomness on 2026-10-13).
+- Exact base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+- Claimed at 2026-10-13 04:45 UTC; expected finish by 05:05 UTC.
+- Object: the 120-by-420 dirty-helper correction map of the accepted PR543
+  R420 bit word, consumed unchanged by selected PR626.
+- Method: independently propagate target observables backward through
+  A/scatter/B (transpose circuit, rather than forward register expressions).
+  Compare the resulting helper coefficients with D; certify rank by an
+  explicit invertible minor and derive the entire right kernel. Seed 80
+  rotates the helper-column pivot order and selects control targets.
+- Deliverable: source-pinned standard-library verifier, exact certificate,
+  rejecting controls, and a scoped linear-summary dimension consequence.
+  No new circuit, runtime saving, kappa, or full multiplication theorem.
+
+Three candidates considered: selected cold-wrapper identities (overlaps
+#702 and our #712), selected moment inequalities (overlaps #678/#706),
+and this correction-map rank/kernel certificate (chosen). Existing PR543
+`xcheck.py` already verifies K=D by forward symbolic propagation; this run
+adds a different propagation direction and explicit full-rank/kernel evidence.
+The recent #686/#694 helper-basis and #713/#716 target-basis constructions
+optimize D but do not claim this certificate. #612 formalizes boundaries/B;
+its D compensation equality remains open. None of those pending patches is
+consumed here. The fixed-frame search #661 does not exclude circuit changes.
+
+The refreshed open-PR queue included #716. There were no pinned issues and
+Discussions was disabled; no separate reservation issue was opened. No
+workers were delegated. Scope is a fixed finite object, not a search for a
+stronger bound. Stop after exact rank/kernel and control checks are complete.
+The first 20% is reserved for selection and the final 25% for verification
+and handoff.
+
+## Result — 2026-10-13 04:58 UTC
+
+Completed and submitted as
+[PR #731](https://github.com/CrocSwap/integer-mult-bounds/pull/731).
+The correction has rank 120, nullity 300, and minimum nonzero kernel weight
+4, with exactly 18 weight-four vectors. The latter follows from the complete
+87,990-pair census on the same fixed map, not an expanded supplier search.
+The package supplies an inverse minor, all kernel directions by a compact
+formula, 120 isolated target-error inputs, ten rejecting controls and seven
+independent obligation tests. Normal/optimized runs, a minimal clean export,
+the original frame/scalar/interface checker, selected-record integrity and
+ledger checks pass; see VALIDATION.json. No new kappa is claimed.
+
+The final pre-submission refresh covered 547 open PRs through #728, with main
+still at the exact base. Two arrivals were checked immediately after posting:
+#729 (`deaed262cebc50bdb0c27c6ba132b8f8289b3eef`) checks complex helper frame
+lifetimes; #730 (`d222e348179cc02a54d6d26dbd2838944f62c6e5`) optimizes ordered
+dirty echoes. Neither overlaps this fixed bit correction matrix. No pinned
+sprint issue was available, so this is the single local result update.
+
+Implementation/certificate commit:
+`0e10ed667c0cc435eb0f69c71a1d542599cad170`; the follow-up changes only this
+claim. Verification and packaging occupied the final part of the run, and
+the contribution finished before the recorded deadline. No workers were
+delegated and no selected-frontier or upstream files changed.

research/r420-compensation-rank80/OVERLAP.json

@@ -0,0 +1,81 @@
+{
+  "additional_arrivals_checked": [
+    719,
+    720,
+    721,
+    722,
+    723,
+    724,
+    725,
+    726,
+    727,
+    728
+  ],
+  "consumed_pending_code": false,
+  "newest_pr": 728,
+  "open_pr_count": 547,
+  "pinned_sprint_issue": null,
+  "related_prs": [
+    {
+      "headRefOid": "688258f863410419d10e34b0b3014b91cdce632c",
+      "number": 718,
+      "title": "Scoped negative result: R420 split target reads cannot lower the paid moment"
+    },
+    {
+      "headRefOid": "67e9e846d9e8814b2dd01133251bb83fafa8f5b6",
+      "number": 717,
+      "title": "Format limits part 2 (no \u03ba claim): erratum to #595, exact invoice prices, frontier-word censuses, decoder floors, spec requirements, centre and fragmentation walls"
+    },
+    {
+      "headRefOid": "afeb452f58ff0cbf109172335e2ba282aac3dcde",
+      "number": 716,
+      "title": "Research: optimal disjoint R420 target pairs save 3,250 XORs (no new kappa)"
+    },
+    {
+      "headRefOid": "1a19af5c5ddb6de9797a6d085e5df0b90ed6d58b",
+      "number": 713,
+      "title": "Research: save 3,150 R420 XORs with a restored target basis"
+    },
+    {
+      "headRefOid": "4773b879a1087540f5919c726ec8c670dadfa0c5",
+      "number": 712,
+      "title": "Independent verification: quadratic-phase certificate for a selected cold wrapper"
+    },
+    {
+      "headRefOid": "0f7dbb54948775c010b5e5bc8ab3cf92a52a9b25",
+      "number": 706,
+      "title": "Independent verification: selected complex moments via integer root bounds"
+    },
+    {
+      "headRefOid": "27db45ac6befa99d6c06be920a93845023e81937",
+      "number": 702,
+      "title": "Research audit: verify all selected cold-wrapper amplitudes (no new kappa)"
+    },
+    {
+      "headRefOid": "9732ac127dd4bef98a846aaa904c20b5a84e72c1",
+      "number": 694,
+      "title": "Research: save 6,934 R420 XORs with a restored helper basis"
+    },
+    {
+      "headRefOid": "23dcb610c2b156b76b9d599ea296c3cbde224b2d",
+      "number": 686,
+      "title": "Research: save 108 R420 XORs with restored frame-zero sharing (no new kappa)"
+    },
+    {
+      "headRefOid": "bdc9317efd6d928a0f050159670d1316ba5f4c5b",
+      "number": 678,
+      "title": "Independent verification of the #543 bit moment using binomial enclosures"
+    },
+    {
+      "headRefOid": "9ca7aa3ab0a3260a2f36ac86b9911a31fd88bd89",
+      "number": 661,
+      "title": "Scoped negative result: R420 phase-B frames are moment-optimal at fixed gate order"
+    },
+    {
+      "headRefOid": "ce37f3ce35ba8891771e01492b3a21978763bebb",
+      "number": 612,
+      "title": "[Lean] Verify current R420 boundaries and B-XOR interfaces"
+    }
+  ],
+  "snapshot_utc": "2026-10-13 04:55:31 UTC"
+}

research/r420-compensation-rank80/README.md

@@ -0,0 +1,166 @@
+# Exact rank and minimum-weight kernel of R420 dirty compensation
+
+**Independent verification; no new kappa or circuit.** The selected PR543
+R420 word has a dirty-helper correction matrix `K` of size 120 by 420 over
+F2. This package certifies **rank(K) = 120**, **nullity(K) = 300**, and
+**minimum nonzero kernel weight 4**. There are exactly **18** weight-four
+kernel vectors. All 420 columns are distinct and nonzero.
+
+The source is eumemic's PR543 at
+`2065fe4f72a914d907f1046603f5a36f17018535`, unchanged in base
+`66849e1475c930fd7732b1a0067ffee7e1e95f60`. The selected construction is
+PR626 (`660de893d27bb7abd1d5b01b1640207528a5c851`) with PR543,
+conditional kappa `51110230636731/31250000000000000`.
+[SOURCES.json](SOURCES.json) records archive/payload SHA-256, Git blob IDs,
+and the selected record, manifest, construction, checker and review pins.
+
+From the repository root, with Python 3.10+ and no external dependencies:
+
+```sh
+python3 -I -B research/r420-compensation-rank80/verify.py
+```
+
+Expected:
+
+```text
+PASS_R420_DIRTY_RANK rank=120 nullity=300 distance=4 pairs=87990 isolated_errors=120 controls=10
+```
+
+The additional independent scalar tests run with:
+
+```sh
+python3 -I -O -B research/r420-compensation-rank80/test_verify.py
+```
+
+Expected: seven tests pass. `verify.py --write /tmp/new-certificate.json`
+reconstructs the complete certificate and refuses to overwrite an existing
+file. Normal and optimized Python execute the same explicit checks.
+[VALIDATION.json](VALIDATION.json) records the Linux checks, including a
+minimal clean export containing only this package and its pinned inputs.
+
+## What is checked
+
+Registers 0–119 are sources `x`, 120–239 are targets `y`, and 240–659 are
+arbitrary helper inputs `s`. For `W0 = A; scatter; B`, the existing PR543
+interface states
+
+`W0(x,s,y) = (U(x,s), y + Jx + Ks)`.
+
+The original `xcheck.py` already checks `J=I`, `V=I`, and `K=D` by forward
+symbolic register propagation. That identity is predecessor work. This
+implementation imports no supplier code: it **pulls target observables
+backward** through the actual gate order. For a gate `r_d += sum r_s`, a
+covector changes by `q_s += q_d` for each source, with `q_d` unchanged.
+This is its exact transpose action, since
+
+`q · G r = (G^T q) · r`.
+
+Reversing all 3,021 A/scatter/B gates (4,021 binary additions) yields all
+120 target observables simultaneously. Their source and target blocks are
+each the identity, and their helper block equals the literal frame-zero D
+matrix. The retained-total scatter is read directly from `ret` and
+`scatter`; its retained registers are never modified during scatter.
+
+A separate backward pass through D/A/scatter/B/C verifies the entire
+660-column scalar endpoint: `x` and arbitrary `s` are restored, and
+`y -> y+x`. This is a scalar obligation; it does not recheck physical frame
+transport or the COPY/ERASE realization of scatter.
+
+## Rank, diagnostic inputs, and a complete kernel basis
+
+[EXPECTED.json](EXPECTED.json) contains every row of K, 120 selected helper
+indices, and the exact inverse of their 120-by-120 column minor `M`.
+Bit j of a hexadecimal integer denotes coordinate j; K rows use
+helper-relative indices 0–419, while lists explicitly marked `absolute`
+use registers 240–659. Inverse row j corresponds to pivot position j.
+
+The verifier checks **both** `M M^-1 = I` and `M^-1 M = I` by exact products.
+Nomination and Gaussian elimination are not accepted as rank evidence on
+their own. Embedding the rows of `M^-1` in the chosen helper positions gives
+a 420-by-120 right inverse `H` with `KH=I`. In particular, helper input
+`H e_t` causes exactly target error `e_t` if D is omitted. These **120
+isolated-error inputs** are reproducible diagnostics for future correction
+circuits. They distinguish every target error direction, whereas testing
+only clean helpers cannot detect an omitted D at all.
+
+For each nonpivot helper coordinate f, define
+
+`n_f = e_f + H K e_f`.
+
+Then `K n_f = 0`. Each of the 300 vectors has a unique unit coordinate
+among the free positions, so they are independent. Rank-nullity proves
+they span the full kernel. The verifier checks annihilation and the entire
+free-coordinate identity. The exact minor plus this formula is the compact
+kernel certificate; hashes of the generated kernel and H columns are also
+recorded. The 120 H columns together with these 300 kernel vectors form a
+basis of all helper inputs. A separate ordinary Boolean interpreter tests
+all 420 directions through both the raw and complete circuits.
+
+**Scoped consequence.** Any linear factorization `K = A B` with
+`B : F2^420 -> F2^r` needs `r >= 120`. Thus this fixed correction cannot
+factor through fewer than 120 linear summaries. This is not a lower bound
+on simultaneous physical scratch, XOR count, recursive cost, or an altered
+supplier. Summaries can be produced sequentially; the recent basis-changing
+circuits are fully compatible with this rank.
+
+## Exact minimum weight and a concrete cancellation
+
+A kernel vector of weight one would be a zero column of K; a weight-two
+vector would be two equal columns. Neither exists. A weight-three vector
+would satisfy `K_a + K_b = K_c`. All **87,990 unordered column pairs** are
+checked against the complete column set, excluding that possibility.
+
+Equal XORs of two disjoint pairs yield weight-four vectors. The census
+retains all pairs per XOR value, not just one representative, and deduplicates
+sorted supports. Every weight-four vector has three such pair partitions,
+so this exhausts the domain. All 18 supports are in the certificate.
+Seed `80 % 18` selects the example
+
+**absolute helper registers `{284, 296, 521, 623}`**.
+
+Setting those four helper bits to one and all other inputs to zero gives no
+target error in W0. Each of their 14 nonempty proper subsets gives a nonzero
+target error. The separate scalar interpreter checks all 15 subsets for all
+18 supports. Together with the exhaustive lower-weight exclusions this
+establishes minimum weight exactly 4 for this finite linear map. In coding
+notation its kernel is a binary `[420,300,4]` code. This does not identify
+removable helper registers: each individual helper affects the correction.
+
+## Controls, scope, and provenance
+
+Ten controls cover omitted D, one missing D operand, swapped D rows
+(**rank preserved but compensation wrong**), incorrect backward order,
+corrupted inverse, corrupted kernel vector, dependent kernel basis, and
+injected dependencies of weights one, two and three. Additional tests check
+the adjoint identity on all 16 inputs and 16 observables for each of 40
+seeded four-register circuits, both dense inverse products, cleanup damage
+with K unchanged, corrupted source/certificate rejection, and gzip
+recompression acceptance. All proof-relevant input bytes are pinned;
+recompressed containers are compared by their complete decoded payload.
+
+This is a complete finite calculation on the pinned word, not an empirical
+search for a stronger bound or a formal proof in a proof assistant. Pivot
+nomination uses helper order 80–419, then 0–79, and stops at 120 independent
+columns. The distance census completes all 87,990 pairs and retains every
+collision. No solver, probabilistic acceptance or floating arithmetic is
+used. All-size/compiler, common-label/mutable-basis, physical/hosting,
+precision/tape and analytic obligations remain inherited. No new invoice,
+hosted construction, supplier optimum or full multiplication theorem follows.
+
+The reviewed PR543 checker and interleaved-interface argument belong to
+**eumemic**, with their Anthropic Claude disclosure retained in the
+[original notice](../e8-bit-r420/NOTICE.md). Credit also remains with the
+PR493/370/425/472/510 lineage identified there and in the pinned README.
+The current construction/review credit remains with Jeremy Kothe, Chafik
+Boukhalfa and the full selected dependency chain.
+
+Concurrent #686/#694 optimize helper columns, #713/#716 optimize target
+rows, and #612 supplies scoped Lean boundary/B facts. This package imports
+none of those changes and does not certify their implementations; it adds a
+transpose-based check and explicit rank/kernel evidence for their common
+accepted baseline. [CLAIM.md](CLAIM.md) records task selection and overlap.
+
+Prepared by **Joshua Snider**, with substantial **OpenAI Codex assistance**
+in research, mathematics, implementation, testing and writing. Independent
+implementation does not mean independent human review. New material is
+under the repository's [Apache-2.0 license](../../LICENSE).

research/r420-compensation-rank80/SOURCES.json

@@ -0,0 +1,38 @@
+{
+  "base": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "bit_pr543": "2065fe4f72a914d907f1046603f5a36f17018535",
+  "files": {
+    "certificates/selected-result.json": {
+      "base_git_blob": "92a10096dee76479af88a897714b3818d8263141",
+      "sha256": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53"
+    },
+    "docs/research/community-k492-review.md": {
+      "base_git_blob": "11efcd07ae2b9d93d355c6adaf773dca70dbce91",
+      "sha256": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47"
+    },
+    "research/community-k492-audit/SELECTED-SOURCE.json": {
+      "base_git_blob": "5f8725175afc095ff2da92e38af6ef4476c266da",
+      "sha256": "36e9e421230c4cb7b6a537d76a4bdfb6f667730d383e56062d4e45957484ab9e"
+    },
+    "research/e8-bit-r420/NOTICE.md": {
+      "base_git_blob": "cb68783d7d76c3fc13faa571429e9b067a0db3f7",
+      "sha256": "12ba6e0845f222e9940b00f6c60d261db104246a8d3143da267682973479f811"
+    },
+    "research/e8-bit-r420/README.md": {
+      "base_git_blob": "6751eba6f617292fc919e58d5a9f9f06ab037391",
+      "sha256": "9807be57c6adf26b30e4f54e2f8160075bbc05091f1a6d157e43d2a4620c1c9f"
+    },
+    "research/e8-bit-r420/code/xcheck.py": {
+      "base_git_blob": "fbff8607e4c61e18481f696b99dd38a32444e90d",
+      "sha256": "5737d18a7826fd51e131035f2d7bebba2e2868af91dd7672a5f11208b036d424"
+    },
+    "research/e8-bit-r420/data/bitE8mut-r420.json.gz": {
+      "base_git_blob": "0c63ca62759dc63d302be6552aeeee1ede70350f",
+      "payload_sha256": "e597e3885c0a8daa262afa5985ee2930443329126aece76d33159d81882bdcc2",
+      "pr543_git_blob": "0c63ca62759dc63d302be6552aeeee1ede70350f",
+      "sha256": "9721a3819efd68307f66f00d84a952eb28eb7c3ad2ce79653ce295c98a764784"
+    }
+  },
+  "runtime_dependencies": "Python 3.10+ standard library only; no predecessor code imported",
+  "selected_pr626": "660de893d27bb7abd1d5b01b1640207528a5c851"
+}