Preserve exact growing-carrier decoding and dirty-host capture components

research/local-eight-form-capture/README.md

@@ -0,0 +1,93 @@
+# Eight mixed forms captured in existing dirty helpers
+
+This package proves one exact forward local scalar operation on 800 arbitrary
+input fields. It preserves X, sends Y to Y+SX, and sends each of eight
+selected helpers to `h_i + C_i(59X/4 + Y)`. Every other helper is unchanged.
+The eight helper values remain dirty. The operation does not restore them.
+This is a local construction; it gives no complete supplier or kappa gain.
+
+Read the [algebra and operation-order proof](historical/work/complex-next/structural/hamming-factor/HOSTED-CAPTURE-REVIEW.txt)
+and the [separate column review](historical/work/doubling-architecture/rank-independent/live-capture/REVIEW.txt).
+The frozen word has 120 X fields, 120 Y fields and 560 helper fields.
+On its 112 code ports, `S = I - C^T C/4` and `C C^T = 56I`.
+The other eight ports have zero S rows and zero C columns. The captured
+helper indices are 758 through 751. All original values are arbitrary.
+
+The omitted-centre word has `Y -> Y+SX+Dh` and preserves its helper inputs.
+First preload `h1=h+PY`, where P inserts the eight C rows. Then use the
+updated h1 to correct `Y1=Y-Dh1`. The base word gives `Y2=Y+SX`.
+Finally add `(59/4)PX` to the eight helpers. This yields the stated map.
+The base word has 19,449 scalar operations. The capture adds 11,326
+dyadic correction operations and two 448-term loads. The total is 31,671
+scalar operations: 19,449 + 11,326 + 448 + 448. The replay uses
+the updated helper values. The fresh independent review also checked that
+every selected helper column of D is zero, so `D P = 0` in this instance.
+The historical review's warning about a stale-helper error does not apply
+to these eight helpers. It does not affect the verified endpoint.
+
+Preload and dirt correction satisfy the saved zero-frame boundary contract;
+postload satisfies its full-frame contract. These are exact local label
+statements. They do not supply a paid native or phase realization of the
+new boundary operations, a backward program, the routed global controller,
+a physical endpoint decoder, restoration of the eight hosts, or an invoice.
+The selected future Y owners are live data, not free private workspace.
+The included endpoint check records nontrivial chart translations and
+rejects a proposed two-tap tensor shortcut. No such shortcut is used.
+
+## Replay
+
+From this package directory, with Python 3.10 or later:
+
+```sh
+python3 -B verify.py --build /tmp/local-eight-form-capture-replay
+```
+
+The build path must not exist. Only the standard library is required.
+The runner checks source hashes and copies historical files into that path.
+It then checks the full sparse-row map, a separate 800-column base replay
+with symbolic boundary composition, a separate 800-column complete capture
+replay, and the saved endpoint/covariance limitations. It compares all four
+complete receipts with their unchanged historical results. The final line is:
+
+```text
+PASS_LOCAL_EIGHT_FORM_CAPTURE 800 8 11326
+```
+
+The finite scalar map checks plus linearity establish the all-input local
+identity. They do not revalidate the inherited global supplier.
+The two portable scripts replace historical absolute paths with explicit
+input/output arguments and add an optimized-Python guard. Their unchanged
+originals remain in `historical/`. The other two checkers are unchanged.
+Python children run with environment options ignored; no discovery search
+runs. `SOURCE-MANIFEST.json` binds every input. `replayed-receipt.json` and
+`replay.log` record the fresh cleanup replay.
+
+## Sources and overlap
+
+The retimed R560 word is from the local lineage of
+[PR #495](https://github.com/CrocSwap/integer-mult-bounds/pull/495), at
+[its source-pinned proof](https://github.com/CrocSwap/integer-mult-bounds/blob/355d9f7ff293e291676ff4a32eed434419692576/research/e8-combined/PROOF.txt).
+The two exact historical generated inputs are bound by SHA256 here; they
+are not claimed byte-identical to a published generated input. The
+[retained notice](historical/work/combined-pr/publication/research/e8-combined/NOTICE)
+credits the R560 word to Ali Romman with OpenAI Codex assistance and records
+DreamingOfClouds' kernel scripts, chafreaky's paid adapters and distinct-host
+construction, icekylinx's split centres, and the earlier geometry sources.
+The [source ledger](historical/work/combined-pr/publication/research/e8-combined/vendor/complex/SOURCES.json)
+retains their exact pins. Original notices are unchanged.
+The capture and its separate reviews were prepared with substantial OpenAI
+Codex and research-agent assistance. No independent human review is claimed.
+
+The later [native centre capture](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/native-centre-capture/README.md)
+uses 640 inputs, 16 centre records and different native endpoints. This earlier
+800-input mixed capture is a different local identity. No cost or theorem
+from one model is added to the other. The new contribution here is preserving
+the closed exact operation and its limitations, not a new capture principle.
+
+## Open next questions
+
+Can these mixed forms be read by a complete routed controller and then
+removed without a larger complete cost? The first step is a literal
+composition that includes the arbitrary old host values and all phase
+translations. The saved current stage maps differ, so a common-S identity
+does not establish that composition. No such controller is supplied here.

research/local-eight-form-capture/SOURCE-MANIFEST.json

@@ -0,0 +1,107 @@
+{
+  "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703",
+  "files": [
+    {
+      "original": "work/complex-next/structural/check_hosted_capture.py",
+      "package": "historical/work/complex-next/structural/check_hosted_capture.py",
+      "sha256": "04a1f9434d3b1ba9b0744863522cfeab7b139d51f361ec2e887994ac7fdf9c12",
+      "bytes": 4711
+    },
+    {
+      "original": "work/complex-next/structural/hosted-capture-receipt.json",
+      "package": "historical/work/complex-next/structural/hosted-capture-receipt.json",
+      "sha256": "61198fdd7d1b99e2384b50fd5666d48866c98bf61280df4694ac10f13dab0b12",
+      "bytes": 21400
+    },
+    {
+      "original": "work/complex-next/structural/hamming-factor/check_capture_independent.py",
+      "package": "historical/work/complex-next/structural/hamming-factor/check_capture_independent.py",
+      "sha256": "0520113c0318f4eaf0cb56dde5ee88980ff5e10cbd3f20cfd942d580ea8951f1",
+      "bytes": 3403
+    },
+    {
+      "original": "work/complex-next/structural/hamming-factor/capture-independent-receipt.json",
+      "package": "historical/work/complex-next/structural/hamming-factor/capture-independent-receipt.json",
+      "sha256": "e2db977b175614a57c23111fbee0ccd0639f50e1c329da15b5de9384ae1bfce2",
+      "bytes": 528
+    },
+    {
+      "original": "work/complex-next/structural/hamming-factor/HOSTED-CAPTURE-REVIEW.txt",
+      "package": "historical/work/complex-next/structural/hamming-factor/HOSTED-CAPTURE-REVIEW.txt",
+      "sha256": "16df704fa05256cb567bb7c84eb8ebc213cead05b7c3cb6d295d435241a13833",
+      "bytes": 2541
+    },
+    {
+      "original": "work/doubling-architecture/rank-independent/live-capture/check.py",
+      "package": "historical/work/doubling-architecture/rank-independent/live-capture/check.py",
+      "sha256": "558df28c3e0934d8b1d2fdfb591e57fb2cc60ae69e599a341c1bc7f507a685c4",
+      "bytes": 5787
+    },
+    {
+      "original": "work/doubling-architecture/rank-independent/live-capture/RESULT.json",
+      "package": "historical/work/doubling-architecture/rank-independent/live-capture/RESULT.json",
+      "sha256": "8ff1440f0008f8af3344c4598f0d08cf375b1b47eba363a30fa3c697a3a35c9a",
+      "bytes": 21564
+    },
+    {
+      "original": "work/doubling-architecture/rank-independent/live-capture/REVIEW.txt",
+      "package": "historical/work/doubling-architecture/rank-independent/live-capture/REVIEW.txt",
+      "sha256": "e4eaa33d9143d78e0230b2fd4ce4afd0610a4b290a052f6c1ab0793974437f39",
+      "bytes": 5447
+    },
+    {
+      "original": "work/doubling-architecture/rank-independent/live-capture/check_endpoint.py",
+      "package": "historical/work/doubling-architecture/rank-independent/live-capture/check_endpoint.py",
+      "sha256": "70deac8ee0febef6c7d1b55d3a756bb9bb7dace7b4ce6a1728c226c77b62a639",
+      "bytes": 3871
+    },
+    {
+      "original": "work/doubling-architecture/rank-independent/live-capture/ENDPOINT-RESULT.json",
+      "package": "historical/work/doubling-architecture/rank-independent/live-capture/ENDPOINT-RESULT.json",
+      "sha256": "3ff5c5f1f58d1b658d493083ec69e5225f33d0fe4d39be8285ffa937f004bc8e",
+      "bytes": 2185
+    },
+    {
+      "original": "work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz",
+      "package": "historical/work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz",
+      "sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be",
+      "bytes": 83586
+    },
+    {
+      "original": "work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz",
+      "package": "historical/work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz",
+      "sha256": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f",
+      "bytes": 465792
+    },
+    {
+      "original": "work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt",
+      "package": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt",
+      "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2",
+      "bytes": 9402
+    },
+    {
+      "original": "work/next-track/complex/pipeline/full-source/research/split-centres-global/NOTICE.md",
+      "package": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/NOTICE.md",
+      "sha256": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389",
+      "bytes": 2447
+    },
+    {
+      "original": "work/next-track/complex/pipeline/full-source/research/split-centres-global/SOURCES.json",
+      "package": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/SOURCES.json",
+      "sha256": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be",
+      "bytes": 8835
+    },
+    {
+      "original": "work/combined-pr/publication/research/e8-combined/NOTICE",
+      "package": "historical/work/combined-pr/publication/research/e8-combined/NOTICE",
+      "sha256": "7b41fa130dcd11e5972eed84e12f3499d80ea00e17d460f450fa8ddf39cc4951",
+      "bytes": 5054
+    },
+    {
+      "original": "work/combined-pr/publication/research/e8-combined/vendor/complex/SOURCES.json",
+      "package": "historical/work/combined-pr/publication/research/e8-combined/vendor/complex/SOURCES.json",
+      "sha256": "72e38ad6a030b7bb29eac71cda1eafeb96e9202630a9e96f3fbf5cac31742b49",
+      "bytes": 8867
+    }
+  ]
+}

research/local-eight-form-capture/VALIDATION.json

@@ -0,0 +1,18 @@
+{
+  "cwd": "/Users/aliromman/Projects/IntegerMultiplicationBounds",
+  "command": [
+    "python3",
+    "-E",
+    "-B",
+    "work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture/verify.py",
+    "--build",
+    "/tmp/eight-form-capture-cleanup-20261023"
+  ],
+  "exit_code": 0,
+  "fresh_output_required": true,
+  "log": "replay.log",
+  "log_sha256": "d3c39d733abd943d10d5569e72218daed05b350cb7fb3046d3b15e2eca06b554",
+  "receipt": "replayed-receipt.json",
+  "receipt_sha256": "b52c403f5dc4b5d8e5cb40d94dbc3a223a113c441e6c35ff81c832ff12ea92e2",
+  "note": "Literal output is retained. Original source files are unchanged. No new discovery search ran."
+}

research/local-eight-form-capture/dense_columns.py

@@ -0,0 +1,85 @@
+"""Check the omitted-centre map by exact input-column propagation."""
+import argparse
+from fractions import Fraction as F
+import gzip
+import hashlib
+import json
+from pathlib import Path
+
+if not __debug__:
+    raise SystemExit("Run this verifier without -O. Historical sources use assert.")
+parser = argparse.ArgumentParser()
+parser.add_argument("--base", type=Path, required=True)
+args = parser.parse_args()
+BASE = args.base
+PATH = BASE / 'retimed-4/split-centres/CANONICAL-WORD.json.gz'
+raw = PATH.read_bytes()
+w = json.loads(gzip.decompress(raw))
+n = 240 + w['R']
+ops = w['precondition'] + w['compensation'] + w['A'] + w['B'] + w['cleanup']
+steps = [(e[0], e[1], e[2] if e[0] == 'add' else -1,
+          F(e[3], e[4]) if e[0] == 'add' else F(e[2], e[3])) for e in ops]
+S = [[F(0) for _ in range(120)] for _ in range(120)]
+D = [[F(0) for _ in range(n - 240)] for _ in range(120)]
+for column in range(n):
+    v = [F(0)] * n
+    v[column] = F(1)
+    for kind, dst, src, coefficient in steps:
+        if kind == 'add':
+            if v[src]:
+                v[dst] += coefficient * v[src]
+        else:
+            v[dst] *= coefficient
+    assert all(v[i] == int(column == i) for i in range(120))
+    assert all(v[i] == int(column == i) for i in range(240, n))
+    if column < 120:
+        for i in range(120):
+            S[i][column] = v[120 + i]
+    elif column < 240:
+        assert all(v[120 + i] == int(column == 120 + i) for i in range(120))
+    else:
+        for i in range(120):
+            D[i][column - 240] = v[120 + i]
+            if v[120 + i]:
+                assert w['start'][column] == 0
+                assert v[120 + i].denominator.bit_count() == 1
+
+C = [[F(0) for _ in range(120)] for _ in range(8)]
+for column in range(120):
+    v = [F(0)] * n
+    v[column] = F(1)
+    for e in w['precondition'] + w['A']:
+        if e[0] == 'add':
+            v[e[1]] += F(e[3], e[4]) * v[e[2]]
+        else:
+            v[e[1]] *= F(e[2], e[3])
+    for i, register in enumerate(w['centers'][:8]):
+        C[i][column] = v[register]
+assert [[sum(x*y for x, y in zip(a, b)) for b in C] for a in C] == [
+    [56 * int(i == j) for j in range(8)] for i in range(8)]
+code = [i for i, row in enumerate(S) if any(row)]
+assert len(code) == 112
+for i in range(120):
+    for j in range(120):
+        gram = sum(row[i]*row[j] for row in C) / 4
+        assert S[i][j] == (int(i == j) - gram if i in code else 0)
+        if i not in code:
+            assert gram == 0
+helpers = list(range(758, 750, -1))
+assert all(w['start'][r] == 0 and w['final'][r] == 1 for r in helpers)
+assert all(w['start'][120 + j] == 0 and w['final'][j] == 1
+           for row in C for j, coefficient in enumerate(row) if coefficient)
+
+# Compose the four block maps symbolically. P inserts C into eight helper rows.
+# preload: h1=h+P Y; correction: Y1=Y-D h1.
+# base: Y2=Y1+S X+D h1=Y+S X; h2=h1; X2=X.
+# postload: h3=h2+(59/4)P X=h+P(Y+(59/4)X).
+result = dict(status='PASS_INDEPENDENT_EXACT_CAPTURE_MAP',
+              source_sha256=hashlib.sha256(raw).hexdigest(),
+              method='800 exact input columns; symbolic composition of boundary maps',
+              columns=n, scalar_operations=len(steps), code_ports=len(code),
+              dirty_correction_terms=sum(bool(x) for row in D for x in row),
+              C_row_gram=56, captured_forms=8,
+              boundary_frames='preload and dirt correction at zero; postload at full',
+              scope='Local label map only; no routed endpoint decoder or global cost claim.')
+print(json.dumps(result, indent=2))