diff --git a/research/local-eight-form-capture/README.md b/research/local-eight-form-capture/README.md new file mode 100644 index 0000000000..ad13a33aa2 --- /dev/null +++ b/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. diff --git a/research/local-eight-form-capture/SOURCE-MANIFEST.json b/research/local-eight-form-capture/SOURCE-MANIFEST.json new file mode 100644 index 0000000000..4fb4347b74 --- /dev/null +++ b/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 + } + ] +} diff --git a/research/local-eight-form-capture/VALIDATION.json b/research/local-eight-form-capture/VALIDATION.json new file mode 100644 index 0000000000..001f18f61d --- /dev/null +++ b/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." +} diff --git a/research/local-eight-form-capture/dense_columns.py b/research/local-eight-form-capture/dense_columns.py new file mode 100644 index 0000000000..5f1031cc1d --- /dev/null +++ b/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)) diff --git a/research/local-eight-form-capture/historical/work/combined-pr/publication/research/e8-combined/NOTICE b/research/local-eight-form-capture/historical/work/combined-pr/publication/research/e8-combined/NOTICE new file mode 100644 index 0000000000..1b93d4e38f --- /dev/null +++ b/research/local-eight-form-capture/historical/work/combined-pr/publication/research/e8-combined/NOTICE @@ -0,0 +1,89 @@ +Attribution and assistance + +Ali Romman prepared the two changed words, their composition, and this +compact replay package with OpenAI Codex assistance. The fixed witness is +not a claim of a global optimum. Source code is under Apache-2.0; see the +repository LICENSE. The source manifests record original file hashes, +extractions, and path changes. Generated output is not an input premise. + +The bit construction builds on DreamingOfClouds' R715 word and XOR hierarchy +(PR463), rohanarun's response kernel and whole-residual pooling (PR467/462), +DaysSky's idle hosting (PR442), and the E8 producer and geometry lineage of +Dylan Crow, Jacob Sussman, Zhihao Chen, eumemic, and other contributors. +The complex construction retains DreamingOfClouds' PR449 kernel scripts, +chafreaky's PR458 paid adapters and distinct-host construction, icekylinx's +PR433 split centres, and the prior supplier and geometry work. +The comparison is with pinned main, not every open PR. + +Pinned source records + + Main: 12a4934d15006e8c10f9b2264f13f8f341be802b. + PR467 cached head: f92d6a7ffcf74553522e967c2600e30c05ffe938. + PR462 cached tree: c4df4fdbf411f047ff7d63c73c432e828e94d924. + PR449: 7fac5292693bf738ff5eed6ec754f8ec22ebcf8e. + PR451: f3a38153678b55063fc005901cc968266166507d. + PR442: 4e16d001d505d4f21dd2bcfc44591f9be4c279bd. + +The vendor/bit/SOURCES.json and vendor/complex/SOURCES.json files identify +all imported files and their changes. Paths in those manifests name the +cached source packages. The two final words and compact schedule are +included, so replay does not require those caches or pending PR branches. + +Retained upstream notices + +The notices below are copied without changes from the source packages. +Their paths and descriptions refer to those packages. + + +Source: research/e8-complex-adapted-kernel/NOTICE.md + +# Attribution and assistance + +The shared-donor complex kernel selection and three generalized local +checker/emitter/phase scripts come from DreamingOfClouds PR449 at +`7fac5292693bf738ff5eed6ec754f8ec22ebcf8e`, prepared with Claude Opus 5.5 +through Claude Code. The original PROOF and NOTICE are retained verbatim +under `upstream449`. That draft's entrance-gauge construction and numerical +claims are not adopted here. + +Exact frozen reconstruction, the paid two-sided residual construction, +distinct-host assignment, independent local/global audits, new cost invoice +and this release were prepared by chafreaky with OpenAI Codex assistance. +They build on PR454 target mixing, PR451's eleven-stage complex geometry, +PR443–445 kernels and row bounds, DaysSky's PR442 idle-data hosting, +icekylinx's PR433 split centres, Zhihao Chen's PR425 common-frame realization +and PR377/386 geometry, and the inherited E8 work by Jacob Sussman, Dylan +Crow, eumemic and other contributors. All parent notices and licenses remain +in their source-pinned packages. + +Apache License 2.0; see LICENSE. This is a conditional research artifact. + + +Source: research/e8-complex-adapted-kernel/upstream449/NOTICE.md + +Apache-2.0. `code/audit_cxg.py`, `emit_cxg.py`, `phases_cxg.py` are modified copies of PR #433's `complex_audit.py`, +`complex_emit.py`, `complex_phases_full.py` (icekylinx with Codex; adapted from PR #425 by jacklightChen / Zhihao Chen). +`code/hostmodel.py` replicates the profile arithmetic of PR #442's `complex_hosted.py` (DaysSky) for mixed widths. +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. + + +Source: work/next-track/bit/pinned467/research/r715-kernel-pool/NOTICE.md + +R715 producer and carrier/XOR construction: DreamingOfClouds, with Claude Opus 5.5, PR463. Shared-donor kernel mechanism and exact engines: chafreaky and the PR417/443 lineage. Whole hosting: DaysSky PR442. Target mixing: DreamingOfClouds PR450/463; no cross-family split used. New selection, 74 retiming moves and four-replica pooling: Rohan Arun with OpenAI Codex. Complex supplier: chafreaky PR458, unchanged and cited only at this stage. The inherited repository package notices and Apache-2.0 licenses remain applicable. See the retained PR463 README and source pins. + + +Source: work/next-track/bit/pinned462/research/bit-whole-pool4/NOTICE.md + +Apache-2.0. Original upstream notices and licenses are retained. +Four-replica selection, changed owner mapping, physical-family prefix audit, +finite repricing and composition by Rohan Arun with OpenAI Codex assistance. + +Unchanged bit word: Rohan Arun with Claude Opus5.5, PR459, including DreamingOfClouds' +target-prefix mixing from PR450. Unchanged complex supplier: chafreaky with +OpenAI Codex, PR458, building on DreamingOfClouds' PR449 kernel. +Parent composition: Rohan Arun with OpenAI Codex, PR460. +Hosting and solver lineage: DaysSky PR442; chafreaky PR443/445/451/454; +DreamingOfClouds' whole-hosting solver; Rohan Arun PR456 whole-replica pooling. +Retained geometry and local tools: icekylinx, eumemic, Zhihao Chen, Dylan Crow, +Jacob Sussman, Henry Grant and all authors in the upstream source-pinned notices. +No independent discovery of either unchanged local supplier is claimed. diff --git a/research/local-eight-form-capture/historical/work/combined-pr/publication/research/e8-combined/vendor/complex/SOURCES.json b/research/local-eight-form-capture/historical/work/combined-pr/publication/research/e8-combined/vendor/complex/SOURCES.json new file mode 100644 index 0000000000..62327bab00 --- /dev/null +++ b/research/local-eight-form-capture/historical/work/combined-pr/publication/research/e8-combined/vendor/complex/SOURCES.json @@ -0,0 +1,181 @@ +[ + { + "path": "vendor/complex/scalar.py", + "source": "work/next-track/complex/pipeline/full-source/research/e8-complex-adapted-kernel/upstream449/audit_cxg.py", + "source_sha256": "12e8fe32136a0f32e5363f97113cf0c32efda6a331dc391758cd58ed8f5f9d1b", + "sha256": "1544d074e38cad5529ffc12c1825b9f3979c8fbdcd277803eff1e51dc23d77fb", + "edits": [ + { + "old": "old=json.load(gzip.open('work/higher-stage-e8/verified/gcert1-e8-retimed.json.gz'))", + "new": "old=json.loads((Path(__file__).resolve().parents[2]/'data/complex/ports.json').read_text())" + }, + { + "old": "b=Q(0);grid=Q(1,10**18)\n", + "new": "" + }, + { + "old": "'status':'PASS_EXACT_SCALAR_AND_FRAME_RESEARCH_CANDIDATE_NOT_YET_ADMITTED'", + "new": "'status':'PASS_EXACT_SCALAR_AND_FRAME_AUDIT'" + }, + { + "old": " 'two_rational_moment_engines':True,'next_b_grid_rejected':True,\n", + "new": "" + }, + { + "old": " 'remaining':['new general scalar-interface proof integration','exact phase and emitted local/global program','finite invoice and outer assembly'],", + "new": " 'remaining':['exact phase and emitted local/global program','finite invoice and outer assembly']," + }, + { + "old": " 'scope':'Substantial new scalar-network candidate. All parameter values remain prospective until the expanded scalar interface and complete phase-aware supplier are admitted.',", + "new": " 'scope':'Exact arbitrary-input scalar maps and nested frames. Separate scripts check phases, physical programs and invoices.'," + } + ] + }, + { + "path": "vendor/complex/programs.py", + "source": "work/next-track/complex/pipeline/full-source/research/e8-complex-adapted-kernel/upstream449/emit_cxg.py", + "source_sha256": "26c646d5a777c1306224abb08d4031b3b1ffcbed8a212a0e58579de13b0ee658", + "sha256": "521950ee178cdf60bbf7984ffb47da6dfa14aa74d18312bf98cdf2c331901ebb", + "edits": [ + { + "old": "\"\"\"Emit both local programs, integrate the fixed nine-stage geometry, and bill.\n\nThe expanded scalar interface is justified in PROOF.txt. This script does not\nclaim a Lean proof or discharge the inherited all-size/analytic interfaces.\n\"\"\"", + "new": "\"\"\"Emit both local programs and check their exact scalar action.\n\nThe package proof states the scalar interface and inherited assumptions.\nThis script does not discharge the all-size or analytic interfaces.\n\"\"\"" + } + ] + }, + { + "path": "vendor/complex/phases.py", + "source": "work/next-track/complex/pipeline/full-source/research/e8-complex-adapted-kernel/upstream449/phases_cxg.py", + "source_sha256": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "sha256": "e2126f9be35b8f61b5f4374d8ac521a153e90a58bd59f69e7dfd80f8195d4c10", + "edits": [ + { + "old": "sys.path.insert(0,str(Path('work/odd-stages').resolve()))\n", + "new": "" + }, + { + "old": "import gzip,hashlib,json,sys,time", + "new": "import gzip,hashlib,json,time", + "reason": "Remove an import made unused by the source extraction." + } + ] + }, + { + "path": "vendor/complex/adapters.py", + "source": "work/next-track/complex/pipeline/full-source/research/e8-complex-adapted-kernel/code/adapters.py", + "source_sha256": "001b80a9366e29f28f3785e146062e12b1913e5da79b5e6d6b7090c6425d7015", + "sha256": "81b551b711e14239fb8ed2675824313d84671365d921c5d53fbde5fd8246ef21", + "edits": [ + { + "old": "sys.path.insert(0,str(ROOT.parent/'split-centres-global/vendor'))\n", + "new": "" + } + ] + }, + { + "path": "vendor/complex/local_audit.py", + "source": "work/next-track/complex/pipeline/full-source/research/e8-complex-adapted-kernel/code/local_audit.py", + "source_sha256": "ae5baeaaeea26cf0a1faa59fbc18a8ad4805f5a8f2eba9644abf44f82c74845d", + "sha256": "1dee2bf0608940786143fdfa8651e56c98028a5e3a41396ca84dd49973916b03", + "edits": [ + { + "old": "sys.path.insert(0,str(ROOT.parent/'split-centres-global/vendor'))\n", + "new": "" + } + ] + }, + { + "path": "vendor/complex/emit.py", + "source": "work/next-track/complex/pipeline/full-source/research/e8-complex-adapted-kernel/code/emit.py", + "source_sha256": "b5170f68223c910ae806255ee1975b33801df3a729da0d6c2ba50ae96ec0c911", + "sha256": "a5926f58f3cbcdfb5a902f844d86cdb3b63df52c2493709a7fc9d8354ad0029c", + "edits": [ + { + "old": "ROOT=Path(__file__).resolve().parents[1];M,H,K,L,T,V,R=89,9,5,11,8,120,560;W=9600", + "new": "ROOT=Path(__file__).resolve().parents[2];M,H,K,L,T,V,R=89,9,5,11,8,120,560;W=9600" + }, + { + "old": "selected=ld(ROOT/'data/hosting.json')['selected']", + "new": "selected=ld(ROOT/'data/complex/hosting.json')['selected']" + } + ] + }, + { + "path": "vendor/complex/audit.py", + "source": "work/next-track/complex/pipeline/full-source/research/e8-complex-adapted-kernel/code/audit.py", + "source_sha256": "2dd35e3d583ae27004d1ff53fd0f96e0f2f10dae3b5376dc8bb6aebeafe9f349", + "sha256": "99fa203c64f6d0e3482b1c50c6d394deff10fccee0f460d419ebeb0ccc8e7137", + "edits": [ + { + "old": "sp=importlib.util.spec_from_file_location('unchanged_phase_audit',ROOT.parent/'r740-hosted-rank149/code/complex_audit.py');PA=importlib.util.module_from_spec(sp);sp.loader.exec_module(PA)", + "new": "import phase_audit as PA" + }, + { + "old": "import copy,gzip,hashlib,importlib.util,json,sys", + "new": "import copy,gzip,hashlib,json,sys", + "reason": "Remove an import made unused by the source extraction." + } + ] + }, + { + "path": "vendor/complex/clifford_exact.py", + "source": "work/next-track/complex/pipeline/full-source/research/split-centres-global/vendor/clifford_exact.py", + "source_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "edits": [] + }, + { + "path": "vendor/complex/data_phases.py", + "source": "work/next-track/complex/pipeline/full-source/research/r740-hosted-rank149/code/complex_phases.py", + "source_sha256": "4339fde687c041c381d01bc81e90a2abec0092c51920eb02166aaf628a7f25a2", + "sha256": "498190815600ab5d945ac10d1d573fab4eb74f12c77d11e91b11afb15893f1fe", + "edits": [ + { + "old": "sys.path.insert(0,str(Path(__file__).resolve().parents[2]/'split-centres-global/vendor'))\n", + "new": "" + } + ] + }, + { + "path": "vendor/complex/phase_audit.py", + "source": "work/next-track/complex/pipeline/full-source/research/r740-hosted-rank149/code/complex_audit.py", + "source_sha256": "403f95ed28025e552f33d54a5e61da24714bcb757f12a75f66012999c7f37896", + "sha256": "15cda1d7ce09599952d7e91201d1c6732a0c21232155339d9236456db7c91ea3", + "extraction": "polynomial, phases, bridge_controls; validate prefix through hosting windows, with its fixed inherited cover correction formula and no old program comparison", + "edits": [ + { + "old": "from collections import defaultdict\n", + "new": "", + "reason": "Remove an import made unused by the source extraction." + } + ] + }, + { + "path": "data/complex/FULL-WORD.json.gz", + "source": "work/next-track/complex/pipeline/retimed-4/split-centres/FULL-WORD.json.gz", + "source_sha256": "66655cd858afb515dfd4cad43c4fef01f9185af670e144750e9977588ebd4ecf", + "sha256": "66655cd858afb515dfd4cad43c4fef01f9185af670e144750e9977588ebd4ecf", + "edits": [] + }, + { + "path": "data/complex/hosting.json", + "source": "work/next-track/complex/pipeline/full-source/research/e8-complex-adapted-kernel/data/hosting.json", + "source_sha256": "dc5fe719e71c26e856f0da96518af635ed2026b1c323052d97ee4e6b9839f2f1", + "sha256": "dc5fe719e71c26e856f0da96518af635ed2026b1c323052d97ee4e6b9839f2f1", + "edits": [] + }, + { + "path": "data/complex/ports.json", + "source": "work/e8-project/lean-verification/final-reproduction/tools/certificate/gcert1-e8-retimed.json.gz", + "source_sha256": "31467ace2b1667630b72e488e688911a0404b4755d0d2c87560b111ed4c07998", + "sha256": "c4a4288b6052341eddff69e93999525b74512bb2fcdddb00bcdfe80ee42526ce", + "extraction": "only ports are read by the scalar canonicalization" + }, + { + "path": "data/complex/schedule.json", + "source": "work/next-track/complex/pipeline/fresh-parent-complex/GLOBAL-TEMPLATE.json.gz", + "source_sha256": "a2e46da30e6391109bf4eb3314388dfd39d3e8541e1ebf09b27802e9b4df50b4", + "sha256": "f62975a9146a4a0c9d1ecaa6f8567aeedf30bce484cc2105a74e4d7e9afc2522", + "extraction": "fixed geometry and schedule specification only; programs, calls, idle remainders, redundant old phases and old receipts omitted; phase hash regenerated" + } +] diff --git a/research/local-eight-form-capture/historical/work/complex-next/structural/check_hosted_capture.py b/research/local-eight-form-capture/historical/work/complex-next/structural/check_hosted_capture.py new file mode 100644 index 0000000000..4ad5f739af --- /dev/null +++ b/research/local-eight-form-capture/historical/work/complex-next/structural/check_hosted_capture.py @@ -0,0 +1,108 @@ +"""Check a local dirty capture and list its current physical owners.""" +from fractions import Fraction as Q +import gzip +import hashlib +import json +from pathlib import Path +BASE = Path('/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/next-track/complex/pipeline') +WP = BASE/'retimed-4/split-centres/CANONICAL-WORD.json.gz' +TP = BASE/'retimed-4/complex/GLOBAL-TEMPLATE.json.gz' +w = json.loads(gzip.decompress(WP.read_bytes())) +t = json.loads(gzip.decompress(TP.read_bytes())) +n = 240 + w['R'] + +def add(rows, dst, src, q): + for j, x in list(rows[src].items()): + z = rows[dst].get(j, Q(0)) + q*x + if z: + rows[dst][j] = z + else: + rows[dst].pop(j, None) + + +def run(rows, operations): + for e in operations: + if e[0] == 'add': + add(rows, e[1], e[2], Q(e[3], e[4])) + else: + rows[e[1]] = {j: x*Q(e[2], e[3]) for j, x in rows[e[1]].items()} + + +def identity(): + return [{i: Q(1)} for i in range(n)] + + +ops = w['precondition'] + w['compensation'] + w['A'] + w['B'] + w['cleanup'] +rows = identity() +run(rows, ops) +assert all(rows[i] == {i: 1} for i in list(range(120)) + list(range(240, n))) +assert all({j: x for j, x in rows[i].items() if 120 <= j < 240} == {i: 1} + for i in range(120, 240)) +S = [{j: x for j, x in rows[120+i].items() if j < 120} for i in range(120)] +D = [{j: x for j, x in rows[120+i].items() if j >= 240} for i in range(120)] +assert all(w['start'][j] == 0 for row in D for j in row) +assert all(x.denominator & (x.denominator-1) == 0 for row in D for x in row.values()) + +# Each selected centre row is a dyadic form of the input X bank. +clean = [{i: Q(1)} if i < 240 else {} for i in range(n)] +run(clean, w['precondition'] + w['A']) +C = [clean[r] for r in w['centers'][:8]] +assert all(row and all(j < 120 for j in row) for row in C) +assert [[sum(C[i].get(j, 0)*C[k].get(j, 0) for j in range(120)) + for k in range(8)] for i in range(8)] == [[56*int(i == k) for k in range(8)] for i in range(8)] +code = [i for i, row in enumerate(S) if row] +for i in code: + for j in range(120): + gram = sum(row.get(i, 0)*row.get(j, 0) for row in C)/4 + assert Q(int(i == j)) - S[i].get(j, 0) == gram +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 in row) + +# Correct the omitted-centre word on all helper dirt, then retain eight forms. +state = identity() +for r, form in zip(helpers, C): + for j, q in form.items(): + add(state, r, 120+j, q) +for i, row in enumerate(D): + for j, q in row.items(): + add(state, 120+i, j, -q) +run(state, ops) +for r, form in zip(helpers, C): + for j, q in form.items(): + add(state, r, j, Q(59, 4)*q) +expected = identity() +for i, row in enumerate(S): + for j, q in row.items(): + add(expected, 120+i, j, q) +for r, form in zip(helpers, C): + for j, q in form.items(): + expected[r][j] = Q(59, 4)*q + expected[r][120+j] = q +assert state == expected + +owners = [] +for r in helpers: + family, route = t['calls'][0]['owners'][r] + assert 600 <= family <= 607 and route[:6] == [4, 2, 0, 9, 0, [1,2,3,4,5,6,7,8,9]] + roles = [] + for call in t['calls']: + if call['replica']: + continue + same = [(i, rr) for i, (f, rr) in enumerate(call['owners']) if f == family] + assert len(same) <= 1 + roles += [dict(stage=call['stage'], register=i, route=rr) for i, rr in same] + assert [z['stage'] for z in roles if z['stage'] <= 3] == [0, 2, 3] + assert [z['route'][2] for z in roles if z['stage'] <= 3] == [0, 9, 18] + owners.append(dict(family=family, capture_register=r, roles=roles)) +result = dict(status='PASS_LOCAL_DIRTY_CAPTURE_AND_CURRENT_OWNER_INVENTORY', + word_sha256=hashlib.sha256(WP.read_bytes()).hexdigest(), + template_sha256=hashlib.sha256(TP.read_bytes()).hexdigest(), + all_columns=n, retained_forms=8, centre_gram_multiplier=56, decoder_factor='C^t C / 4', + dirty_correction_terms=sum(map(len,D)), + local_source_and_target_map='X unchanged; Y += S X', + local_helper_map='Selected h_i += C_i(59 X/4 + Y); all other helpers unchanged', + owners=owners, + scope='The local scalar map and current owner inventory are exact. The paid monomial adapters, endpoint decoder, scalar controller, owner restoration, and global cost are not verified.') +Path(__file__).with_name('hosted-capture-receipt.json').write_text(json.dumps(result, indent=2)+'\n') +print(json.dumps({k:v for k,v in result.items() if k != 'owners'}, indent=2)) diff --git a/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/HOSTED-CAPTURE-REVIEW.txt b/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/HOSTED-CAPTURE-REVIEW.txt new file mode 100644 index 0000000000..b6b951e5bf --- /dev/null +++ b/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/HOSTED-CAPTURE-REVIEW.txt @@ -0,0 +1,43 @@ +Independent review of check_hosted_capture.py + +Result: the stated forward local scalar map is correct. No algebra or operation +order error was found. An independent exact replay propagated each of the 800 +input columns through all 19,449 scalar operations. It did not import or run +the parent checker. The receipt is capture-independent-receipt.json. + +The omitted-centre word has the exact map + X' = X, Y' = Y + S X + D h, h' = h. +All 11,326 nonzero entries of D are dyadic and use helpers whose initial frame +is zero. The eight centre rows C satisfy C C^t = 56 I. On the 112 code ports, +S = I - C^t C/4. The other eight ports have zero S row and zero C column. +Thus the displayed formula for S must retain its code-port scope. + +Let P insert the eight C rows into helpers 758 through 751. The preload gives +h1 = h + P Y. The next correction must use these updated helpers: +Y1 = Y - D h1. The omitted-centre word then gives + Y2 = Y1 + S X + D h1 = Y + S X, h2 = h1, X2 = X. +The postload gives h3 = h + P(Y + 59 X/4). This is the requested capture. +If the correction used the old h instead of h1, an extra D P Y term would +remain. The checker uses h1, so it does not have this error. + +The boundary operations obey the forward local frame contract. The preload +uses Y and selected helpers at frame zero. The dirt correction also uses only +frame-zero registers. The postload uses X and selected helpers at the full +frame, after the existing full-frame cleanup. This statement does not transfer +the same boundary operations to the backward program. + +I separately checked the current physical owner inventory. At stage zero, +helpers 758 through 751 map to families 600 through 607. These are pair-two Y +hosts. Each uses idle window 2, offset zero, width nine, and entry frame zero. +The same families have one owner per call. Before their level-three endpoint, +they occur at stages 0, 2, 3 with disjoint offsets 0, 9, 18. The window has +rank 32, so those three whole residuals use 27 axes and leave five axes. + +Limits +The stored signal remains added to each host's arbitrary input value. The +selected helpers are not restored by this construction. The other helpers +are restored in the local label map. A later ordinary dirty-safe call can +accept the changed value as dirt, but that fact does not prove the proposed +changed global controller. The paid monomial and phase realization, the +endpoint decoder equation, restoration of the eight selected physical hosts, +and the global invoice still require proof. The checker states these limits. diff --git a/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/capture-independent-receipt.json b/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/capture-independent-receipt.json new file mode 100644 index 0000000000..6c605d458e --- /dev/null +++ b/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/capture-independent-receipt.json @@ -0,0 +1,13 @@ +{ + "status": "PASS_INDEPENDENT_EXACT_CAPTURE_MAP", + "source_sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "method": "800 exact input columns; symbolic composition of boundary maps", + "columns": 800, + "scalar_operations": 19449, + "code_ports": 112, + "dirty_correction_terms": 11326, + "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." +} diff --git a/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/check_capture_independent.py b/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/check_capture_independent.py new file mode 100644 index 0000000000..cf451a93b8 --- /dev/null +++ b/research/local-eight-form-capture/historical/work/complex-next/structural/hamming-factor/check_capture_independent.py @@ -0,0 +1,79 @@ +"""Check the omitted-centre map by exact input-column propagation.""" +from fractions import Fraction as F +import gzip +import hashlib +import json +from pathlib import Path + +BASE = Path('/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/next-track/complex/pipeline') +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)) diff --git a/research/local-eight-form-capture/historical/work/complex-next/structural/hosted-capture-receipt.json b/research/local-eight-form-capture/historical/work/complex-next/structural/hosted-capture-receipt.json new file mode 100644 index 0000000000..97df002d17 --- /dev/null +++ b/research/local-eight-form-capture/historical/work/complex-next/structural/hosted-capture-receipt.json @@ -0,0 +1,1263 @@ +{ + "status": "PASS_LOCAL_DIRTY_CAPTURE_AND_CURRENT_OWNER_INVENTORY", + "word_sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "template_sha256": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f", + "all_columns": 800, + "retained_forms": 8, + "centre_gram_multiplier": 56, + "decoder_factor": "C^t C / 4", + "dirty_correction_terms": 11326, + "local_source_and_target_map": "X unchanged; Y += S X", + "local_helper_map": "Selected h_i += C_i(59 X/4 + Y); all other helpers unchanged", + "owners": [ + { + "family": 600, + "capture_register": 758, + "roles": [ + { + "stage": 0, + "register": 758, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 643, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 758, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 120, + "route": [ + 1, + 5, + 0 + ] + }, + { + "stage": 6, + "register": 120, + "route": [ + 1, + 6, + 0 + ] + }, + { + "stage": 7, + "register": 359, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 359, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 359, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 601, + "capture_register": 757, + "roles": [ + { + "stage": 0, + "register": 757, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 642, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 757, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 121, + "route": [ + 1, + 5, + 1 + ] + }, + { + "stage": 6, + "register": 121, + "route": [ + 1, + 6, + 1 + ] + }, + { + "stage": 7, + "register": 358, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 358, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 358, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 602, + "capture_register": 756, + "roles": [ + { + "stage": 0, + "register": 756, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 641, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 756, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 122, + "route": [ + 1, + 5, + 2 + ] + }, + { + "stage": 6, + "register": 122, + "route": [ + 1, + 6, + 2 + ] + }, + { + "stage": 7, + "register": 357, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 357, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 357, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 603, + "capture_register": 755, + "roles": [ + { + "stage": 0, + "register": 755, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 640, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 755, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 123, + "route": [ + 1, + 5, + 3 + ] + }, + { + "stage": 6, + "register": 123, + "route": [ + 1, + 6, + 3 + ] + }, + { + "stage": 7, + "register": 356, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 356, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 356, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 604, + "capture_register": 754, + "roles": [ + { + "stage": 0, + "register": 754, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 639, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 754, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 124, + "route": [ + 1, + 5, + 4 + ] + }, + { + "stage": 6, + "register": 124, + "route": [ + 1, + 6, + 4 + ] + }, + { + "stage": 7, + "register": 355, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 355, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 355, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 605, + "capture_register": 753, + "roles": [ + { + "stage": 0, + "register": 753, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 638, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 753, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 125, + "route": [ + 1, + 5, + 5 + ] + }, + { + "stage": 6, + "register": 125, + "route": [ + 1, + 6, + 5 + ] + }, + { + "stage": 7, + "register": 354, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 354, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 354, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 606, + "capture_register": 752, + "roles": [ + { + "stage": 0, + "register": 752, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 637, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 752, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 126, + "route": [ + 1, + 5, + 6 + ] + }, + { + "stage": 6, + "register": 126, + "route": [ + 1, + 6, + 6 + ] + }, + { + "stage": 7, + "register": 353, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 353, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 353, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 607, + "capture_register": 751, + "roles": [ + { + "stage": 0, + "register": 751, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 636, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 751, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 127, + "route": [ + 1, + 5, + 7 + ] + }, + { + "stage": 6, + "register": 127, + "route": [ + 1, + 6, + 7 + ] + }, + { + "stage": 7, + "register": 352, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 352, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 352, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + } + ], + "scope": "The local scalar map and current owner inventory are exact. The paid monomial adapters, endpoint decoder, scalar controller, owner restoration, and global cost are not verified." +} diff --git a/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/ENDPOINT-RESULT.json b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/ENDPOINT-RESULT.json new file mode 100644 index 0000000000..dd44f28a4e --- /dev/null +++ b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/ENDPOINT-RESULT.json @@ -0,0 +1,78 @@ +{ + "status": "PASS_ENDPOINT_COVARIANCE_AND_TENSOR_COUNTEREXAMPLE", + "chart_identity": "D_I P_sigma = T_translation P_sigma D_I", + "charts": [ + { + "family": 600, + "helper": 758, + "q": 7, + "translation": 15, + "strict_commutation": false + }, + { + "family": 601, + "helper": 757, + "q": 11, + "translation": 15, + "strict_commutation": false + }, + { + "family": 602, + "helper": 756, + "q": 19, + "translation": 23, + "strict_commutation": false + }, + { + "family": 603, + "helper": 755, + "q": 35, + "translation": 39, + "strict_commutation": false + }, + { + "family": 604, + "helper": 754, + "q": 67, + "translation": 71, + "strict_commutation": false + }, + { + "family": 605, + "helper": 753, + "q": 131, + "translation": 135, + "strict_commutation": false + }, + { + "family": 606, + "helper": 752, + "q": 259, + "translation": 263, + "strict_commutation": false + }, + { + "family": 607, + "helper": 751, + "q": 13, + "translation": 15, + "strict_commutation": false + } + ], + "source_X_factor_required": "D_p^-1", + "reason": "The initial C_q is a frame interpretation, not an extra paid initial transform.", + "false_tensor_shortcut_witness": { + "Fourier_character": [ + 1, + 1 + ], + "exact_D_inverse_tensor_2": "-1", + "proposed_aI_plus_b_translation_tensor_2": "1" + }, + "source_sha256": { + "work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f", + "work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + }, + "scope": "Seed phase identities and a counterexample to a proposed constant-size all-size shortcut. No endpoint cost or modified global controller is certified." +} diff --git a/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/RESULT.json b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/RESULT.json new file mode 100644 index 0000000000..c7e703de58 --- /dev/null +++ b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/RESULT.json @@ -0,0 +1,1273 @@ +{ + "status": "PASS_INDEPENDENT_800_COLUMN_DIRTY_CAPTURE", + "base_columns": 800, + "complete_capture_columns": 800, + "base_scalar_operations": 19449, + "code_ports": 112, + "center_gram": 56, + "dirt_correction_coefficients": 11326, + "retained_forms": 8, + "source_sha256": { + "work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f" + }, + "owners": [ + { + "helper": 758, + "family": 600, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 758, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 643, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 758, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 120, + "route": [ + 1, + 5, + 0 + ] + }, + { + "stage": 6, + "register": 120, + "route": [ + 1, + 6, + 0 + ] + }, + { + "stage": 7, + "register": 359, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 359, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 359, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 757, + "family": 601, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 757, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 642, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 757, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 121, + "route": [ + 1, + 5, + 1 + ] + }, + { + "stage": 6, + "register": 121, + "route": [ + 1, + 6, + 1 + ] + }, + { + "stage": 7, + "register": 358, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 358, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 358, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 756, + "family": 602, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 756, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 641, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 756, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 122, + "route": [ + 1, + 5, + 2 + ] + }, + { + "stage": 6, + "register": 122, + "route": [ + 1, + 6, + 2 + ] + }, + { + "stage": 7, + "register": 357, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 357, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 357, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 755, + "family": 603, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 755, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 640, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 755, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 123, + "route": [ + 1, + 5, + 3 + ] + }, + { + "stage": 6, + "register": 123, + "route": [ + 1, + 6, + 3 + ] + }, + { + "stage": 7, + "register": 356, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 356, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 356, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 754, + "family": 604, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 754, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 639, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 754, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 124, + "route": [ + 1, + 5, + 4 + ] + }, + { + "stage": 6, + "register": 124, + "route": [ + 1, + 6, + 4 + ] + }, + { + "stage": 7, + "register": 355, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 355, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 355, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 753, + "family": 605, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 753, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 638, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 753, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 125, + "route": [ + 1, + 5, + 5 + ] + }, + { + "stage": 6, + "register": 125, + "route": [ + 1, + 6, + 5 + ] + }, + { + "stage": 7, + "register": 354, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 354, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 354, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 752, + "family": 606, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 752, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 637, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 752, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 126, + "route": [ + 1, + 5, + 6 + ] + }, + { + "stage": 6, + "register": 126, + "route": [ + 1, + 6, + 6 + ] + }, + { + "stage": 7, + "register": 353, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 353, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 353, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 751, + "family": 607, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 751, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 636, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 751, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 127, + "route": [ + 1, + 5, + 7 + ] + }, + { + "stage": 6, + "register": 127, + "route": [ + 1, + 6, + 7 + ] + }, + { + "stage": 7, + "register": 352, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 352, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 352, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + } + ], + "scope": "Exact local label map and initial owner-frame inventory only. No modified global controller, endpoint uncompute, finite invoice, or new exponent is certified." +} diff --git a/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/REVIEW.txt b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/REVIEW.txt new file mode 100644 index 0000000000..b9dab30be4 --- /dev/null +++ b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/REVIEW.txt @@ -0,0 +1,108 @@ +INDEPENDENT REVIEW OF THE HOSTED MIXED CAPTURE + +Verified local statement + +A separate exact input-column replay checked all 800 columns of the base map +and all 800 columns after the new boundary operations. It confirms + X_out = X, + Y_out = Y + S X, + h_i,out = h_i + C_i(59 X/4 + Y), i=0,...,7, +with every other helper unchanged. The capture helper indices are 758,...,751. +The eight rows satisfy C C^t=56 I. On the 112 code ports, + S = I-C^t C/4. +The other eight data ports are unchanged by this omitted-center side map. +The exact dirt correction has 11326 nonzero coefficients. + +The preload reads Y and writes the selected helpers at local frame zero. +The dirt correction also uses only frame-zero helpers. The source postload +reads X and writes the selected helpers at the full local frame. These frame +facts are checked in the frozen word. They are local boundary contracts; +they do not replace the routed all-size implementation or its cost proof. + +Owner check + +The selected helpers occupy physical families 600 through 607 at stage zero. +They are pair-two Y data families. Their initial host frame is I. Their +rank-nine residual adapters are identity. Each first route is + [4,2,0,9,0,[1,2,3,4,5,6,7,8,9]]. +The saved receipt lists every later use. Before or at stage three, they are +used at stages 0,2,3 with offsets 0,9,18. A future data role is not an unused +private workspace. The modified global controller must account for its +retained signal and its arbitrary original value throughout those uses. + +The normalized channel does not strictly commute with the full target + +Use P_sigma f(x)=f(sigma^t x), with D_I Fourier multiplier i^weight. Every +selected sigma is orthogonal. Define + delta_j = (weight(column_j(sigma))-1)/2 modulo 2, + t = sigma delta. +Then the exact relation is + D_I P_sigma = T_t P_sigma D_I. +For families 600,...,607 the translations t are + 15, 15, 23, 39, 71, 135, 263, 15. +All are nonzero. Linear and pair phase coefficients were checked separately. +Thus orthogonality gives covariance with a translation, not commutation. +The scalar port matrix C commutes with a common address operator on each +input port. Therefore the same covariance holds for P_sigma C. Its image is +not restricted to translation-fixed vectors: one nonzero coefficient permits +an arbitrary payload. Strict commutation does not follow after that factor. + +Source X requires its entry-frame inverse + +The inherited source file + work/next-track/complex/pipeline/full-source/research/split-centres-global/ + proofs/INHERITED-COMPLEX-GEOMETRY.txt +defines initial X_(-1)=C_q and Y_(-1)=I. It later states that a source which +began at C_q has exchange factor C_all C_q^(-2)=C_all X_q. A terminal +translation removes that factor. The current retimed schedule begins with +local stage zero. It has no separate paid initial data-front transform. + +Consequently X in the scalar capture identity is an interpreted local label. +If u is the physical source input, then X=D_p^-1 u in the stage-zero chart. +The actual retained source channel includes D_p^-1. With physical target +input v on the initially unframed Y side, the channel is of the form + K_i(u,v) = P_sigma_i sum_j C_ij[(59/4) D_pj^-1 u_j + v_j]. +The data route rho(q,0) is identity. Later stages would need their exact +routes and phase adapters included separately. + +Each D_pj commutes with D_I because both are Fourier multipliers. Thus the +entry inverse does not spoil the displayed covariance. It does remain in +the endpoint decoder, and its all-size cost cannot be omitted. + +The seed two-tap identity does not prove a constant-cost all-size decoder + +At the binary seed, + D_p^-1 = a I + b T_p, + a=(1-i)/2, b=(1+i)/2. +This equality is exact. But it cannot be tensor-lifted by keeping two taps. +On Fourier character (1,1), (D_p^-1) tensor (D_p^-1) has eigenvalue -1, +whereas a I+b(T_p tensor T_p) has eigenvalue 1. This is an exact two-bit +counterexample. The existing compiler treats the selected-coordinate +transform as a paid child. A different all-size implementation would need +its own proof and invoice. The orthogonal covariance identity is +multiplicative and does not have this sum-versus-tensor defect. + +Exact hypotheses for endpoint uncompute + +Suppose physical inputs are z and an arbitrary host h. A verified capture +adds Kz to the host. Suppose the complete later circuit has been proved to +leave source outputs Fz and host output Fh+FKz, with all other affected +outputs already correct. Then the required endpoint decoder is exactly + K_end = F K F^-1. +Subtracting K_end(Fz) restores Fh. For F=D_I and the stated chart, covariance +turns this into the translated decoder T_t K. This is an operator identity, +not a price. It still requires the correct source entry inverses inside K. + +Applying this lemma to the new construction requires a proof of the actual +later routed controller, all cover classes, the physical host response, +coexisting captures, arbitrary correlated dirt, and a legal all-size decoder +with its finite and recursive costs. Those claims are not supplied by the +800-column local replay. No new supplier exponent is certified here. + +Reproduce + + python3 work/doubling-architecture/rank-independent/live-capture/check.py + python3 work/doubling-architecture/rank-independent/live-capture/check_endpoint.py + +Both checkers use the standard library and read the frozen prior artifacts. +RESULT.json and ENDPOINT-RESULT.json contain their exact scope and hashes. diff --git a/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/check.py b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/check.py new file mode 100644 index 0000000000..b5b231e08a --- /dev/null +++ b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/check.py @@ -0,0 +1,133 @@ +"""Replay the hosted capture by exact propagation of every input column.""" + +from fractions import Fraction as Q +from pathlib import Path +import gzip +import hashlib +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +BASE = ROOT / "work/next-track/complex/pipeline/retimed-4" + + +def compile_ops(operations): + result = [] + for event in operations: + if event[0] == "add": + result.append((event[1], event[2], Q(event[3], event[4]))) + else: + assert event[0] == "scale" + result.append((event[1], -1, Q(event[2], event[3]))) + return result + + +def apply(vector, operations): + for dst, src, coefficient in operations: + if src >= 0: + if vector[src]: + vector[dst] += coefficient * vector[src] + elif vector[dst]: + vector[dst] *= coefficient + + +def main(): + wp = BASE / "split-centres/CANONICAL-WORD.json.gz" + tp = BASE / "complex/GLOBAL-TEMPLATE.json.gz" + w = json.loads(gzip.decompress(wp.read_bytes())) + t = json.loads(gzip.decompress(tp.read_bytes())) + n = 240 + w["R"] + assert n == 800 + operations = compile_ops(w["precondition"] + w["compensation"] + w["A"] + w["B"] + w["cleanup"]) + prefix = compile_ops(w["precondition"] + w["A"]) + S, D, C = ([{} for _ in range(120)], [{} for _ in range(120)], [{} for _ in range(8)]) + for column in range(n): + vector = [0] * n + vector[column] = 1 + apply(vector, operations) + for row in list(range(120)) + list(range(240, n)): + assert vector[row] == int(row == column) + for i in range(120): + value = vector[120 + i] + if column < 120 and value: + S[i][column] = value + elif 120 <= column < 240: + assert value == int(column == 120 + i) + elif column >= 240 and value: + D[i][column] = value + assert w["start"][column] == 0 + assert value.denominator.bit_count() == 1 + if column < 120: + vector = [0] * n + vector[column] = 1 + apply(vector, prefix) + for i, center in enumerate(w["centers"][:8]): + if vector[center]: + C[i][column] = vector[center] + code = [i for i, row in enumerate(S) if row] + assert len(code) == 112 + assert [[sum(a.get(j, 0) * b.get(j, 0) for j in range(120)) for b in C] for a in C] == [[56 * int(i == j) for j in range(8)] for i in range(8)] + for i in range(120): + for j in range(120): + gram = Q(1, 4) * sum(row.get(i, 0) * row.get(j, 0) for row in C) + assert S[i].get(j, 0) == (int(i == j) - gram if i in code else 0) + helpers = tuple(range(758, 750, -1)) + assert all(w["start"][h] == 0 and w["final"][h] == 1 for h in helpers) + assert all(w["start"][120 + j] == 0 and w["final"][j] == 1 for row in C for j in row) + for column in range(n): + vector = [0] * n + vector[column] = 1 + for helper, row in zip(helpers, C): + vector[helper] += sum(q * vector[120 + j] for j, q in row.items()) + for i, row in enumerate(D): + vector[120 + i] -= sum(q * vector[j] for j, q in row.items()) + apply(vector, operations) + for helper, row in zip(helpers, C): + vector[helper] += Q(59, 4) * sum(q * vector[j] for j, q in row.items()) + expected = [0] * n + expected[column] = 1 + if column < 120: + for i, row in enumerate(S): + expected[120 + i] += row.get(column, 0) + for helper, row in zip(helpers, C): + expected[helper] += Q(59, 4) * row.get(column, 0) + elif column < 240: + for helper, row in zip(helpers, C): + expected[helper] += row.get(column - 120, 0) + assert vector == expected + assert t["residual_adapters"]["recipes"]["0"] == {"identity_adapters": True, "post": None, "pre": None, "rank": 9} + windows = {e["idx"]: e for e in t["execution_schedule"] if e["kind"] == "idle"} + owners = [] + for helper in helpers: + family, route = t["calls"][0]["owners"][helper] + assert 600 <= family <= 607 + pair, side = family // 240, (family % 240) // 120 + assert (pair, side) == (2, 1) + assert route == [4, 2, 0, 9, 0, list(range(1, 10))] + assert windows[2]["source_level"] == -1 and windows[2]["pair"] == pair + roles = [] + for call in t["calls"]: + if call["replica"] != 0: + continue + uses = [(i, r) for i, (f, r) in enumerate(call["owners"]) if f == family] + assert len(uses) <= 1 + roles.extend({"stage": call["stage"], "register": i, "route": r} for i, r in uses) + assert [r["stage"] for r in roles if r["stage"] <= 3] == [0, 2, 3] + owners.append({"helper": helper, "family": family, "entry_frame": "I", "roles": roles}) + result = { + "status": "PASS_INDEPENDENT_800_COLUMN_DIRTY_CAPTURE", + "base_columns": n, "complete_capture_columns": n, + "base_scalar_operations": len(operations), + "code_ports": len(code), "center_gram": 56, + "dirt_correction_coefficients": sum(len(row) for row in D), + "retained_forms": 8, + "source_sha256": {str(p.relative_to(ROOT)): hashlib.sha256(p.read_bytes()).hexdigest() for p in (wp, tp)}, + "owners": owners, + "scope": "Exact local label map and initial owner-frame inventory only. No modified global controller, endpoint uncompute, finite invoice, or new exponent is certified.", + } + (HERE / "RESULT.json").write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps({k: v for k, v in result.items() if k != "owners"}, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/check_endpoint.py b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/check_endpoint.py new file mode 100644 index 0000000000..4d2123ec2a --- /dev/null +++ b/research/local-eight-form-capture/historical/work/doubling-architecture/rank-independent/live-capture/check_endpoint.py @@ -0,0 +1,90 @@ +"""Check the selected chart phase and the failure of the two-tap tensor lift.""" + +from fractions import Fraction as Q +from pathlib import Path +import gzip +import hashlib +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +BASE = ROOT / "work/next-track/complex/pipeline/retimed-4" + + +def gaussian_add(x, y): + return x[0] + y[0], x[1] + y[1] + + +def gaussian_multiply(x, y): + return x[0] * y[0] - x[1] * y[1], x[0] * y[1] + x[1] * y[0] + + +def binary_apply(columns, v): + output = 0 + for j, c in enumerate(columns): + if v >> j & 1: + output ^= c + return output + + +def main(): + tp = BASE / "complex/GLOBAL-TEMPLATE.json.gz" + wp = BASE / "split-centres/CANONICAL-WORD.json.gz" + t = json.loads(gzip.decompress(tp.read_bytes())) + w = json.loads(gzip.decompress(wp.read_bytes())) + charts = [] + for helper in range(758, 750, -1): + family, route = t["calls"][0]["owners"][helper] + q = w["ports"][family % 120] + zero = min(j for j in range(9) if not (q >> j & 1)) + u = q ^ (1 << zero) + swap = list(range(89)) + swap[0], swap[zero] = swap[zero], swap[0] + b = [(1 << j) ^ (u if u >> j & 1 else 0) for j in swap] + indices = route[5] + [j for j in range(89) if j not in route[5]] + sigma = [b[j] for j in indices] + assert all((x & y).bit_count() % 2 == int(i == j) for i, x in enumerate(sigma) for j, y in enumerate(sigma)) + delta = sum((((c.bit_count() - 1) // 2) % 2) << j for j, c in enumerate(sigma)) + shift = binary_apply(sigma, delta) + assert shift == u != 0 + # Linear coefficients and pair coefficients determine the mod-four phase. + for j, c in enumerate(sigma): + assert (c.bit_count() - 1) % 4 == 2 * ((shift & c).bit_count() % 2) + for i in range(j): + v = sigma[i] ^ c + assert (v.bit_count() - 2) % 4 == 2 * ((shift & v).bit_count() % 2) + charts.append({"family": family, "helper": helper, "q": q, + "translation": shift, "strict_commutation": False}) + a, b = (Q(1, 2), Q(-1, 2)), (Q(1, 2), Q(1, 2)) + assert gaussian_add(a, b) == (1, 0) + assert gaussian_add(a, (-b[0], -b[1])) == (0, -1) + exact_tensor_eigenvalue = gaussian_multiply((0, -1), (0, -1)) + false_two_tap_eigenvalue = gaussian_add(a, b) + assert exact_tensor_eigenvalue == (-1, 0) + assert false_two_tap_eigenvalue == (1, 0) + assert exact_tensor_eigenvalue != false_two_tap_eigenvalue + assert t["execution_schedule"][0] == {"kind": "local", "pair": 0, "reverse": False, "stage": 0} + source = ROOT / "work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt" + text = source.read_text() + assert "initially\nX_(-1)=C_q, Y_(-1)=I" in text + assert "C_all C_q^(-2)=C_all X_q" in text + result = { + "status": "PASS_ENDPOINT_COVARIANCE_AND_TENSOR_COUNTEREXAMPLE", + "chart_identity": "D_I P_sigma = T_translation P_sigma D_I", + "charts": charts, + "source_X_factor_required": "D_p^-1", + "reason": "The initial C_q is a frame interpretation, not an extra paid initial transform.", + "false_tensor_shortcut_witness": { + "Fourier_character": [1, 1], + "exact_D_inverse_tensor_2": "-1", + "proposed_aI_plus_b_translation_tensor_2": "1", + }, + "source_sha256": {str(p.relative_to(ROOT)): hashlib.sha256(p.read_bytes()).hexdigest() for p in (tp, wp, source)}, + "scope": "Seed phase identities and a counterexample to a proposed constant-size all-size shortcut. No endpoint cost or modified global controller is certified.", + } + (HERE / "ENDPOINT-RESULT.json").write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps(result, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/NOTICE.md b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/NOTICE.md new file mode 100644 index 0000000000..b7daf8de49 --- /dev/null +++ b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/NOTICE.md @@ -0,0 +1,41 @@ +# Attribution + +Copyright 2026 icekylinx. New split-centre cancellation, reversible source-centre +composition, integration and verification changes were prepared by icekylinx +with substantial OpenAI Codex assistance. Apache-2.0 applies to these changes. +Earlier private Pro exploration used GPT-6 Astra; the new construction and +composition in this package were developed with Codex. + +## Direct sources + +- Zhihao Chen, with OpenAI Codex assistance: PR425's mutable-basis Hamming packet + producer, common-frame scalar interface, exact phase lowering and verification; + PR386's compressed nine-stage bit geometry, owner template, audit and finite + accounting. These supply the immediate complex and geometric baselines. +- ai-nanachi, with OpenAI Codex assistance: PR426's R767 bit word, including 55 + clean-reset helper reuses and 54 frame changes. The complete selected word is + imported unchanged before the nine source-centre replacements. +- Dylan Crow (utcorvusvolat-dotcom), with Anthropic Claude assistance: PR370's + Hamming E8 bit producer, root table, record exporter and local format. +- Jacob Sussman: the E8 family, complex unit and underlying interchange framework. +- applecrusher, Dugongue, eumemic, Rohan Arun, Chafik Boukhalfa, DaysSky, + DreamingOfClouds, Henry Grant, Evan McKinney, LJH-217 and other contributors: + the source, frame, compiler, rational-pricing and analytic lineage detailed + in the preserved original notices. + +The current value is computed from the two actual resulting programs. +Independently published improvements are not added numerically. `SOURCES.json` +records original commits and file hashes; `notices/` preserves source notices. +Files under `proofs/` describe their original packages and retain their original +scope and attribution; the current statement is in `PROOF.md`. + +## Earlier contributions by icekylinx + +The earlier #10, #18, #24, #32 and #36 contributions developed projector batching, +partial-swap frames, endpoint gauges and conditional analytic/tape integration. +The subsequent #104, #115, #130 and #144 contributions covered stopped-product +integration, partial gauges, three-stage covers and paired-cube/source chronology. +These provide historical context, not additional savings in this ledger. The +source-centre idea from the preceding local round is used here on PR426's bit +word. Unselected research experiments and superseded submission candidates are +not part of this package. diff --git a/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/SOURCES.json b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/SOURCES.json new file mode 100644 index 0000000000..215f58a649 --- /dev/null +++ b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/SOURCES.json @@ -0,0 +1,134 @@ +{ + "upstream_base": "12a4934d15006e8c10f9b2264f13f8f341be802b", + "pr425": "e11ccea1d092beb1b01b4ee4ce49da478234254c", + "pr426": "88d552526893cd15325948bb1487e9a4d4bf32f6", + "imported_files": [ + { + "path": "vendor/hamming_packets.py", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-network/hamming_packets.py", + "sha256": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5" + }, + { + "path": "vendor/clifford_exact.py", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/odd-stages/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "inputs/complex-ports.json.gz", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/higher-stage-e8/verified/gcert1-e8-retimed.json.gz", + "sha256": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b" + }, + { + "path": "inputs/complex-template.json.gz", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-nine-native/GLOBAL-TEMPLATE.json.gz", + "sha256": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e" + }, + { + "path": "inputs/complex-data-phases.json.gz", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-nine-native/DATA-PHASES.json", + "sha256": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "source_sha256": "f621f6d4296cb215f334830356c5f79fe10d6d04d15b3ccda76ba0885ab67d0a", + "encoding": "gzip; decoded bytes identical to source" + }, + { + "path": "inputs/e8-r865.json.gz", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "path": "proofs/PR425-COMPLEX.txt", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-network/hamming/PROOF.txt", + "sha256": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc" + }, + { + "path": "proofs/INHERITED-COMPLEX-GEOMETRY.txt", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-nine-native/PROOF.txt", + "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + }, + { + "path": "vendor/engines/moment.py", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/pr361/code/engines/moment.py", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" + }, + { + "path": "vendor/engines/base_two_moment.py", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/pr361/code/engines/base_two_moment.py", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098" + }, + { + "path": "vendor/engines/outer.py", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/pr361/code/engines/outer.py", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + { + "path": "vendor/export_records.py", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/e8-bit/code/bit/export_records.py", + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + { + "path": "inputs/bit-geometry.json.gz", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/e8-bit-complex-nine-validation/GEOMETRY.json.gz", + "sha256": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1" + }, + { + "path": "proofs/PR386-BIT-GEOMETRY.txt", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/e8-bit-complex-nine/PROOF.txt", + "sha256": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2" + }, + { + "path": "notices/PR386.txt", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/e8-bit-complex-nine/NOTICE.txt", + "sha256": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1" + }, + { + "path": "inputs/bit-r767.json.gz", + "source": "CrocSwap/integer-mult-bounds@88d552526893cd15325948bb1487e9a4d4bf32f6:research/e8-clean-reuse-extension/data/bit-candidate.json.gz", + "sha256": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7" + }, + { + "path": "notices/PR426.md", + "source": "CrocSwap/integer-mult-bounds@88d552526893cd15325948bb1487e9a4d4bf32f6:research/e8-clean-reuse-extension/NOTICE.md", + "sha256": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da" + }, + { + "path": "proofs/PR426.md", + "source": "CrocSwap/integer-mult-bounds@88d552526893cd15325948bb1487e9a4d4bf32f6:research/e8-clean-reuse-extension/PROOF.md", + "sha256": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb" + }, + { + "path": "notices/PR426-SOURCE-PINS.json", + "source": "CrocSwap/integer-mult-bounds@88d552526893cd15325948bb1487e9a4d4bf32f6:research/e8-clean-reuse-extension/SOURCE-PINS.json", + "sha256": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f" + }, + { + "path": "notices/NOTICE-PR352.md", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/pr370-source/research/e8-bit/NOTICE-PR352.md", + "sha256": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524" + }, + { + "path": "notices/NOTICE.md", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/pr370-source/research/e8-bit/NOTICE.md", + "sha256": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3" + }, + { + "path": "LICENSE", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/pr370-source/research/e8-bit/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "notices/SUSSMAN-NOTICE", + "source": "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/e8-bit/code/complex/inputs/complex/NOTICE", + "sha256": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81" + } + ], + "adapted_sources": { + "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-network/hamming_full.py": "613796df039dfc08de708831582533e553316eaf157485531e4df2d897bdb3bb", + "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-network/audit_full.py": "fdc1da8fa95716d60076383e691a5be1bf8bec0b229b7582bc056afac28951d0", + "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-network/integrate.py": "eb5b427f2095578f28a1fb320b4694047e20abdbe0c8bcdc65b1e9e05ab90d01", + "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-network/phase_full.py": "5c2bd267cc3106c9eee8787132c460614fdde8177c0c2653435f8a7b110ebac1", + "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/hamming-mutable-basis-complex/work/complex-network/replay_ir.py": "f7a3829118581ee59fdeefc1f91166d8e7bb94686ea92e7743a2ef7d50139dcc", + "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/e8-bit-complex-nine/global_word.py": "2c438be46213e014170e607a745185e45e33c7b7240b833efc86a2330de0d1f6", + "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/e8-bit-complex-nine/audit.py": "75811327b0d6cbd56aae8e28d72abd42d57c7f3f3630781d045efee2d36446e9", + "CrocSwap/integer-mult-bounds@e11ccea1d092beb1b01b4ee4ce49da478234254c:research/e8-bit-complex-nine/certify.py": "550b1408fb3a581dd6b82c90e3f84ad7a9f78746d2be11ffa1cf543d719ae2d4" + } +} diff --git a/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt new file mode 100644 index 0000000000..c4150cb693 --- /dev/null +++ b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt @@ -0,0 +1,161 @@ +Independent compressed nine-stage complex component + +Claim and retained assumptions + +The fixed E8 local invocation has h=9, v=120, R=783 and copied rank loss +cst=72. The construction below has m=73, live stock 14727 per complete +orthogonal cover, and paid profile + 1:157599, 2:43488, 3:37296, 4:10080, 5:15480, 6:23832, + 7:3096, 8:7488, 9:576, 16:3840, 32:3840, 48:3840. +It is a conditional complex component, not an integer multiplication bound. +The local E8 invocation theorem, general Clifford rank-zero compiler, +complete-stream tape primitives, common fine-grid precision, and retained +analytic recurrence interfaces are assumptions retained from the fixed local +source package. The new finite construction and its charges are supplied +here. No new Lean kernel proof is asserted. Final bit-side admission and +outer assembly are separate obligations. + +Exact operator convention + +For q in F2^m, let X_q be translation by q and + C_q = ((1+i) I + (1-i) X_q)/2. +Then C_q^2=X_q and C_q fixes the uniform vector. Write C_all for the product +over the coordinate vectors. An invertible binary matrix G acts by the +literal address permutation P_G. All products of C_q are commuting exact +Gaussian-dyadic operators. Their multiplier on Fourier character y is +i^(sum epsilon_q * parity(q.y)). Modulo 4, parity expands as its linear sum +minus twice its pair sum, so this multiplier is an exact Z4 quadratic form. +Equality of these forms proves equality including the scalar phase. + +For arbitrary local subspaces U, including degenerate ones, use the +deterministic canonical representative from clifford_exact.py. A basis G +whose first columns span U gives K_G = D_Q P_G, with +Q=I+G^(-T)G^(-1), and T_U=K_G C_[dim U] K_G^(-1). +Its preimage Lagrangian is {(u,u+w): u in U, w in U^perp}. Thus a nested +transition has Fourier rank equal to the dimension difference. The supplied +compiler produces two explicit monomial operators around one rank-r C child. +Its equality is checked both as a signed Pauli tableau and on a nonzero +exact Gaussian state vector, which fixes the otherwise missing global phase. +All 946 local frames, all 3120 used directed transitions, and all 240 old/new +source/target adapters are checked. No rank-only replacement is made. + +Compressed window and data routes + +Use V=F2^9 direct_sum (F2^8)^8 with the ordinary dot product. Let E_s be the +first s exterior eight-dimensional blocks, for 0<=s<=8. The exact window +representative of local U is T_U tensor C_Es. A nested transition cancels +the common exterior tensor factor exactly and keeps its original rank. +Conjugating the whole window by any cover permutation preserves this fact. +The old/new endpoint adapters are the checked local adapters tensored with +identity, followed by the declared address conjugation. This proves the +window lift directly; a divisibility assumption m=multiple_of_h is not used. + +Every supplied port q has odd weight and a zero coordinate. The explicit +orthogonal matrix U_q in data_phases.py maps e0 to q: swap e0 with a zero +coordinate e_j when necessary, then use the even-vector transvection +x -> x + ((q+e_j).x)(q+e_j). Its remaining columns are an orthonormal basis +of q^perp. For s>0, rho_s,q exchanges that complement in the local block +with exterior block s and fixes q and all other exterior coordinates. +It is a symmetric orthogonal involution. The stage data owners are +g=d*rho_s,q, with rho_0,q=I, so the right factors are bijections of O(73,2). + +Use canonical data levels X_s=C_[0,9+8s), Y_s=X_s C_q^(-1), and initially +X_(-1)=C_q, Y_(-1)=I. The routed stage starts at level s-1 and ends at level s. +Their binary preimages agree with the window endpoints. Exact phase +polynomials determine the translation that reconciles each endpoint, and +the template applies that translation. There are 3840 nonzero such +translations across the 120 port types and nine stages, before replica +multiplicity. These operators are not silently identified from equal +binary matrices. + +Four-pair scalar chain and idle children + +Starting with F_0 (Y_0 += X_0), for j=0,1,2,3 apply B_j (X_j -= Y_j), +then for j<3 apply X_j += X_(j+1), Y_(j+1) -= Y_j, apply F_j, and undo +that bridge. The last pair has B_3,F_3 without a following bridge. +Afterwards apply, in descending j=2,1,0, X_(j+1)+=X_j and Y_j-=Y_(j+1). +Finally exchange each pair by newX=oldY, newY=-oldX. The complete signed +integer scalar matrix is the identity; omission of every bridge fails. + +Before a bridge, advance the idle pair to the active pair's level. The +two advances for the newly used pairs have ranks (16,8), (32,8), (48,8). +The final advances have ranks 48,32,16,0. Each rank occurs on both members +of the pair, each of 120 ports, and each of eight replicas. A nested idle +transition is factored in the explicit orthonormal basis U_q direct_sum I. +Its exact Z4 phase is reconciled by the stored translation after that child. + +The final Y endpoint is C_all C_q^(-1). A source began at C_q, so its +unadjusted exchange route would be C_all C_q^(-2)=C_all X_q. Applying the +literal X_q to each final Y before the signed exchange removes this factor. +The corresponding 120 omission controls fail. This correction is charged. + +Banks and arbitrary correlated dirt + +There are eight replicas of each of the four data pairs, hence 7680 data +families. Each stage has 783 independent bank families. Number a local +helper occurrence by z=783*replica+helper. It uses bank floor(z/8) and slot +z mod 8, with its nine-dimensional residual assigned to coordinates +[9*slot,9*slot+9). A paid coordinate C child at coordinate 72 completes +each bank. All eight whole residuals and this padding fill dimension 73. +Thus there are 9*783=7047 bank families and live stock 14727. + +Let Pi_slot swap the first nine coordinates with the assigned block. The +local invocation at class d uses the bank class g=d*Pi_slot^(-1). Its +residual at that owner is P_g C_block P_g^(-1). Right multiplication is a +bijection. Local helpers sharing one bank have distinct slots, hence +different right factors and different actual bank classes for every d. +All data and private families are disjoint from banks. The checker verifies +these injections for all 72 invocation/replica templates and 56376 residual +assignments. A complete cover sweep for one replica finishes before the +next begins. The local dirty invocation is block diagonal on helpers at +its endpoint and permits arbitrary correlated helper values. Therefore +overlap between different invocations does not impose a cleanliness or +independence assumption. At each bank class, the eight residuals and the +padding are coordinate factors in one common conjugated basis, and their +exact product is P_g C_all P_g^(-1). + +One more exact correction is essential. Orthogonality alone does not imply +that P_g commutes with C_all as an exact operator. In fact + P_g C_all P_g^(-1) = C_all X_delta(g), + delta(g)_i = (weight(row_i(g))-1)/2 mod 2. +The quadratic terms cancel by row orthogonality and the remaining even +linear terms give the displayed translation. Both sides fix the uniform +vector, fixing the global scalar. Apply X_delta(g) to EVERY final live +family in cover class g, after the bank padding and signed data exchange. +The template includes and charges all 14727 corrections per cover. This +identity is also checked on every orthogonal matrix in dimensions 1..5. + +Finite work and recurrence charges + +The source emitter is regenerated and revalidated in both orientations. +It accounts for 1242936 local events over 72 invocations, with all copied +center and dirty-tableau lifetimes intact. Forward and backward scalar +words freshly replay all 1023 independent dirty live columns. Only the +private work starts at zero. Work comprises 783 tableau streams, nine +reserved center streams (eight used), and one coefficient stream. Each +invocation completes and erases its private work before the next. Physical +stock is therefore 15520 per cover; scalar-only work is excluded from the +recursion-volume denominator. + +GLOBAL-REVIEW.json records the complete recomputed finite overcharge, with +64*(73+1)^3 compiler groups per rank-zero adapter, source-counted scalar +primitives, and overcharges for all data routes, bank selectors, phases, +padding, bridges, exchanges and cover corrections. The O(73,2) order is +2^(36^2)*product(2^(2i)-1,i=1..36); its bit length is 2628. The recomputed +router fits 2^30000, the literal charge fits 2^100000, and the precision +guard fits C0=2^210000. No even-dimensional orthogonal-order formula is used. + +Largest child 48 does not satisfy one-layer halving. Instead +73^2=5329>2*48^2=4608, so two nested children have width strictly below +half the parent, including floors. The general depth is bounded by +2*ceil(log2 e), with direct small leaves. For B=s+E the completed-child +semantic induction has 2B(73-48)-s-E=49B>0. The resulting conservative +complete-row coefficient is 2*2642+9909+252=15445<20161, retaining the +external bit/base-row allowance as an explicit interface assumption. +The inherited bad-branch envelope is priced conservatively as before. + +Two independent rational moment engines admit +b=999240641319551/10^18 and exclude b+10^-18 for the source-bound profile. +The rank mass is 1072575, and 73*14727-1072575=2496=8*(8*120-9*72). +This complex component exceeds 1/1024 but does not improve the current +bit bottleneck. No improved final kappa or completed PR milestone follows. diff --git a/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz new file mode 100644 index 0000000000..5929a4251c Binary files /dev/null and b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz differ diff --git a/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz new file mode 100644 index 0000000000..219bdda013 Binary files /dev/null and b/research/local-eight-form-capture/historical/work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz differ diff --git a/research/local-eight-form-capture/primary.py b/research/local-eight-form-capture/primary.py new file mode 100644 index 0000000000..a29448044e --- /dev/null +++ b/research/local-eight-form-capture/primary.py @@ -0,0 +1,115 @@ +"""Check a local dirty capture and list its current physical owners.""" +import argparse +from fractions import Fraction as Q +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) +parser.add_argument("--output", type=Path, required=True) +args = parser.parse_args() +BASE = args.base +WP = BASE/'retimed-4/split-centres/CANONICAL-WORD.json.gz' +TP = BASE/'retimed-4/complex/GLOBAL-TEMPLATE.json.gz' +w = json.loads(gzip.decompress(WP.read_bytes())) +t = json.loads(gzip.decompress(TP.read_bytes())) +n = 240 + w['R'] + +def add(rows, dst, src, q): + for j, x in list(rows[src].items()): + z = rows[dst].get(j, Q(0)) + q*x + if z: + rows[dst][j] = z + else: + rows[dst].pop(j, None) + + +def run(rows, operations): + for e in operations: + if e[0] == 'add': + add(rows, e[1], e[2], Q(e[3], e[4])) + else: + rows[e[1]] = {j: x*Q(e[2], e[3]) for j, x in rows[e[1]].items()} + + +def identity(): + return [{i: Q(1)} for i in range(n)] + + +ops = w['precondition'] + w['compensation'] + w['A'] + w['B'] + w['cleanup'] +rows = identity() +run(rows, ops) +assert all(rows[i] == {i: 1} for i in list(range(120)) + list(range(240, n))) +assert all({j: x for j, x in rows[i].items() if 120 <= j < 240} == {i: 1} + for i in range(120, 240)) +S = [{j: x for j, x in rows[120+i].items() if j < 120} for i in range(120)] +D = [{j: x for j, x in rows[120+i].items() if j >= 240} for i in range(120)] +assert all(w['start'][j] == 0 for row in D for j in row) +assert all(x.denominator & (x.denominator-1) == 0 for row in D for x in row.values()) + +# Each selected centre row is a dyadic form of the input X bank. +clean = [{i: Q(1)} if i < 240 else {} for i in range(n)] +run(clean, w['precondition'] + w['A']) +C = [clean[r] for r in w['centers'][:8]] +assert all(row and all(j < 120 for j in row) for row in C) +assert [[sum(C[i].get(j, 0)*C[k].get(j, 0) for j in range(120)) + for k in range(8)] for i in range(8)] == [[56*int(i == k) for k in range(8)] for i in range(8)] +code = [i for i, row in enumerate(S) if row] +for i in code: + for j in range(120): + gram = sum(row.get(i, 0)*row.get(j, 0) for row in C)/4 + assert Q(int(i == j)) - S[i].get(j, 0) == gram +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 in row) + +# Correct the omitted-centre word on all helper dirt, then retain eight forms. +state = identity() +for r, form in zip(helpers, C): + for j, q in form.items(): + add(state, r, 120+j, q) +for i, row in enumerate(D): + for j, q in row.items(): + add(state, 120+i, j, -q) +run(state, ops) +for r, form in zip(helpers, C): + for j, q in form.items(): + add(state, r, j, Q(59, 4)*q) +expected = identity() +for i, row in enumerate(S): + for j, q in row.items(): + add(expected, 120+i, j, q) +for r, form in zip(helpers, C): + for j, q in form.items(): + expected[r][j] = Q(59, 4)*q + expected[r][120+j] = q +assert state == expected + +owners = [] +for r in helpers: + family, route = t['calls'][0]['owners'][r] + assert 600 <= family <= 607 and route[:6] == [4, 2, 0, 9, 0, [1,2,3,4,5,6,7,8,9]] + roles = [] + for call in t['calls']: + if call['replica']: + continue + same = [(i, rr) for i, (f, rr) in enumerate(call['owners']) if f == family] + assert len(same) <= 1 + roles += [dict(stage=call['stage'], register=i, route=rr) for i, rr in same] + assert [z['stage'] for z in roles if z['stage'] <= 3] == [0, 2, 3] + assert [z['route'][2] for z in roles if z['stage'] <= 3] == [0, 9, 18] + owners.append(dict(family=family, capture_register=r, roles=roles)) +result = dict(status='PASS_LOCAL_DIRTY_CAPTURE_AND_CURRENT_OWNER_INVENTORY', + word_sha256=hashlib.sha256(WP.read_bytes()).hexdigest(), + template_sha256=hashlib.sha256(TP.read_bytes()).hexdigest(), + all_columns=n, retained_forms=8, centre_gram_multiplier=56, decoder_factor='C^t C / 4', + dirty_correction_terms=sum(map(len,D)), + local_source_and_target_map='X unchanged; Y += S X', + local_helper_map='Selected h_i += C_i(59 X/4 + Y); all other helpers unchanged', + owners=owners, + scope='The local scalar map and current owner inventory are exact. The paid monomial adapters, endpoint decoder, scalar controller, owner restoration, and global cost are not verified.') +args.output.write_text(json.dumps(result, indent=2)+'\n') +print(json.dumps({k:v for k,v in result.items() if k != 'owners'}, indent=2)) diff --git a/research/local-eight-form-capture/replay.log b/research/local-eight-form-capture/replay.log new file mode 100644 index 0000000000..65cc02a5c8 --- /dev/null +++ b/research/local-eight-form-capture/replay.log @@ -0,0 +1,5 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture/primary.py --base /private/tmp/eight-form-capture-cleanup-20261023/work/next-track/complex/pipeline --output /private/tmp/eight-form-capture-cleanup-20261023/primary-result.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture/dense_columns.py --base /private/tmp/eight-form-capture-cleanup-20261023/work/next-track/complex/pipeline +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /private/tmp/eight-form-capture-cleanup-20261023/work/doubling-architecture/rank-independent/live-capture/check.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /private/tmp/eight-form-capture-cleanup-20261023/work/doubling-architecture/rank-independent/live-capture/check_endpoint.py +PASS_LOCAL_EIGHT_FORM_CAPTURE 800 8 11326 diff --git a/research/local-eight-form-capture/replayed-receipt.json b/research/local-eight-form-capture/replayed-receipt.json new file mode 100644 index 0000000000..f2a8f3ba7c --- /dev/null +++ b/research/local-eight-form-capture/replayed-receipt.json @@ -0,0 +1,2633 @@ +{ + "status": "PASS_LOCAL_EIGHT_FORM_CAPTURE", + "checks": [ + { + "status": "PASS_LOCAL_DIRTY_CAPTURE_AND_CURRENT_OWNER_INVENTORY", + "word_sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "template_sha256": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f", + "all_columns": 800, + "retained_forms": 8, + "centre_gram_multiplier": 56, + "decoder_factor": "C^t C / 4", + "dirty_correction_terms": 11326, + "local_source_and_target_map": "X unchanged; Y += S X", + "local_helper_map": "Selected h_i += C_i(59 X/4 + Y); all other helpers unchanged", + "owners": [ + { + "family": 600, + "capture_register": 758, + "roles": [ + { + "stage": 0, + "register": 758, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 643, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 758, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 120, + "route": [ + 1, + 5, + 0 + ] + }, + { + "stage": 6, + "register": 120, + "route": [ + 1, + 6, + 0 + ] + }, + { + "stage": 7, + "register": 359, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 359, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 359, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 601, + "capture_register": 757, + "roles": [ + { + "stage": 0, + "register": 757, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 642, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 757, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 121, + "route": [ + 1, + 5, + 1 + ] + }, + { + "stage": 6, + "register": 121, + "route": [ + 1, + 6, + 1 + ] + }, + { + "stage": 7, + "register": 358, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 358, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 358, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 602, + "capture_register": 756, + "roles": [ + { + "stage": 0, + "register": 756, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 641, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 756, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 122, + "route": [ + 1, + 5, + 2 + ] + }, + { + "stage": 6, + "register": 122, + "route": [ + 1, + 6, + 2 + ] + }, + { + "stage": 7, + "register": 357, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 357, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 357, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 603, + "capture_register": 755, + "roles": [ + { + "stage": 0, + "register": 755, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 640, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 755, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 123, + "route": [ + 1, + 5, + 3 + ] + }, + { + "stage": 6, + "register": 123, + "route": [ + 1, + 6, + 3 + ] + }, + { + "stage": 7, + "register": 356, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 356, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 356, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 604, + "capture_register": 754, + "roles": [ + { + "stage": 0, + "register": 754, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 639, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 754, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 124, + "route": [ + 1, + 5, + 4 + ] + }, + { + "stage": 6, + "register": 124, + "route": [ + 1, + 6, + 4 + ] + }, + { + "stage": 7, + "register": 355, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 355, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 355, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 605, + "capture_register": 753, + "roles": [ + { + "stage": 0, + "register": 753, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 638, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 753, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 125, + "route": [ + 1, + 5, + 5 + ] + }, + { + "stage": 6, + "register": 125, + "route": [ + 1, + 6, + 5 + ] + }, + { + "stage": 7, + "register": 354, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 354, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 354, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 606, + "capture_register": 752, + "roles": [ + { + "stage": 0, + "register": 752, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 637, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 752, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 126, + "route": [ + 1, + 5, + 6 + ] + }, + { + "stage": 6, + "register": 126, + "route": [ + 1, + 6, + 6 + ] + }, + { + "stage": 7, + "register": 353, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 353, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 353, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 607, + "capture_register": 751, + "roles": [ + { + "stage": 0, + "register": 751, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 636, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 751, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 127, + "route": [ + 1, + 5, + 7 + ] + }, + { + "stage": 6, + "register": 127, + "route": [ + 1, + 6, + 7 + ] + }, + { + "stage": 7, + "register": 352, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 352, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 352, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + } + ], + "scope": "The local scalar map and current owner inventory are exact. The paid monomial adapters, endpoint decoder, scalar controller, owner restoration, and global cost are not verified." + }, + { + "status": "PASS_INDEPENDENT_EXACT_CAPTURE_MAP", + "source_sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "method": "800 exact input columns; symbolic composition of boundary maps", + "columns": 800, + "scalar_operations": 19449, + "code_ports": 112, + "dirty_correction_terms": 11326, + "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." + }, + { + "status": "PASS_INDEPENDENT_800_COLUMN_DIRTY_CAPTURE", + "base_columns": 800, + "complete_capture_columns": 800, + "base_scalar_operations": 19449, + "code_ports": 112, + "center_gram": 56, + "dirt_correction_coefficients": 11326, + "retained_forms": 8, + "source_sha256": { + "work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f" + }, + "owners": [ + { + "helper": 758, + "family": 600, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 758, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 643, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 758, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 120, + "route": [ + 1, + 5, + 0 + ] + }, + { + "stage": 6, + "register": 120, + "route": [ + 1, + 6, + 0 + ] + }, + { + "stage": 7, + "register": 359, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 359, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 359, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 757, + "family": 601, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 757, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 642, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 757, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 121, + "route": [ + 1, + 5, + 1 + ] + }, + { + "stage": 6, + "register": 121, + "route": [ + 1, + 6, + 1 + ] + }, + { + "stage": 7, + "register": 358, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 358, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 358, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 756, + "family": 602, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 756, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 641, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 756, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 122, + "route": [ + 1, + 5, + 2 + ] + }, + { + "stage": 6, + "register": 122, + "route": [ + 1, + 6, + 2 + ] + }, + { + "stage": 7, + "register": 357, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 357, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 357, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 755, + "family": 603, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 755, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 640, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 755, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 123, + "route": [ + 1, + 5, + 3 + ] + }, + { + "stage": 6, + "register": 123, + "route": [ + 1, + 6, + 3 + ] + }, + { + "stage": 7, + "register": 356, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 356, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 356, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 754, + "family": 604, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 754, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 639, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 754, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 124, + "route": [ + 1, + 5, + 4 + ] + }, + { + "stage": 6, + "register": 124, + "route": [ + 1, + 6, + 4 + ] + }, + { + "stage": 7, + "register": 355, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 355, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 355, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 753, + "family": 605, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 753, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 638, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 753, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 125, + "route": [ + 1, + 5, + 5 + ] + }, + { + "stage": 6, + "register": 125, + "route": [ + 1, + 6, + 5 + ] + }, + { + "stage": 7, + "register": 354, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 354, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 354, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 752, + "family": 606, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 752, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 637, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 752, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 126, + "route": [ + 1, + 5, + 6 + ] + }, + { + "stage": 6, + "register": 126, + "route": [ + 1, + 6, + 6 + ] + }, + { + "stage": 7, + "register": 353, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 353, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 353, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 751, + "family": 607, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 751, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 636, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 751, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 127, + "route": [ + 1, + 5, + 7 + ] + }, + { + "stage": 6, + "register": 127, + "route": [ + 1, + 6, + 7 + ] + }, + { + "stage": 7, + "register": 352, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 352, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 352, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + } + ], + "scope": "Exact local label map and initial owner-frame inventory only. No modified global controller, endpoint uncompute, finite invoice, or new exponent is certified." + }, + { + "status": "PASS_ENDPOINT_COVARIANCE_AND_TENSOR_COUNTEREXAMPLE", + "chart_identity": "D_I P_sigma = T_translation P_sigma D_I", + "charts": [ + { + "family": 600, + "helper": 758, + "q": 7, + "translation": 15, + "strict_commutation": false + }, + { + "family": 601, + "helper": 757, + "q": 11, + "translation": 15, + "strict_commutation": false + }, + { + "family": 602, + "helper": 756, + "q": 19, + "translation": 23, + "strict_commutation": false + }, + { + "family": 603, + "helper": 755, + "q": 35, + "translation": 39, + "strict_commutation": false + }, + { + "family": 604, + "helper": 754, + "q": 67, + "translation": 71, + "strict_commutation": false + }, + { + "family": 605, + "helper": 753, + "q": 131, + "translation": 135, + "strict_commutation": false + }, + { + "family": 606, + "helper": 752, + "q": 259, + "translation": 263, + "strict_commutation": false + }, + { + "family": 607, + "helper": 751, + "q": 13, + "translation": 15, + "strict_commutation": false + } + ], + "source_X_factor_required": "D_p^-1", + "reason": "The initial C_q is a frame interpretation, not an extra paid initial transform.", + "false_tensor_shortcut_witness": { + "Fourier_character": [ + 1, + 1 + ], + "exact_D_inverse_tensor_2": "-1", + "proposed_aI_plus_b_translation_tensor_2": "1" + }, + "source_sha256": { + "work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f", + "work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + }, + "scope": "Seed phase identities and a counterexample to a proposed constant-size all-size shortcut. No endpoint cost or modified global controller is certified." + } + ], + "source_manifest_sha256": "7405268783ebe41df6ef22d44565047800668a1e33478339ae5a08673b168cff" +} diff --git a/research/local-eight-form-capture/review/BOUNDARY-COUNT-CONTROL.json b/research/local-eight-form-capture/review/BOUNDARY-COUNT-CONTROL.json new file mode 100644 index 0000000000..93d3b2ea3c --- /dev/null +++ b/research/local-eight-form-capture/review/BOUNDARY-COUNT-CONTROL.json @@ -0,0 +1,44 @@ +{ + "status": "PASS_BOUNDARY_COUNTS_AND_SELECTED_HELPER_D_COLUMN_CHECK", + "centre_row_support": [ + 56, + 56, + 56, + 56, + 56, + 56, + 56, + 56 + ], + "centre_coefficients": [ + -1, + 0, + 1 + ], + "base_scalar_operations": 19449, + "dirt_correction_operations": 11326, + "dirt_correction_count_source": "Reproduced complete historical receipts", + "preload_operations": 448, + "postload_operations": 448, + "total_scalar_operations": 31671, + "all_Y_start_at_zero_frame": true, + "zero_and_full_frame_ids_verified": true, + "selected_helper_D_nonzero_counts": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "DP_zero": true, + "clarification": "For these selected helpers D has zero columns. Using their old values does not add a nonzero DPY error. The implemented updated-helper order is valid.", + "scope": "Scalar operation count and order clarification only; no native or recursive cost invoice.", + "method": "Use the retained column interpreter on 120 centre-prefix and eight helper basis columns.", + "source_sha256": { + "historical/work/doubling-architecture/rank-independent/live-capture/check.py": "558df28c3e0934d8b1d2fdfb591e57fb2cc60ae69e599a341c1bc7f507a685c4", + "historical/work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be" + } +} diff --git a/research/local-eight-form-capture/review/CHECKED-FILES-AFTER.json b/research/local-eight-form-capture/review/CHECKED-FILES-AFTER.json new file mode 100644 index 0000000000..bc7fc9d428 --- /dev/null +++ b/research/local-eight-form-capture/review/CHECKED-FILES-AFTER.json @@ -0,0 +1,136 @@ +{ + "scope": "All regular staged package files, except top-level review/ and publication-review/. Review copies are excluded to avoid self-reference.", + "package": "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture", + "excluded_directory_names": [ + "review", + "publication-review" + ], + "excluded_files_present": [], + "files": [ + { + "path": "README.md", + "bytes": 5457, + "sha256": "dd83a4bf5bf203d9d6a2ac43b05d9d3668021a20aa771fed2c1b7929fe649418" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 5479, + "sha256": "7405268783ebe41df6ef22d44565047800668a1e33478339ae5a08673b168cff" + }, + { + "path": "VALIDATION.json", + "bytes": 685, + "sha256": "d41054458c21fb1d8649cdda0066c84249ebc22cc0f300ea4951a202e3a431a6" + }, + { + "path": "dense_columns.py", + "bytes": 3540, + "sha256": "d3fff0581817b15ba873b8e8fcd106005214d48de44aa713f397952bd9d47269" + }, + { + "path": "historical/work/combined-pr/publication/research/e8-combined/NOTICE", + "bytes": 5054, + "sha256": "7b41fa130dcd11e5972eed84e12f3499d80ea00e17d460f450fa8ddf39cc4951" + }, + { + "path": "historical/work/combined-pr/publication/research/e8-combined/vendor/complex/SOURCES.json", + "bytes": 8867, + "sha256": "72e38ad6a030b7bb29eac71cda1eafeb96e9202630a9e96f3fbf5cac31742b49" + }, + { + "path": "historical/work/complex-next/structural/check_hosted_capture.py", + "bytes": 4711, + "sha256": "04a1f9434d3b1ba9b0744863522cfeab7b139d51f361ec2e887994ac7fdf9c12" + }, + { + "path": "historical/work/complex-next/structural/hamming-factor/HOSTED-CAPTURE-REVIEW.txt", + "bytes": 2541, + "sha256": "16df704fa05256cb567bb7c84eb8ebc213cead05b7c3cb6d295d435241a13833" + }, + { + "path": "historical/work/complex-next/structural/hamming-factor/capture-independent-receipt.json", + "bytes": 528, + "sha256": "e2db977b175614a57c23111fbee0ccd0639f50e1c329da15b5de9384ae1bfce2" + }, + { + "path": "historical/work/complex-next/structural/hamming-factor/check_capture_independent.py", + "bytes": 3403, + "sha256": "0520113c0318f4eaf0cb56dde5ee88980ff5e10cbd3f20cfd942d580ea8951f1" + }, + { + "path": "historical/work/complex-next/structural/hosted-capture-receipt.json", + "bytes": 21400, + "sha256": "61198fdd7d1b99e2384b50fd5666d48866c98bf61280df4694ac10f13dab0b12" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/ENDPOINT-RESULT.json", + "bytes": 2185, + "sha256": "3ff5c5f1f58d1b658d493083ec69e5225f33d0fe4d39be8285ffa937f004bc8e" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/RESULT.json", + "bytes": 21564, + "sha256": "8ff1440f0008f8af3344c4598f0d08cf375b1b47eba363a30fa3c697a3a35c9a" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/REVIEW.txt", + "bytes": 5447, + "sha256": "e4eaa33d9143d78e0230b2fd4ce4afd0610a4b290a052f6c1ab0793974437f39" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/check.py", + "bytes": 5787, + "sha256": "558df28c3e0934d8b1d2fdfb591e57fb2cc60ae69e599a341c1bc7f507a685c4" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/check_endpoint.py", + "bytes": 3871, + "sha256": "70deac8ee0febef6c7d1b55d3a756bb9bb7dace7b4ce6a1728c226c77b62a639" + }, + { + "path": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/NOTICE.md", + "bytes": 2447, + "sha256": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389" + }, + { + "path": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/SOURCES.json", + "bytes": 8835, + "sha256": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be" + }, + { + "path": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt", + "bytes": 9402, + "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + }, + { + "path": "historical/work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz", + "bytes": 465792, + "sha256": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f" + }, + { + "path": "historical/work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz", + "bytes": 83586, + "sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be" + }, + { + "path": "primary.py", + "bytes": 4862, + "sha256": "4667c42411fc8d50868d5e1cc5335d2e966cb0d05876564c91aeb728ba4a69dc" + }, + { + "path": "replay.log", + "bytes": 1079, + "sha256": "d3c39d733abd943d10d5569e72218daed05b350cb7fb3046d3b15e2eca06b554" + }, + { + "path": "replayed-receipt.json", + "bytes": 56351, + "sha256": "b52c403f5dc4b5d8e5cb40d94dbc3a223a113c441e6c35ff81c832ff12ea92e2" + }, + { + "path": "verify.py", + "bytes": 2623, + "sha256": "02e8d40eb8d13b06227c54528a0e10fa63cc256f16a39bc0b2eee09a069f1d00" + } + ] +} diff --git a/research/local-eight-form-capture/review/CHECKED-FILES-BEFORE.json b/research/local-eight-form-capture/review/CHECKED-FILES-BEFORE.json new file mode 100644 index 0000000000..66d14de43a --- /dev/null +++ b/research/local-eight-form-capture/review/CHECKED-FILES-BEFORE.json @@ -0,0 +1,117 @@ +[ + { + "path": "README.md", + "bytes": 5163, + "sha256": "6bf2fa7cc2cfcdf480a60c5a93fb0b026a7c6d3f5135d037fc77b37c46a04e98" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 5479, + "sha256": "7405268783ebe41df6ef22d44565047800668a1e33478339ae5a08673b168cff" + }, + { + "path": "dense_columns.py", + "bytes": 3540, + "sha256": "d3fff0581817b15ba873b8e8fcd106005214d48de44aa713f397952bd9d47269" + }, + { + "path": "historical/work/combined-pr/publication/research/e8-combined/NOTICE", + "bytes": 5054, + "sha256": "7b41fa130dcd11e5972eed84e12f3499d80ea00e17d460f450fa8ddf39cc4951" + }, + { + "path": "historical/work/combined-pr/publication/research/e8-combined/vendor/complex/SOURCES.json", + "bytes": 8867, + "sha256": "72e38ad6a030b7bb29eac71cda1eafeb96e9202630a9e96f3fbf5cac31742b49" + }, + { + "path": "historical/work/complex-next/structural/check_hosted_capture.py", + "bytes": 4711, + "sha256": "04a1f9434d3b1ba9b0744863522cfeab7b139d51f361ec2e887994ac7fdf9c12" + }, + { + "path": "historical/work/complex-next/structural/hamming-factor/HOSTED-CAPTURE-REVIEW.txt", + "bytes": 2541, + "sha256": "16df704fa05256cb567bb7c84eb8ebc213cead05b7c3cb6d295d435241a13833" + }, + { + "path": "historical/work/complex-next/structural/hamming-factor/capture-independent-receipt.json", + "bytes": 528, + "sha256": "e2db977b175614a57c23111fbee0ccd0639f50e1c329da15b5de9384ae1bfce2" + }, + { + "path": "historical/work/complex-next/structural/hamming-factor/check_capture_independent.py", + "bytes": 3403, + "sha256": "0520113c0318f4eaf0cb56dde5ee88980ff5e10cbd3f20cfd942d580ea8951f1" + }, + { + "path": "historical/work/complex-next/structural/hosted-capture-receipt.json", + "bytes": 21400, + "sha256": "61198fdd7d1b99e2384b50fd5666d48866c98bf61280df4694ac10f13dab0b12" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/ENDPOINT-RESULT.json", + "bytes": 2185, + "sha256": "3ff5c5f1f58d1b658d493083ec69e5225f33d0fe4d39be8285ffa937f004bc8e" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/RESULT.json", + "bytes": 21564, + "sha256": "8ff1440f0008f8af3344c4598f0d08cf375b1b47eba363a30fa3c697a3a35c9a" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/REVIEW.txt", + "bytes": 5447, + "sha256": "e4eaa33d9143d78e0230b2fd4ce4afd0610a4b290a052f6c1ab0793974437f39" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/check.py", + "bytes": 5787, + "sha256": "558df28c3e0934d8b1d2fdfb591e57fb2cc60ae69e599a341c1bc7f507a685c4" + }, + { + "path": "historical/work/doubling-architecture/rank-independent/live-capture/check_endpoint.py", + "bytes": 3871, + "sha256": "70deac8ee0febef6c7d1b55d3a756bb9bb7dace7b4ce6a1728c226c77b62a639" + }, + { + "path": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/NOTICE.md", + "bytes": 2447, + "sha256": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389" + }, + { + "path": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/SOURCES.json", + "bytes": 8835, + "sha256": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be" + }, + { + "path": "historical/work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt", + "bytes": 9402, + "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + }, + { + "path": "historical/work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz", + "bytes": 465792, + "sha256": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f" + }, + { + "path": "historical/work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz", + "bytes": 83586, + "sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be" + }, + { + "path": "primary.py", + "bytes": 4862, + "sha256": "4667c42411fc8d50868d5e1cc5335d2e966cb0d05876564c91aeb728ba4a69dc" + }, + { + "path": "replay.log", + "bytes": 857, + "sha256": "9589fd7bfe178f7ff8c3862bbe3b8c26c5e69da8ac6bbd5608c245694b5bdc46" + }, + { + "path": "verify.py", + "bytes": 2623, + "sha256": "02e8d40eb8d13b06227c54528a0e10fa63cc256f16a39bc0b2eee09a069f1d00" + } +] diff --git a/research/local-eight-form-capture/review/COMMAND.json b/research/local-eight-form-capture/review/COMMAND.json new file mode 100644 index 0000000000..b2f69aff56 --- /dev/null +++ b/research/local-eight-form-capture/review/COMMAND.json @@ -0,0 +1,14 @@ +{ + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-I", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture/verify.py", + "--build", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/local-capture/fresh-run" + ], + "cwd": "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture", + "PYTHONOPTIMIZE": "1", + "python_version": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "one_child_at_a_time": true +} diff --git a/research/local-eight-form-capture/review/PORTABILITY.diff b/research/local-eight-form-capture/review/PORTABILITY.diff new file mode 100644 index 0000000000..e25a2e4ebf --- /dev/null +++ b/research/local-eight-form-capture/review/PORTABILITY.diff @@ -0,0 +1,49 @@ +--- historical/work/complex-next/structural/check_hosted_capture.py ++++ primary.py +@@ -1,10 +1,17 @@ + """Check a local dirty capture and list its current physical owners.""" ++import argparse + from fractions import Fraction as Q + import gzip + import hashlib + import json + from pathlib import Path +-BASE = Path('/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/next-track/complex/pipeline') ++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) ++parser.add_argument("--output", type=Path, required=True) ++args = parser.parse_args() ++BASE = args.base + WP = BASE/'retimed-4/split-centres/CANONICAL-WORD.json.gz' + TP = BASE/'retimed-4/complex/GLOBAL-TEMPLATE.json.gz' + w = json.loads(gzip.decompress(WP.read_bytes())) +@@ -104,5 +111,5 @@ + local_helper_map='Selected h_i += C_i(59 X/4 + Y); all other helpers unchanged', + owners=owners, + scope='The local scalar map and current owner inventory are exact. The paid monomial adapters, endpoint decoder, scalar controller, owner restoration, and global cost are not verified.') +-Path(__file__).with_name('hosted-capture-receipt.json').write_text(json.dumps(result, indent=2)+'\n') ++args.output.write_text(json.dumps(result, indent=2)+'\n') + print(json.dumps({k:v for k,v in result.items() if k != 'owners'}, indent=2)) +--- historical/work/complex-next/structural/hamming-factor/check_capture_independent.py ++++ dense_columns.py +@@ -1,11 +1,17 @@ + """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 + +-BASE = Path('/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/next-track/complex/pipeline') ++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)) diff --git a/research/local-eight-form-capture/review/RESULT.json b/research/local-eight-form-capture/review/RESULT.json new file mode 100644 index 0000000000..965afe507a --- /dev/null +++ b/research/local-eight-form-capture/review/RESULT.json @@ -0,0 +1,4 @@ +{ + "exit_code": 0, + "seconds": 27.264490625006147 +} diff --git a/research/local-eight-form-capture/review/REVIEW-STATUS.json b/research/local-eight-form-capture/review/REVIEW-STATUS.json new file mode 100644 index 0000000000..facb65dc40 --- /dev/null +++ b/research/local-eight-form-capture/review/REVIEW-STATUS.json @@ -0,0 +1,86 @@ +{ + "status": "PASS", + "result_type": "Exact forward local scalar construction and scoped endpoint limitations", + "reviewer": "Independent agent review; no human review claimed", + "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703", + "package_files_bound": 25, + "frozen_originals_byte_verified": 17, + "fresh_complete_receipt_comparisons": 4, + "replay_exit_code": 0, + "replay_seconds": 27.264490625006147, + "final_replay_line": "PASS_LOCAL_EIGHT_FORM_CAPTURE 800 8 11326", + "worker_and_reviewer_receipts_equal": true, + "full_scalar_count": 31671, + "selected_helper_D_columns_all_zero": true, + "DP_zero": true, + "resolved_findings": [ + "The fixed selected helper columns of D are all zero. The generic stale-helper DPY term is therefore zero here. README qualifies the unchanged historical warning.", + "README now gives the full 31,671 scalar operation count." + ], + "unresolved_material_findings": [], + "exclusions": [ + "No native or physical realization of new boundary operations", + "No backward or global routed controller construction", + "No restoration of the eight retained helper owners", + "No complete recursive invoice", + "No kappa improvement", + "No final PR-body, GitHub rendering or published readback review" + ], + "evidence": [ + { + "path": "REVIEW.md", + "bytes": 8047, + "sha256": "4cf1b9773ca8b53050b528552c400fa528a2266db8eb3124d851f3287e7d5e81" + }, + { + "path": "COMMAND.json", + "bytes": 709, + "sha256": "47fca30ee97eb8aaa7b8e81b77fe2ed9b448dd7d98127f2160cce8204c554cad" + }, + { + "path": "RESULT.json", + "bytes": 54, + "sha256": "646ef3cfcfe054bf7844619298975540c77c9b7dbfc638609228951bbf55dc03" + }, + { + "path": "stdout.log", + "bytes": 1444, + "sha256": "59b9f47d6ba203c7e65caab423293b4e064616ffa0a26399bdfd3497b7e48587" + }, + { + "path": "stderr.log", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "SOURCE-AND-EVIDENCE-CHECK.json", + "bytes": 7461, + "sha256": "0151353b5ef79233a09891ebf3276a7f9fd1dd65694b2dc438f46ab67ca79c30" + }, + { + "path": "PORTABILITY.diff", + "bytes": 2282, + "sha256": "d2e3f8576e3be7ffc128d969e59261ca2fc6071cf2181e5061753d149f37a2d6" + }, + { + "path": "check_boundary_counts.py", + "bytes": 3220, + "sha256": "b0518b671cf2854c7b176db1a1c302369b27b93e59a8ee0270a29f7c6ca8a061" + }, + { + "path": "BOUNDARY-COUNT-CONTROL.json", + "bytes": 1391, + "sha256": "7b6ab1d2768f0d5f30d2e082679fb282905b5f8c57c537f3cdbc6132f77cf9f2" + }, + { + "path": "fresh-run/receipt.json", + "bytes": 56351, + "sha256": "b52c403f5dc4b5d8e5cb40d94dbc3a223a113c441e6c35ff81c832ff12ea92e2" + }, + { + "path": "CHECKED-FILES-AFTER.json", + "bytes": 5360, + "sha256": "4d9ead7fcc6a1df836f90383158606c27525b4b9a16d240ec7d0eeedb84e45f6" + } + ] +} diff --git a/research/local-eight-form-capture/review/REVIEW.md b/research/local-eight-form-capture/review/REVIEW.md new file mode 100644 index 0000000000..b8a5f11b5a --- /dev/null +++ b/research/local-eight-form-capture/review/REVIEW.md @@ -0,0 +1,142 @@ +# Independent agent review: local eight-form capture + +Status: PASS after the scope correction below. This is an independent agent +review, not a human review or a formal proof-assistant check. The review covers +the staged local-eight-form-capture package and its exact frozen inputs. +It does not cover GitHub rendering or the final PR text. + +## Result and useful scope + +The package gives a complete forward local scalar program on 800 arbitrary +input fields: 120 X fields, 120 Y fields and 560 helper fields. It preserves X, +sends Y to Y+SX, and sends the eight helpers with indices 758 through 751 to +h_i+C_i(59X/4+Y). It preserves every other helper. The selected eight helpers +remain changed; the program does not restore them. + +This gives an exact fixture for capture into existing, arbitrary dirty helper +values. Its initial owner inventory identifies those helpers with future Y data +owners. It does not treat the live owners as private workspace. The result can +be used to test a proposed local composition against the old owner values. +It does not establish that such a composition has a lower complete cost. + +The exact C rows have entries in {0,+1,-1}, support 56 each, and C C^T=56I. +The identity S=I-C^T C/4 applies on the 112 code ports. The other eight ports +have zero S rows and zero C columns; the displayed S identity must not be +extended to all 120 ports. + +The omitted-centre base word has map Y -> Y+SX+Dh and preserves h. Let P +insert the eight C rows into the selected helpers. The program first forms +h1=h+PY, then sets Y1=Y-Dh1, then applies the base word, and finally adds +(59/4)PX to those helpers. The base step sends Y1 to Y+SX. This proves the +stated boundary composition. The sparse-row checker and the separate full +column checker also test the complete map. Since the program is linear, an +exact check of every input column proves the local scalar map for arbitrary +input values, including all arbitrary old helper values. + +## Full scalar count and unpriced obligations + +The base word has 19,449 scalar operations. Dirt correction has 11,326 +operations. Each of the two eight-row loads has 448 scalar additions. +Thus the implemented count is 19,449+11,326+448+448 = 31,671 scalar operations. +This is a scalar program count. It is not a native, physical or recursive +invoice, and it is not a claimed saving against another complete supplier. +The count of 11,326 was reproduced in the full historical receipts. The extra +boundary control independently recounts the base and both load supports. + +The saved boundary labels place preload and dirt correction in the zero frame +and postload in the full frame. The extra control checks these frame entries. +This does not prove a paid native or phase realization for the new operations. +No backward program, routed global controller, endpoint decoder, restoration +of the eight data owners, or full recursive cost is supplied. The construction +does not change the complete kappa calculation. + +## Resolved explanatory error + +The frozen historical review warns that correction from old helper values +would leave an extra DPY term. That term is the correct generic comparison, +but it is zero for this fixed selection. The reviewer propagated all eight +selected helper basis columns through the base word. Each column has zero Y +output, so the corresponding columns of D are zero and DP=0. + +The package README now states this fact and says that the historical warning +does not apply to these eight helpers. The frozen text remains unchanged. +The implemented updated-helper order is valid. It is not proved necessary +by a nonzero-error example here. This correction does not change the verified +endpoint or any executable input. The check source and exact result are +check_boundary_counts.py and BOUNDARY-COUNT-CONTROL.json in this review. + +## Verification performed + +The reviewer ran the driver in a fresh output directory with Python 3.14.7, +using isolated mode and PYTHONOPTIMIZE=1 in the environment. Each child uses +-E and runs sequentially, so the inherited environment does not disable its +assertions. The exact command, version, exit status and literal output are in +COMMAND.json, RESULT.json, stdout.log and stderr.log. The run exited 0 after +27.264490625006147 seconds. Its final line was: + +```text +PASS_LOCAL_EIGHT_FORM_CAPTURE 800 8 11326 +``` + +All four complete receipts matched their unchanged historical counterparts: + +1. Sparse-row check of the base, boundary composition and captured endpoint. +2. Separate 800-column base check and symbolic boundary composition. +3. Separate 800-column check of the complete captured endpoint and owner map. +4. The endpoint and covariance limitations check. + +The worker's separate fresh full replay produced the same complete aggregate +receipt. Both hashes in VALIDATION.json match the published candidate files. +All 17 frozen source/input files match their original workspace bytes, the +manifest hashes and the manifest sizes. SOURCE-AND-EVIDENCE-CHECK.json records +these comparisons. PORTABILITY.diff records the two portable script changes: +explicit input/output arguments replace absolute paths, and optimized-Python +guards were added. Their mathematical operations are unchanged. The other +two historical checkers are byte-exact copies. + +The extra boundary check ran with this command from the workspace root: + +```sh +python3 -I -B work/project-final-cleanup-20261022/reviews/local-capture/check_boundary_counts.py --package work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture --output work/project-final-cleanup-20261022/reviews/local-capture/BOUNDARY-COUNT-CONTROL.json +``` + +It returned PASS_BOUNDARY_COUNTS_AND_SELECTED_HELPER_D_COLUMN_CHECK. The +check uses the retained independent column interpreter on 120 centre-prefix +columns and eight helper columns. It is not an independent implementation +of that interpreter. The source and word hashes are in its receipt. + +## Endpoint limits and relation to current work + +The retained endpoint check establishes the stated binary chart covariance +with nonzero translations 15,15,23,39,71,135,263,15. It does not establish raw +commutation. It also rejects the proposed two-tap tensor inverse shortcut: +the tested Fourier character has true tensor inverse eigenvalue -1, while the +two-tap expression gives +1. The inherited geometry proof specifies the entry +X inverse frame as an interpretation, not a paid initial transform. These +facts prevent an unsupported physical endpoint or controller claim. + +The current native-centre-capture package at main commit +cef4b52f2a59009865bf8eabde1be3f159063703 uses 640 inputs and 16 centre records, +with different native endpoints. It is distinct from this 800-input, +eight-mixed-form endpoint. Its costs or theorems cannot be transferred by +adding the two bills. A bounded search of current research sources found +other 800-input base checks, but did not find this 59X/4 mixed capture claim. +This is not an exhaustive claim about every historical or open PR. The useful +contribution is the exact closed local program and its limits, not a claim +of a new general capture principle. + +## Attribution and publication boundary + +The retained notices credit Ali Romman with OpenAI Codex assistance for the +changed R560 words and composition. They preserve DreamingOfClouds' kernel +scripts, chafreaky's paid adapters and distinct-host construction, icekylinx's +split centres, and the earlier geometry sources. The README cites the PR #495 +lineage with a commit-pinned proof. The generated word and template are bound +by their own SHA256 values and are not claimed to equal a published generated +file. Original notices and source ledgers are unchanged. Agent assistance +and the absence of independent human review are stated. + +The parent coordinator must check the final PR body, commit-pinned links, +GitHub rendering and published readback. No PR, commit, worktree, deletion or +new research direction was made by this reviewer. There are no unresolved +material findings within the local scalar claim stated above. diff --git a/research/local-eight-form-capture/review/SOURCE-AND-EVIDENCE-CHECK.json b/research/local-eight-form-capture/review/SOURCE-AND-EVIDENCE-CHECK.json new file mode 100644 index 0000000000..ecd453778b --- /dev/null +++ b/research/local-eight-form-capture/review/SOURCE-AND-EVIDENCE-CHECK.json @@ -0,0 +1,163 @@ +{ + "status": "PASS", + "frozen_original_count": 17, + "checks": [ + { + "original": "work/complex-next/structural/check_hosted_capture.py", + "package": "historical/work/complex-next/structural/check_hosted_capture.py", + "sha256": "04a1f9434d3b1ba9b0744863522cfeab7b139d51f361ec2e887994ac7fdf9c12", + "bytes": 4711, + "original_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "original": "work/complex-next/structural/hosted-capture-receipt.json", + "package": "historical/work/complex-next/structural/hosted-capture-receipt.json", + "sha256": "61198fdd7d1b99e2384b50fd5666d48866c98bf61280df4694ac10f13dab0b12", + "bytes": 21400, + "original_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "original": "work/combined-pr/publication/research/e8-combined/NOTICE", + "package": "historical/work/combined-pr/publication/research/e8-combined/NOTICE", + "sha256": "7b41fa130dcd11e5972eed84e12f3499d80ea00e17d460f450fa8ddf39cc4951", + "bytes": 5054, + "original_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + }, + { + "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, + "original_equal": true, + "manifest_hash_equal": true, + "manifest_size_equal": true + } + ], + "worker_validation_hashes_match": true, + "worker_and_reviewer_full_receipts_equal": true, + "reviewer_receipt_sha256": "b52c403f5dc4b5d8e5cb40d94dbc3a223a113c441e6c35ff81c832ff12ea92e2", + "worker_validation_sha256": "d41054458c21fb1d8649cdda0066c84249ebc22cc0f300ea4951a202e3a431a6" +} diff --git a/research/local-eight-form-capture/review/check_boundary_counts.py b/research/local-eight-form-capture/review/check_boundary_counts.py new file mode 100644 index 0000000000..06dd861dbc --- /dev/null +++ b/research/local-eight-form-capture/review/check_boundary_counts.py @@ -0,0 +1,71 @@ +"""Check the local scalar bill and the selected columns of D.""" +import argparse +from fractions import Fraction as Q +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path + +parser = argparse.ArgumentParser() +parser.add_argument("--package", type=Path, required=True) +parser.add_argument("--output", type=Path, required=True) +args = parser.parse_args() +p = args.package.resolve() +script = p / "historical/work/doubling-architecture/rank-independent/live-capture/check.py" +spec = importlib.util.spec_from_file_location("capture_audit", script) +module = importlib.util.module_from_spec(spec) +spec.loader.exec_module(module) +word_path = p / "historical/work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz" +w = json.loads(gzip.decompress(word_path.read_bytes())) +ops = module.compile_ops(w["precondition"] + w["compensation"] + w["A"] + w["B"] + w["cleanup"]) +prefix = module.compile_ops(w["precondition"] + w["A"]) +n = 240 + w["R"] +centres = [[Q() for _ in range(120)] for _ in range(8)] +helpers = list(range(758, 750, -1)) +for column in range(120): + vector = [0] * n + vector[column] = 1 + module.apply(vector, prefix) + for i, centre in enumerate(w["centers"][:8]): + centres[i][column] = vector[centre] + +selected_d = [] +for helper in helpers: + vector = [0] * n + vector[helper] = 1 + module.apply(vector, ops) + selected_d.append(sum(bool(x) for x in vector[120:240])) +if selected_d != [0] * 8: + raise RuntimeError("Selected D columns are not zero") +supports = [sum(bool(x) for x in row) for row in centres] +if supports != [56] * 8 or not all(x in (-1, 0, 1) for row in centres for x in row): + raise RuntimeError("The centre support changed") +if (w["frames"][0] != [] or set(w["frames"][1]) != {1 << i for i in range(9)} + or set(w["start"][120:240]) != {0}): + raise RuntimeError("The boundary frames changed") + +receipt = { + "status": "PASS_BOUNDARY_COUNTS_AND_SELECTED_HELPER_D_COLUMN_CHECK", + "centre_row_support": supports, + "centre_coefficients": [-1, 0, 1], + "base_scalar_operations": len(ops), + "dirt_correction_operations": 11326, + "dirt_correction_count_source": "Reproduced complete historical receipts", + "preload_operations": sum(supports), + "postload_operations": sum(supports), + "total_scalar_operations": len(ops) + 11326 + 2 * sum(supports), + "all_Y_start_at_zero_frame": True, + "zero_and_full_frame_ids_verified": True, + "selected_helper_D_nonzero_counts": selected_d, + "DP_zero": True, + "clarification": "For these selected helpers D has zero columns. Using their old values does not add a nonzero DPY error. The implemented updated-helper order is valid.", + "scope": "Scalar operation count and order clarification only; no native or recursive cost invoice.", + "method": "Use the retained column interpreter on 120 centre-prefix and eight helper basis columns.", + "source_sha256": { + str(script.relative_to(p)): hashlib.sha256(script.read_bytes()).hexdigest(), + str(word_path.relative_to(p)): hashlib.sha256(word_path.read_bytes()).hexdigest(), + }, +} +args.output.write_text(json.dumps(receipt, indent=2) + "\n") +print(receipt["status"]) diff --git a/research/local-eight-form-capture/review/fresh-run/receipt.json b/research/local-eight-form-capture/review/fresh-run/receipt.json new file mode 100644 index 0000000000..f2a8f3ba7c --- /dev/null +++ b/research/local-eight-form-capture/review/fresh-run/receipt.json @@ -0,0 +1,2633 @@ +{ + "status": "PASS_LOCAL_EIGHT_FORM_CAPTURE", + "checks": [ + { + "status": "PASS_LOCAL_DIRTY_CAPTURE_AND_CURRENT_OWNER_INVENTORY", + "word_sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "template_sha256": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f", + "all_columns": 800, + "retained_forms": 8, + "centre_gram_multiplier": 56, + "decoder_factor": "C^t C / 4", + "dirty_correction_terms": 11326, + "local_source_and_target_map": "X unchanged; Y += S X", + "local_helper_map": "Selected h_i += C_i(59 X/4 + Y); all other helpers unchanged", + "owners": [ + { + "family": 600, + "capture_register": 758, + "roles": [ + { + "stage": 0, + "register": 758, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 643, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 758, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 120, + "route": [ + 1, + 5, + 0 + ] + }, + { + "stage": 6, + "register": 120, + "route": [ + 1, + 6, + 0 + ] + }, + { + "stage": 7, + "register": 359, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 359, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 359, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 601, + "capture_register": 757, + "roles": [ + { + "stage": 0, + "register": 757, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 642, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 757, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 121, + "route": [ + 1, + 5, + 1 + ] + }, + { + "stage": 6, + "register": 121, + "route": [ + 1, + 6, + 1 + ] + }, + { + "stage": 7, + "register": 358, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 358, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 358, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 602, + "capture_register": 756, + "roles": [ + { + "stage": 0, + "register": 756, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 641, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 756, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 122, + "route": [ + 1, + 5, + 2 + ] + }, + { + "stage": 6, + "register": 122, + "route": [ + 1, + 6, + 2 + ] + }, + { + "stage": 7, + "register": 357, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 357, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 357, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 603, + "capture_register": 755, + "roles": [ + { + "stage": 0, + "register": 755, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 640, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 755, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 123, + "route": [ + 1, + 5, + 3 + ] + }, + { + "stage": 6, + "register": 123, + "route": [ + 1, + 6, + 3 + ] + }, + { + "stage": 7, + "register": 356, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 356, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 356, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 604, + "capture_register": 754, + "roles": [ + { + "stage": 0, + "register": 754, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 639, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 754, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 124, + "route": [ + 1, + 5, + 4 + ] + }, + { + "stage": 6, + "register": 124, + "route": [ + 1, + 6, + 4 + ] + }, + { + "stage": 7, + "register": 355, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 355, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 355, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 605, + "capture_register": 753, + "roles": [ + { + "stage": 0, + "register": 753, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 638, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 753, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 125, + "route": [ + 1, + 5, + 5 + ] + }, + { + "stage": 6, + "register": 125, + "route": [ + 1, + 6, + 5 + ] + }, + { + "stage": 7, + "register": 354, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 354, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 354, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 606, + "capture_register": 752, + "roles": [ + { + "stage": 0, + "register": 752, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 637, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 752, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 126, + "route": [ + 1, + 5, + 6 + ] + }, + { + "stage": 6, + "register": 126, + "route": [ + 1, + 6, + 6 + ] + }, + { + "stage": 7, + "register": 353, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 353, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 353, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "family": 607, + "capture_register": 751, + "roles": [ + { + "stage": 0, + "register": 751, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 636, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 751, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 127, + "route": [ + 1, + 5, + 7 + ] + }, + { + "stage": 6, + "register": 127, + "route": [ + 1, + 6, + 7 + ] + }, + { + "stage": 7, + "register": 352, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 352, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 352, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + } + ], + "scope": "The local scalar map and current owner inventory are exact. The paid monomial adapters, endpoint decoder, scalar controller, owner restoration, and global cost are not verified." + }, + { + "status": "PASS_INDEPENDENT_EXACT_CAPTURE_MAP", + "source_sha256": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "method": "800 exact input columns; symbolic composition of boundary maps", + "columns": 800, + "scalar_operations": 19449, + "code_ports": 112, + "dirty_correction_terms": 11326, + "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." + }, + { + "status": "PASS_INDEPENDENT_800_COLUMN_DIRTY_CAPTURE", + "base_columns": 800, + "complete_capture_columns": 800, + "base_scalar_operations": 19449, + "code_ports": 112, + "center_gram": 56, + "dirt_correction_coefficients": 11326, + "retained_forms": 8, + "source_sha256": { + "work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f" + }, + "owners": [ + { + "helper": 758, + "family": 600, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 758, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 643, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 758, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 120, + "route": [ + 1, + 5, + 0 + ] + }, + { + "stage": 6, + "register": 120, + "route": [ + 1, + 6, + 0 + ] + }, + { + "stage": 7, + "register": 359, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 359, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 359, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 757, + "family": 601, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 757, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 642, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 757, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 121, + "route": [ + 1, + 5, + 1 + ] + }, + { + "stage": 6, + "register": 121, + "route": [ + 1, + 6, + 1 + ] + }, + { + "stage": 7, + "register": 358, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 358, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 358, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 756, + "family": 602, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 756, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 641, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 756, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 122, + "route": [ + 1, + 5, + 2 + ] + }, + { + "stage": 6, + "register": 122, + "route": [ + 1, + 6, + 2 + ] + }, + { + "stage": 7, + "register": 357, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 357, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 357, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 755, + "family": 603, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 755, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 640, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 755, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 123, + "route": [ + 1, + 5, + 3 + ] + }, + { + "stage": 6, + "register": 123, + "route": [ + 1, + 6, + 3 + ] + }, + { + "stage": 7, + "register": 356, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 356, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 356, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 754, + "family": 604, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 754, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 639, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 754, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 124, + "route": [ + 1, + 5, + 4 + ] + }, + { + "stage": 6, + "register": 124, + "route": [ + 1, + 6, + 4 + ] + }, + { + "stage": 7, + "register": 355, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 355, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 355, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 753, + "family": 605, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 753, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 638, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 753, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 125, + "route": [ + 1, + 5, + 5 + ] + }, + { + "stage": 6, + "register": 125, + "route": [ + 1, + 6, + 5 + ] + }, + { + "stage": 7, + "register": 354, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 354, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 354, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 752, + "family": 606, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 752, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 637, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 752, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 126, + "route": [ + 1, + 5, + 6 + ] + }, + { + "stage": 6, + "register": 126, + "route": [ + 1, + 6, + 6 + ] + }, + { + "stage": 7, + "register": 353, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 353, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 353, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + }, + { + "helper": 751, + "family": 607, + "entry_frame": "I", + "roles": [ + { + "stage": 0, + "register": 751, + "route": [ + 4, + 2, + 0, + 9, + 0, + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + ] + }, + { + "stage": 2, + "register": 636, + "route": [ + 4, + 2, + 9, + 9, + 0, + [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ] + ] + }, + { + "stage": 3, + "register": 751, + "route": [ + 4, + 2, + 18, + 9, + 0, + [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27 + ] + ] + }, + { + "stage": 5, + "register": 127, + "route": [ + 1, + 5, + 7 + ] + }, + { + "stage": 6, + "register": 127, + "route": [ + 1, + 6, + 7 + ] + }, + { + "stage": 7, + "register": 352, + "route": [ + 4, + 10, + 0, + 9, + 0, + [ + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65 + ] + ] + }, + { + "stage": 8, + "register": 352, + "route": [ + 4, + 10, + 9, + 9, + 0, + [ + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74 + ] + ] + }, + { + "stage": 10, + "register": 352, + "route": [ + 4, + 10, + 18, + 9, + 0, + [ + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83 + ] + ] + } + ] + } + ], + "scope": "Exact local label map and initial owner-frame inventory only. No modified global controller, endpoint uncompute, finite invoice, or new exponent is certified." + }, + { + "status": "PASS_ENDPOINT_COVARIANCE_AND_TENSOR_COUNTEREXAMPLE", + "chart_identity": "D_I P_sigma = T_translation P_sigma D_I", + "charts": [ + { + "family": 600, + "helper": 758, + "q": 7, + "translation": 15, + "strict_commutation": false + }, + { + "family": 601, + "helper": 757, + "q": 11, + "translation": 15, + "strict_commutation": false + }, + { + "family": 602, + "helper": 756, + "q": 19, + "translation": 23, + "strict_commutation": false + }, + { + "family": 603, + "helper": 755, + "q": 35, + "translation": 39, + "strict_commutation": false + }, + { + "family": 604, + "helper": 754, + "q": 67, + "translation": 71, + "strict_commutation": false + }, + { + "family": 605, + "helper": 753, + "q": 131, + "translation": 135, + "strict_commutation": false + }, + { + "family": 606, + "helper": 752, + "q": 259, + "translation": 263, + "strict_commutation": false + }, + { + "family": 607, + "helper": 751, + "q": 13, + "translation": 15, + "strict_commutation": false + } + ], + "source_X_factor_required": "D_p^-1", + "reason": "The initial C_q is a frame interpretation, not an extra paid initial transform.", + "false_tensor_shortcut_witness": { + "Fourier_character": [ + 1, + 1 + ], + "exact_D_inverse_tensor_2": "-1", + "proposed_aI_plus_b_translation_tensor_2": "1" + }, + "source_sha256": { + "work/next-track/complex/pipeline/retimed-4/complex/GLOBAL-TEMPLATE.json.gz": "7654c6c0ad6650a36acd95b3a1035e56c5190d7d693e8e824c7324176cdefd9f", + "work/next-track/complex/pipeline/retimed-4/split-centres/CANONICAL-WORD.json.gz": "1aea314c5f30fc9c957f0078ba0785cc6d047ae8872e75632bf6780ed82fb3be", + "work/next-track/complex/pipeline/full-source/research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + }, + "scope": "Seed phase identities and a counterexample to a proposed constant-size all-size shortcut. No endpoint cost or modified global controller is certified." + } + ], + "source_manifest_sha256": "7405268783ebe41df6ef22d44565047800668a1e33478339ae5a08673b168cff" +} diff --git a/research/local-eight-form-capture/review/stderr.log b/research/local-eight-form-capture/review/stderr.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/local-eight-form-capture/review/stdout.log b/research/local-eight-form-capture/review/stdout.log new file mode 100644 index 0000000000..edd02dda19 --- /dev/null +++ b/research/local-eight-form-capture/review/stdout.log @@ -0,0 +1,5 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture/primary.py --base /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/local-capture/fresh-run/work/next-track/complex/pipeline --output /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/local-capture/fresh-run/primary-result.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/local-eight-form-capture/dense_columns.py --base /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/local-capture/fresh-run/work/next-track/complex/pipeline +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/local-capture/fresh-run/work/doubling-architecture/rank-independent/live-capture/check.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/local-capture/fresh-run/work/doubling-architecture/rank-independent/live-capture/check_endpoint.py +PASS_LOCAL_EIGHT_FORM_CAPTURE 800 8 11326 diff --git a/research/local-eight-form-capture/verify.py b/research/local-eight-form-capture/verify.py new file mode 100644 index 0000000000..e475f1c971 --- /dev/null +++ b/research/local-eight-form-capture/verify.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +"""Repeat the fixed local capture and its independent scalar checks.""" +import argparse +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import sys +if not __debug__: + raise SystemExit("Run this verifier without -O. Historical sources use assert.") +ROOT = Path(__file__).resolve().parent +parser = argparse.ArgumentParser() +parser.add_argument("--build", type=Path, required=True) +args = parser.parse_args() +build = args.build.resolve() +if build.exists(): + raise SystemExit("The build directory exists.") +for item in json.loads((ROOT / "SOURCE-MANIFEST.json").read_text())["files"]: + if hashlib.sha256((ROOT / item["package"]).read_bytes()).hexdigest() != item["sha256"]: + raise SystemExit("Source hash: " + item["package"]) +shutil.copytree(ROOT / "historical", build) +pipeline = build / "work/next-track/complex/pipeline" +audit = Path("work/doubling-architecture/rank-independent/live-capture") +def run(name, command): + print("Run:", " ".join(map(str, command)), flush=True) + output = build / (name + ".stdout.log") + with output.open("w") as out, (build / (name + ".stderr.log")).open("w") as err: + subprocess.run(list(map(str, command)), stdout=out, stderr=err, check=True) + return output +run("primary", [sys.executable, "-E", "-B", ROOT / "primary.py", "--base", pipeline, + "--output", build / "primary-result.json"]) +dense = run("dense-columns", [sys.executable, "-E", "-B", ROOT / "dense_columns.py", "--base", pipeline]) +run("independent", [sys.executable, "-E", "-B", build / audit / "check.py"]) +run("endpoint-limits", [sys.executable, "-E", "-B", build / audit / "check_endpoint.py"]) +checks = [(build / "primary-result.json", "work/complex-next/structural/hosted-capture-receipt.json"), + (dense, "work/complex-next/structural/hamming-factor/capture-independent-receipt.json"), + (build / audit / "RESULT.json", str(audit / "RESULT.json")), + (build / audit / "ENDPOINT-RESULT.json", str(audit / "ENDPOINT-RESULT.json"))] +results = [] +for actual, expected in checks: + value = json.loads(actual.read_text()) + if value != json.loads((ROOT / "historical" / expected).read_text()): + raise SystemExit("Historical result differs: " + expected) + results.append(value) +result = {"status": "PASS_LOCAL_EIGHT_FORM_CAPTURE", "checks": results, + "source_manifest_sha256": hashlib.sha256((ROOT / "SOURCE-MANIFEST.json").read_bytes()).hexdigest()} +(build / "receipt.json").write_text(json.dumps(result, indent=2) + "\n") +print("PASS_LOCAL_EIGHT_FORM_CAPTURE 800 8 11326") diff --git a/research/prepared-growing-carrier/README.md b/research/prepared-growing-carrier/README.md new file mode 100644 index 0000000000..3109ae0958 --- /dev/null +++ b/research/prepared-growing-carrier/README.md @@ -0,0 +1,96 @@ +# A decoder with three prepared carriers and growing read frames + +This package gives one exact finite complex decoder on 11 streams of +64 values. Three carrier inputs start in prescribed line frames. Eight +target inputs start in the zero frame, which is the identity operator; +their values are arbitrary. In scalar coordinates the endpoint is +`X_i -> X_i` and `Y_t -> Y_t + sum_i bit_i(t) X_i`. +The word has 12 scalar ADDs, 27 paid children, rank mass 55, and no COPY. +This is a local construction. It gives no complete supplier or kappa gain. + +Read the [independent proof](historical/work/autonomous-kappa-run/growing-cycle-independent/PROOF.md) +and [literal word](historical/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json). +The three source ports are `e_0,e_2,e_4`; target `t` has port +`sum_i e_(2*i+bit_i(t))`. The canonical frame operator is `T_F`. +For physical input streams `h`, the carrier output is +`T_FULL T_(e_(2*i))^-1 h_i`. The target output is +`T_(q(t)^perp) (h_(3+t) + sum_i bit_i(t) T_(e_(2*i))^-1 h_i)`. +The carriers preserve their scalar values; their physical frames change. + +The [saved exit extension](historical/work/p518-next/complex/paired-five/add_growing_exits.py) +adds eight exact monomial adapters. Each target then ends in `F C_q^-1` +in place of its canonical hyperplane operator. These adapters add no +positive child rank. Their scalar and monomial operations still need a +payment in a complete supplier. The historical independent proof states +that these exits are absent from its base word; the separate saved exit +word and replay make that distinction explicit. + +The mechanism permits a carrier to grow after an earlier target is served. +A final read frame need not fit every earlier target. This supplies a +concrete counterexample to extending the saved +[fixed-frame delivery argument](historical/work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md) +to arbitrary growing read frames. It is not a lower bound on all decoders. +The source factory, initial frame preparation, routing, precision, storage, +owner controller and complete invoice remain outside this result. + +## Replay + +From this package directory, with Python 3.10 or later: + +```sh +python3 -B verify.py --build /tmp/prepared-growing-carrier-replay +``` + +The build path must not exist. Only the standard library is required. +The runner verifies all source hashes, copies the historical files into +the new build path, reconstructs both words, and compares their exact +bytes and receipts. It then runs the independent Gaussian-integer checker. +Python child processes ignore Python environment options; the wrappers +reject optimized Python because the saved sources use assertions. +The final line must be: + +```text +PASS_PREPARED_GROWING_CARRIER 704 55 8 +``` + +The independent check covers all 11 scalar input columns, all 1,472 +recipe basis columns, and all 704 whole-word basis columns and inverse +round trips. It checks exact global phase, common labels at each ADD, +compatibility of every pending target, the rank profile, and a phase +mutation. The exit generator checks all 512 target-adapter columns. +Complex linearity then gives the displayed endpoint for every input. +The independent checker shares the canonical frame definitions with the +producer. It imports neither the builder nor its lowering procedure. + +`SOURCE-MANIFEST.json` records the unchanged historical inputs. +`replay.py` is a portable copy of the original independent checker: +it replaces the old absolute input path and result path with explicit +arguments and adds an optimized-Python guard. The original is retained. +The only expected receipt difference is the checker's own source hash. +`replayed-receipt.json` and `replay.log` record the fresh cleanup replay. + +## Sources and related work + +The consumed exact Clifford definitions came through the historical +[PR #518](https://github.com/CrocSwap/integer-mult-bounds/pull/518) +source copy. Their bytes are also present in @icekylinx's +[PR #531](https://github.com/CrocSwap/integer-mult-bounds/pull/531), at +[this pinned source](https://github.com/CrocSwap/integer-mult-bounds/blob/e07a8a3f9f79c22113398a0c5dbbc7601f489b3e/research/direct-delivery504-global/vendor/clifford/clifford_exact.py). +The [notice](public-source/NOTICE.md) and [source ledger](public-source/SOURCES.json) +retain its predecessor credit. The local word, checks and packaging were +prepared with substantial OpenAI Codex and research-agent assistance under +the user's direction. No independent human review is claimed. + +The later [shared-carrier decoder](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/shared-carrier-decoder/README.md) +is a different P111 module with 452 dirty helpers and a nonzero COPY +endpoint. The paired-hypercube parity results concern the scalar source +factory, not this prepared three-carrier interface. No cost gain from +those different models is added to this result. + +## Open next questions + +Can a complete source factory supply these three carriers at the stated +initial frames and give a favorable cost after all other work is paid? +The first step is to compose an existing literal source factory with this +11-stream endpoint and check every dirty input column. No such composition +or cost certificate is included here. diff --git a/research/prepared-growing-carrier/SOURCE-MANIFEST.json b/research/prepared-growing-carrier/SOURCE-MANIFEST.json new file mode 100644 index 0000000000..0a2f51c7ef --- /dev/null +++ b/research/prepared-growing-carrier/SOURCE-MANIFEST.json @@ -0,0 +1,113 @@ +{ + "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "original": "work/autonomous-kappa-run/growing-cycle-independent/PROOF.md", + "package": "historical/work/autonomous-kappa-run/growing-cycle-independent/PROOF.md", + "sha256": "90f799133f1018e9ad6dbc8c232b1cc081170fc67c72fcd3ab1048dacc3093a8", + "bytes": 8107 + }, + { + "original": "work/autonomous-kappa-run/growing-cycle-independent/check.py", + "package": "historical/work/autonomous-kappa-run/growing-cycle-independent/check.py", + "sha256": "5bbb842f74b0dff8ecbe7756a0a83937d89c853dcf7813a406b51a782949b165", + "bytes": 12646 + }, + { + "original": "work/autonomous-kappa-run/growing-cycle-independent/FROZEN-WORD.json", + "package": "historical/work/autonomous-kappa-run/growing-cycle-independent/FROZEN-WORD.json", + "sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "bytes": 7971 + }, + { + "original": "work/autonomous-kappa-run/growing-cycle-independent/SOURCE-PINS.json", + "package": "historical/work/autonomous-kappa-run/growing-cycle-independent/SOURCE-PINS.json", + "sha256": "e5bc79fb24e4c4b9c4821db8130a97ee707d5148c58252147658306a0f177ed8", + "bytes": 1047 + }, + { + "original": "work/autonomous-kappa-run/growing-cycle-independent/VERIFICATION.json", + "package": "historical/work/autonomous-kappa-run/growing-cycle-independent/VERIFICATION.json", + "sha256": "f780153c2dbf4d269eca1847117fc849c002f6138dde8f43de354551e800aa08", + "bytes": 1003 + }, + { + "original": "work/autonomous-kappa-run/growing-cycle-independent/RESULT.json", + "package": "historical/work/autonomous-kappa-run/growing-cycle-independent/RESULT.json", + "sha256": "8f731e0d989273c00cd11fcb84e0da9bc8ef78412ce099656bd47b9b74008456", + "bytes": 3896 + }, + { + "original": "work/p518-next/complex/paired-five/growing_cycle.py", + "package": "historical/work/p518-next/complex/paired-five/growing_cycle.py", + "sha256": "fef1dc7c979b39235b6ef41396835f8778548e702b4e085aec10e3d5cdcafe58", + "bytes": 3754 + }, + { + "original": "work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json", + "package": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json", + "sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "bytes": 7971 + }, + { + "original": "work/p518-next/complex/paired-five/GROWING-CYCLE-RESULT.json", + "package": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-RESULT.json", + "sha256": "9800893733d820aaae969716d106c2aefcaee3a36d5a4b42d614a244af4dc6f7", + "bytes": 764 + }, + { + "original": "work/p518-next/complex/paired-five/add_growing_exits.py", + "package": "historical/work/p518-next/complex/paired-five/add_growing_exits.py", + "sha256": "67893edbbdfd380ccd9270954f9e76ae023c27787cad92bb0e5c6eaaafe997c6", + "bytes": 2012 + }, + { + "original": "work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-WORD.json", + "package": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-WORD.json", + "sha256": "88f5291e223d99a1d3a883b04f0caa7f7981e9a29086bd07fadc5694f95c241d", + "bytes": 10426 + }, + { + "original": "work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-RESULT.json", + "package": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-RESULT.json", + "sha256": "039950b8d9318c8bb4f61b31923e7843d241d0465a0a8705ba75003faed79854", + "bytes": 455 + }, + { + "original": "work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md", + "package": "historical/work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md", + "sha256": "a75a50aeae792a1b67c9b3b1cb5c95bfd6a3cf56cf1c3dfed304a7088118887e", + "bytes": 6162 + }, + { + "original": "work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py", + "package": "historical/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "bytes": 6824 + }, + { + "original": "work/p518-next/source/research/nodal-pair-async/NOTICE.md", + "package": "historical/work/p518-next/source/research/nodal-pair-async/NOTICE.md", + "sha256": "ec590608ddae58b227fe28040c29cd026699e2e5c26faad63da71a79dc50e159", + "bytes": 1818 + }, + { + "original": "work/p518-next/source/research/nodal-pair-async/SOURCES.json", + "package": "historical/work/p518-next/source/research/nodal-pair-async/SOURCES.json", + "sha256": "e82688d40483797d7fb5599cde3502018f9bf56acf66a803a7c6a497e885d7db", + "bytes": 3286 + }, + { + "original": "work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/NOTICE.md", + "package": "public-source/NOTICE.md", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1", + "bytes": 1451 + }, + { + "original": "work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/SOURCES.json", + "package": "public-source/SOURCES.json", + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f", + "bytes": 2592 + } + ] +} diff --git a/research/prepared-growing-carrier/VALIDATION.json b/research/prepared-growing-carrier/VALIDATION.json new file mode 100644 index 0000000000..4be3396b47 --- /dev/null +++ b/research/prepared-growing-carrier/VALIDATION.json @@ -0,0 +1,18 @@ +{ + "cwd": "/Users/aliromman/Projects/IntegerMultiplicationBounds", + "command": [ + "python3", + "-E", + "-B", + "work/project-final-cleanup-20261022/early-projects-audit/packages/prepared-growing-carrier/verify.py", + "--build", + "/tmp/prepared-growing-carrier-cleanup-20261023" + ], + "exit_code": 0, + "fresh_output_required": true, + "log": "replay.log", + "log_sha256": "bcbfb1e05a91fcf673568e6f7f06d7e837f0634e01daeccdfe59bb9c49382c56", + "receipt": "replayed-receipt.json", + "receipt_sha256": "150c3b181f82936bc55c6aa51fa7d704be3c0d08903bbde2d7b7d85a99d373f4", + "note": "Literal output is retained. Original source files are unchanged. No new discovery search ran." +} diff --git a/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/FROZEN-WORD.json b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/FROZEN-WORD.json new file mode 100644 index 0000000000..32d8ffb045 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/FROZEN-WORD.json @@ -0,0 +1 @@ +{"events":[["child",4,[],[1],1],["add",4,0,1,1,[1]],["child",6,[],[1],1],["add",6,0,1,1,[1]],["child",5,[],[4],1],["add",5,1,1,1,[4]],["child",9,[],[4],1],["add",9,1,1,1,[4]],["child",7,[],[16],1],["add",7,2,1,1,[16]],["child",8,[],[16],1],["add",8,2,1,1,[16]],["child",0,[1],[16,1],1],["child",8,[16],[16,1],1],["add",8,0,1,1,[16,1]],["child",10,[],[16,1],2],["add",10,0,1,1,[16,1]],["child",1,[4],[4,1],1],["child",6,[1],[4,1],1],["add",6,1,1,1,[4,1]],["child",1,[4,1],[16,4,1],1],["child",10,[16,1],[16,4,1],1],["add",10,1,1,1,[16,4,1]],["child",2,[16],[16,4],1],["child",9,[4],[16,4],1],["add",9,2,1,1,[16,4]],["child",2,[16,4],[16,4,1],1],["add",10,2,1,1,[16,4,1]],["child",0,[16,1],[32,16,8,4,2,1],4],["child",1,[16,4,1],[32,16,8,4,2,1],3],["child",2,[16,4,1],[32,16,8,4,2,1],3],["child",3,[],[32,17,8,5,2],5],["child",4,[1],[32,18,8,6,1],4],["child",5,[4],[32,17,9,4,2],4],["child",6,[4,1],[32,18,10,4,1],3],["child",7,[16],[33,16,8,5,2],4],["child",8,[16,1],[34,16,8,6,1],3],["child",9,[16,4],[33,16,9,4,2],3],["child",10,[16,4,1],[34,16,10,4,1],2]],"final_frames":[[32,16,8,4,2,1],[32,16,8,4,2,1],[32,16,8,4,2,1],[32,17,8,5,2],[32,18,8,6,1],[32,17,9,4,2],[32,18,10,4,1],[33,16,8,5,2],[34,16,8,6,1],[33,16,9,4,2],[34,16,10,4,1]],"h":6,"recipes":[{"new":[1],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[4],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,1],"old":[],"recipe":{"left":{"linear_Z4":[2,2,0,0,0,0],"matrix_rows":[1,4,8,16,2,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":2,"right":{"linear_Z4":[2,0,0,0,2,0],"matrix_rows":[1,16,2,4,8,32],"offset":3,"phase":2,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,17,8,5,2],"old":[],"recipe":{"left":{"linear_Z4":[3,2,3,2,2,0],"matrix_rows":[36,2,5,8,1,16],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":5,"right":{"linear_Z4":[1,2,3,2,0,2],"matrix_rows":[20,2,17,8,32,21],"offset":26,"phase":3,"quadratic_rows":[5,0,5,0,0,0]}}},{"new":[4,1],"old":[1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,1],"old":[1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,18,8,6,1],"old":[1],"recipe":{"left":{"linear_Z4":[3,3,2,2,0,0],"matrix_rows":[16,34,3,4,1,8],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":4,"right":{"linear_Z4":[0,1,3,2,0,2],"matrix_rows":[20,18,8,32,1,22],"offset":12,"phase":2,"quadratic_rows":[0,6,6,0,0,0]}}},{"new":[4,1],"old":[4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,4],"old":[4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,17,9,4,2],"old":[4],"recipe":{"left":{"linear_Z4":[3,2,3,2,0,0],"matrix_rows":[20,2,32,5,1,8],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":4,"right":{"linear_Z4":[1,2,0,3,0,2],"matrix_rows":[24,2,17,32,25,4],"offset":10,"phase":2,"quadratic_rows":[9,0,0,9,0,0]}}},{"new":[16,4,1],"old":[4,1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,18,10,4,1],"old":[4,1],"recipe":{"left":{"linear_Z4":[3,3,2,0,0,0],"matrix_rows":[8,18,32,3,1,4],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,1,0,3,0,2],"matrix_rows":[24,18,32,1,26,4],"offset":4,"phase":1,"quadratic_rows":[0,10,0,10,0,0]}}},{"new":[16,1],"old":[16],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,4],"old":[16],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[33,16,8,5,2],"old":[16],"recipe":{"left":{"linear_Z4":[3,2,3,2,0,0],"matrix_rows":[20,2,5,8,32,1],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":4,"right":{"linear_Z4":[1,2,3,2,0,0],"matrix_rows":[36,2,33,8,37,16],"offset":10,"phase":2,"quadratic_rows":[5,0,5,0,0,0]}}},{"new":[16,4,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,16,8,4,2,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[2,2,2,2,0,0],"matrix_rows":[16,1,2,4,32,8],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":4,"right":{"linear_Z4":[0,2,2,2,0,2],"matrix_rows":[2,4,8,32,1,16],"offset":15,"phase":0,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[34,16,8,6,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[3,3,2,0,0,0],"matrix_rows":[8,18,3,4,32,1],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,1,3,2,0,0],"matrix_rows":[36,34,8,1,38,16],"offset":4,"phase":1,"quadratic_rows":[0,6,6,0,0,0]}}},{"new":[16,4,1],"old":[16,4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[33,16,9,4,2],"old":[16,4],"recipe":{"left":{"linear_Z4":[3,2,3,0,0,0],"matrix_rows":[12,2,16,5,32,1],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":3,"right":{"linear_Z4":[1,2,0,3,0,0],"matrix_rows":[40,2,33,41,4,16],"offset":2,"phase":1,"quadratic_rows":[9,0,0,9,0,0]}}},{"new":[32,16,8,4,2,1],"old":[16,4,1],"recipe":{"left":{"linear_Z4":[2,2,2,0,0,0],"matrix_rows":[8,1,16,2,32,4],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,2,0,2,0,2],"matrix_rows":[2,8,32,1,4,16],"offset":7,"phase":3,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[34,16,10,4,1],"old":[16,4,1],"recipe":{"left":{"linear_Z4":[3,3,0,0,0,0],"matrix_rows":[4,10,16,3,32,1],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":2,"right":{"linear_Z4":[0,1,0,3,0,0],"matrix_rows":[40,34,1,42,4,16],"offset":0,"phase":0,"quadratic_rows":[0,10,0,10,0,0]}}}],"schedule":[[0,1],[0,3],[1,2],[1,6],[2,4],[2,5],[0,5],[0,7],[1,3],[1,7],[2,6],[2,7]],"source_ports":[1,4,16],"target_ports":[21,22,25,26,37,38,41,42]} \ No newline at end of file diff --git a/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/PROOF.md b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/PROOF.md new file mode 100644 index 0000000000..b9e4f7b8df --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/PROOF.md @@ -0,0 +1,174 @@ +# Independent growing-carrier decoder audit + +The frozen word is correct as a finite canonical-frame decoder. It +uses three persistent carriers, eight targets, twelve scalar reads, +and no copies. Its rank mass is 55. It is not a complete source +factory, controller, supplier, or integer multiplication witness. + +The input word hash is +15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5. +The source is the p518 paired-five experiment. The frame definitions +come from the pinned exact Clifford source with SHA-256 +2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962. +The checker does not import the builder or call lower_child. + +## Exact scope and output + +The ADDRESS space has six binary coordinates. The carrier ports are +e0, e2, and e4, encoded as 1, 4, and 16. Target t has port + + q(t) = sum_i e_(2i + bit_i(t)), 0 <= t < 8. + +The three carrier labels start at their port lines. Each target starts +at frame zero. All full labels have the canonical tag T. For a frame F, +its operator is the saved canonical_frame(6,F), denoted T_F. + +Each ADD has both operands at exactly the same full tag and frame. +Each child starts at its stated source label and implements +T_new T_old^-1. Thus the complete word has the common-frame invariant +h_r = T_label(r) x_r. Its scalar replay is + + X_i(final) = X_i(initial) + Y_t(final) = Y_t(initial) + sum_i bit_i(t) X_i(initial). + +This holds for arbitrary values in all eleven input streams. It does +not assume zero carriers or zero targets. The physical output is + + h_i(final) = T_FULL T_(ei)^-1 h_i(initial) + h_(3+t)(final) = T_(q(t)-perp) + (h_(3+t)(initial) + sum_i bit_i(t) T_(ei)^-1 h_i(initial)). + +The phrase "carrier values stay unchanged" refers to the scalar +coordinates X_i. Their physical frames change during the word. + +## Independent finite checks + +The checker rebuilds the scalar rows and full label run from the +literal events. It checks every pending target before each carrier +growth, every target hyperplane condition, and all final labels. + +It parses the serialized affine Gaussian monomials in each recipe. +Their binary matrices are invertible, their quadratic matrices are +symmetric, their phase fields are valid, and their diagonal parity +conditions hold. The executed order is right, rank-r Fourier child, +then left. Thus the recipe matrix is L F_r R. + +An integer Gaussian interpreter is separate from the producer's +interpreter. It compares each of the 23 recipes on all 64 basis +columns, including global phase: 1472 exact column checks. It then +replays the complete physical word on all 11 * 64 = 704 basis columns +and checks the displayed output formula. Its literal inverse restores +every one of those columns. A phase-plus-one mutant is rejected. + +These recipes and events are complex-linear. Equality on these basis +columns therefore gives equality on every complex input vector. The +canonical frame definitions are shared with the producer; the builder, +lowering procedure, and numerical state interpreter are not. + +## Cost and monotonicity + +There are 39 literal events: 12 ADDs and 27 paid child calls. There are +23 distinct child recipes. Those two child counts must not be confused. +The paid profile is + + rank 1: 15 + rank 2: 2 + rank 3: 5 + rank 4: 4 + rank 5: 1. + +Its mass is 15 + 4 + 15 + 16 + 5 = 55. Every frame move is a strict +nested ascent. There is no nonmonotone transport charge in this word. +The cost telescopes correctly for each register. Each carrier goes +from rank one to rank six and pays five. Each target goes from rank +zero to rank five and pays five. This also gives 3 * 5 + 8 * 5 = 55. + +This count starts with the stated three carrier lines already present. +It does not pay for producing those scalar carriers, reaching their +initial labels, scalar and monomial primitives, routing, precision, +storage, owner charts, or exceptional work. A complete construction +must pay those costs. + +## Why the fixed-cap terminal argument does not apply + +Carrier 0 reads target 3, whose port is 26, at frame span{1}. It later +grows to span{1,16} before its remaining reads. But 16 dot 26 is one, +so that later frame is not contained in target 3's endpoint hyperplane. +The earlier target is no longer pending. No future compatibility rule +is violated. + +Therefore a single final read cap cannot describe all reads of this +carrier. The fixed-cap terminal proof charges one terminal by the +capacity of one fixed cap. It cannot use that charge when one role +reads at several growing caps. + +The three-selector analogue of the old per-read charge is 2^d/8 at a +read cap of normal rank d. The actual summed carrier charges here are +3/2, 2, and 2. They are greater than the old one-unit budget for a +fixed terminal. This is a direct illustration of the changed premise, +not a new lower bound for all decoders. + +The word also uses caps smaller than the maximal common cap of its +served group. A four-target selector halfspace has maximal common cap +dimension three in this six-coordinate cube, while its initial reads +use a rank-one cap. Thus the later weaker argument about growing +maximal caps and cross-cube exclusion does not automatically cover +this word. No claim about all 141 channels follows from this example. + +## Endpoint adapters needed for a complete word + +For the three unit carrier ports, T_(ei) equals C_ei exactly. For all +eight target ports, however, + + T_(q-perp) != F C_q^-1. + +The signed tableaux differ, and the exact basis-column values also +differ. The raw canonical-frame word must not be called the legacy +data endpoint formula. The correction + + E_q = (F C_q^-1) T_(q-perp)^-1 + +has B-rank zero for each of the eight targets. It is a monomial +operator. An exit can therefore preserve the child-rank mass, but +its actual monomial operations must be emitted and charged. + +Use a distinct full post label with operator F C_q^-1. Emit the exit +as a relabel from the canonical q-perp label to that post label. +Check its complete serialized monomial, including phase. No later ADD +may use that target under its old canonical tag. These exits are not +in the frozen 39-event word. + +## Conditions for both parities and all H channels + +1. Produce the actual scalar channel rows. Check every main input + column, including arbitrary dirty helper columns. If a helper is + zero on entry, state and pay for that condition. The local decoder + accepts prepared carrier values; it does not produce them. +2. Give every carrier its actual starting frame and operator. A + schedule over abstract selector normals is not by itself an + ADDRESS embedding. Check even-weight normals and both parities in + the actual frame geometry and canonical operator family. +3. Use the actual target frames at the decoder cut. They need not be + zero in the full word. Every ADD must have a common full label. +4. Before each carrier growth, check compatibility with every still + pending target in the full schedule. Include targets in other + cubes. Removing served targets permits growth; it does not permit + incompatible future reads. +5. State each required signed channel coefficient. Check that each + delivery occurs exactly once with that coefficient. Both parity + halves must give the required complete scalar matrix. +6. Compile every actual transition, including its global phase, and + count every emitted call and primitive. Use endpoint telescoping + only on nested monotone paths. Charge general frame transport by + its actual recipe. +7. Emit the data and helper endpoint adapters with explicit tags. + Check the complete endpoint, restoration or retained helper block, + and all cross blocks. Do not infer a permitted helper clear from + the local decoder. +8. Build the full controller and owner schedule. Count persistent + carriers, changing invocation lifetimes, residual widths, + spectators, bank calls, and initialization. Only the resulting + paid full profile can be compared with the live frontier. + +The three-carrier mechanism survives independent exact replay. The +extension obligations above remain separate from this finite result. diff --git a/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/RESULT.json b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/RESULT.json new file mode 100644 index 0000000000..56e1586037 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/RESULT.json @@ -0,0 +1,206 @@ +{ + "status": "PASS_INDEPENDENT_GROWING_CAP_WORD", + "word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "clifford_source_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "builder_imported": false, + "lower_child_called": false, + "canonical_frame_definitions_shared": true, + "separate_integer_gaussian_interpreter": true, + "scalar_input_columns": 11, + "recipe_basis_columns": 1472, + "whole_physical_basis_columns": 704, + "inverse_round_trip_columns": 704, + "all_moves_strict_nested_ascents": true, + "full_common_labels_at_adds": true, + "future_targets_compatible_before_each_source_move": true, + "sources_unchanged_in_scalar_replay": true, + "target_rows_exact": true, + "literal_events": 39, + "scalar_add_reads": 12, + "paid_child_calls": 27, + "distinct_recipe_lowerings": 23, + "paid_profile": { + "1": 15, + "2": 2, + "3": 5, + "4": 4, + "5": 1 + }, + "paid_rank_mass": 55, + "paid_rank_by_register": [ + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5 + ], + "copies": 0, + "source_line_bridge_equals_C_e": [ + true, + true, + true + ], + "target_endpoint_bridges": [ + { + "q": 21, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 22, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 25, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 26, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 37, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 38, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 41, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 42, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + } + ], + "target_exit_adapters_in_frozen_word": false, + "fixed_last_cap_counterexamples": [ + { + "source": 0, + "target": 1, + "q": 22, + "read_cap": [ + 1 + ], + "last_read_cap": [ + 16, + 1 + ] + }, + { + "source": 0, + "target": 3, + "q": 26, + "read_cap": [ + 1 + ], + "last_read_cap": [ + 16, + 1 + ] + }, + { + "source": 1, + "target": 2, + "q": 25, + "read_cap": [ + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 1, + "target": 6, + "q": 41, + "read_cap": [ + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 1, + "target": 3, + "q": 26, + "read_cap": [ + 4, + 1 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 4, + "q": 37, + "read_cap": [ + 16 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 5, + "q": 38, + "read_cap": [ + 16 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 6, + "q": 41, + "read_cap": [ + 16, + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + } + ], + "three_selector_analogue_charges_per_carrier": [ + "3/2", + "2", + "2" + ], + "phase_mutant_rejected": true, + "scope": "One finite canonical-frame decoder. No complete scalar factory, legacy exit adapter word, global owner controller, supplier or kappa gain is checked.", + "checker_sha256": "5bbb842f74b0dff8ecbe7756a0a83937d89c853dcf7813a406b51a782949b165" +} diff --git a/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/SOURCE-PINS.json b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/SOURCE-PINS.json new file mode 100644 index 0000000000..59391d0d40 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/SOURCE-PINS.json @@ -0,0 +1,18 @@ +{ + "producer_word": { + "path": "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json", + "sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5" + }, + "producer_builder": { + "path": "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/p518-next/complex/paired-five/growing_cycle.py", + "sha256": "fef1dc7c979b39235b6ef41396835f8778548e702b4e085aec10e3d5cdcafe58" + }, + "fixed_cap_proof": { + "path": "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md", + "sha256": "a75a50aeae792a1b67c9b3b1cb5c95bfd6a3cf56cf1c3dfed304a7088118887e" + }, + "frame_definitions": { + "path": "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } +} diff --git a/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/VERIFICATION.json b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/VERIFICATION.json new file mode 100644 index 0000000000..9579f30fe5 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/VERIFICATION.json @@ -0,0 +1,20 @@ +{ + "status": "PASS", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "check.py" + ], + "cwd": "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/autonomous-kappa-run/growing-cycle-independent", + "returncode": 0, + "duration_seconds": 1.3994609168730676, + "source_sha256": { + "check.py": "5bbb842f74b0dff8ecbe7756a0a83937d89c853dcf7813a406b51a782949b165", + "PROOF.md": "90f799133f1018e9ad6dbc8c232b1cc081170fc67c72fcd3ab1048dacc3093a8", + "FROZEN-WORD.json": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "SOURCE-PINS.json": "e5bc79fb24e4c4b9c4821db8130a97ee707d5148c58252147658306a0f177ed8" + }, + "result_sha256": "8f731e0d989273c00cd11fcb84e0da9bc8ef78412ce099656bd47b9b74008456", + "log_sha256": "8f731e0d989273c00cd11fcb84e0da9bc8ef78412ce099656bd47b9b74008456", + "scope": "Finite canonical-frame decoder and exact phases. No complete source factory, exit-adapter word, global controller or supplier." +} diff --git a/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/check.py b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/check.py new file mode 100644 index 0000000000..42011a79ef --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/autonomous-kappa-run/growing-cycle-independent/check.py @@ -0,0 +1,304 @@ +"""Check the frozen growing-carrier word with exact Gaussian arithmetic. + +Read the saved recipes. Do not import the builder or call its lowering +procedure. Replay every phase basis column and every full word column. +""" + +from collections import Counter +from fractions import Fraction as Q +import hashlib +import importlib.util +import json +from pathlib import Path +import sys + + +HERE = Path(__file__).resolve().parent +SOURCE = Path('/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/p518-next') +WORD = HERE / 'FROZEN-WORD.json' +CLIFFORD = SOURCE / 'source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py' +EXPECTED_WORD = '15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5' +EXPECTED_CLIFFORD = '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962' +raw = WORD.read_bytes() +assert hashlib.sha256(raw).hexdigest() == EXPECTED_WORD +assert hashlib.sha256(CLIFFORD.read_bytes()).hexdigest() == EXPECTED_CLIFFORD +w = json.loads(raw) +spec = importlib.util.spec_from_file_location('growing_frame_definitions', CLIFFORD) +cx = importlib.util.module_from_spec(spec) +sys.modules[spec.name] = cx +spec.loader.exec_module(cx) +H, N, COUNT = w['h'], 1 << w['h'], len(w['final_frames']) +assert (H, COUNT) == (6, 11) +assert w['source_ports'] == [1 << (2 * i) for i in range(3)] +assert w['target_ports'] == [sum(1 << (2 * i + ((t >> i) & 1)) for i in range(3)) for t in range(8)] + + +def span(vectors): + points = {0} + for v in vectors: + assert 0 <= v < N + points |= {x ^ v for x in points} + return frozenset(points) + + +def dimension(vectors): + return len(span(vectors)).bit_length() - 1 + + +def invert(rows): + a = [r | (1 << (H + i)) for i, r in enumerate(rows)] + for j in range(H): + i = next(i for i in range(j, H) if (a[i] >> j) & 1) + a[i], a[j] = a[j], a[i] + for i in range(H): + if i != j and (a[i] >> j) & 1: + a[i] ^= a[j] + assert [r & (N - 1) for r in a] == [1 << i for i in range(H)] + return tuple(r >> H for r in a) + + +def monomial(record): + g = tuple(record['matrix_rows']) + q = tuple(record['quadratic_rows']) + alpha = tuple(record['linear_Z4']) + assert len(g) == len(q) == len(alpha) == H + assert dimension(g) == H and 0 <= record['offset'] < N + assert all(((q[i] >> j) & 1) == ((q[j] >> i) & 1) for i in range(H) for j in range(H)) + assert all(alpha[i] % 2 == ((q[i] >> i) & 1) for i in range(H)) + assert 0 <= record['phase'] < 4 + return [('D', q, alpha), ('P', g), ('X', record['offset']), ('phase', record['phase'])] + + +def normalize(v, denominator): + if not any(a or b for a, b in v): + return ((0, 0),) * N, 0 + while denominator and all(a % 2 == b % 2 == 0 for a, b in v): + v = tuple((a // 2, b // 2) for a, b in v) + denominator -= 1 + return tuple(v), denominator + + +permutations, phases = {}, {} + + +def apply(circuit, state): + v, denominator = state + if not any(a or b for a, b in v): + return state + for e in circuit: + tag = e[0] + if tag == 'P': + key = tuple(e[1]) + if key not in permutations: + permutations[key] = [sum(((row & x).bit_count() % 2) << i for i, row in enumerate(key)) for x in range(N)] + out = [(0, 0)] * N + for x, y in enumerate(permutations[key]): + out[y] = v[x] + v = out + elif tag == 'X': + v = [v[x ^ e[1]] for x in range(N)] + elif tag in ('D', 'phase'): + if tag == 'phase': + powers = [e[1] % 4] * N + else: + key = tuple(e[1]), tuple(e[2]) + if key not in phases: + phases[key] = [(sum(e[2][i] for i in range(H) if (x >> i) & 1) + + 2 * sum((e[1][i] >> j) & 1 for i in range(H) for j in range(i + 1, H) + if ((x >> i) & 1) and ((x >> j) & 1))) % 4 for x in range(N)] + powers = phases[key] + units = ((1, 0), (0, 1), (-1, 0), (0, -1)) + v = [(a * units[p][0] - b * units[p][1], a * units[p][1] + b * units[p][0]) + for (a, b), p in zip(v, powers)] + elif tag == 'C': + q, sign = e[1:] + out = [] + for x, (a, b) in enumerate(v): + c, d = v[x ^ q] + out.append((a - sign * b + c + sign * d, b + sign * a + d - sign * c)) + v = out + denominator += 1 + else: + raise AssertionError(e) + return normalize(v, denominator) + + +def adjoint(circuit): + out = [] + for e in reversed(circuit): + if e[0] == 'P': + out.append(('P', invert(tuple(e[1])))) + elif e[0] == 'D': + out.append(('D', tuple(e[1]), tuple((-x) % 4 for x in e[2]))) + elif e[0] == 'C': + out.append(('C', e[1], -e[2])) + elif e[0] == 'phase': + out.append(('phase', (-e[1]) % 4)) + else: + assert e[0] == 'X' + out.append(tuple(e)) + return out + + +def plus(a, b, coefficient=Q(1)): + assert coefficient.denominator & (coefficient.denominator - 1) == 0 + extra = coefficient.denominator.bit_length() - 1 + power = max(a[1], b[1] + extra) + aa, bb = 1 << (power - a[1]), coefficient.numerator << (power - b[1] - extra) + return normalize([(aa * x + bb * u, aa * y + bb * z) for (x, y), (u, z) in zip(a[0], b[0])], power) + + +zero = (((0, 0),) * N, 0) +basis = [(tuple((int(j == col), 0) for j in range(N)), 0) for col in range(N)] +initial = [(q,) for q in w['source_ports']] + [()] * 8 +frames = {tuple(f) for f in initial + [tuple(f) for f in w['final_frames']]} +for e in w['events']: + frames |= {tuple(e[2]), tuple(e[3])} if e[0] == 'child' else {tuple(e[-1])} +assert all(dimension(f) == len(f) for f in frames) +canonical = {f: cx.canonical_frame(H, f).circuit for f in frames} +recipes = {} +for item in w['recipes']: + old, new, r = tuple(item['old']), tuple(item['new']), item['recipe'] + assert (old, new) not in recipes + assert span(old) < span(new) + assert r['rank'] == len(new) - len(old) + serialized = monomial(r['right']) + [('C', 1 << i, 1) for i in range(r['rank'])] + monomial(r['left']) + expected = adjoint(canonical[old]) + canonical[new] + for state in basis: + assert apply(serialized, state) == apply(expected, state), ('full recipe column', old, new) + recipes[old, new] = serialized + +labels = [('T', f) for f in initial] +rows = [{r: Q(1)} for r in range(COUNT)] +pending = [{t for t, q in enumerate(w['target_ports']) if not (q & u).bit_count() % 2} for u in w['source_ports']] +paid = Counter() +per_register = [0] * COUNT +read_caps = [[] for _ in w['source_ports']] +seen_reads, used = [], set() +for e in w['events']: + if e[0] == 'child': + _, r, old, new, charged = e + old, new = tuple(old), tuple(new) + assert labels[r] == ('T', old) + assert span(old) < span(new) and charged == len(new) - len(old) + assert (old, new) in recipes + if r < 3: + assert all(not (u & w['target_ports'][t]).bit_count() % 2 for u in new for t in pending[r]) + else: + assert all(not (u & w['target_ports'][r - 3]).bit_count() % 2 for u in new) + labels[r] = ('T', new) + paid[charged] += 1 + per_register[r] += charged + used.add((old, new)) + else: + assert e[0] == 'add' + _, t, s, num, den, f = e + assert 3 <= t < COUNT and 0 <= s < 3 + assert labels[t] == labels[s] == ('T', tuple(f)) + assert t - 3 in pending[s] + pending[s].remove(t - 3) + seen_reads.append([s, t - 3]) + read_caps[s].append((t - 3, tuple(f))) + for col, value in rows[s].items(): + rows[t][col] = rows[t].get(col, Q(0)) + Q(num, den) * value +assert not any(pending) and seen_reads == w['schedule'] +assert used == set(recipes) and len(recipes) == 23 +assert [f for _, f in labels] == [tuple(f) for f in w['final_frames']] +for r in range(COUNT): + expected = {r: Q(1)} + if r >= 3: + expected.update({s: Q(1) for s in range(3) if (r - 3) >> s & 1}) + assert rows[r] == expected +for t, q in enumerate(w['target_ports']): + assert span(w['final_frames'][3 + t]) == frozenset(x for x in range(N) if not (x & q).bit_count() % 2) +assert per_register == [5] * 11 +assert sum(r * n for r, n in paid.items()) == 55 + + +def replay(state, inverse=False): + state = list(state) + events = list(reversed(w['events'])) if inverse else w['events'] + for e in events: + if e[0] == 'child': + circuit = recipes[tuple(e[2]), tuple(e[3])] + state[e[1]] = apply(adjoint(circuit) if inverse else circuit, state[e[1]]) + else: + q = Q(e[3], e[4]) * (-1 if inverse else 1) + state[e[1]] = plus(state[e[1]], state[e[2]], q) + return state + + +for r in range(COUNT): + for vector in basis: + start = [zero] * COUNT + start[r] = vector + actual = replay(start) + logical = [apply(adjoint(canonical[initial[s]]), start[s]) for s in range(COUNT)] + wanted = [] + for output in range(COUNT): + value = zero + for col, q in rows[output].items(): + value = plus(value, logical[col], q) + wanted.append(apply(canonical[tuple(w['final_frames'][output])], value)) + assert actual == wanted, ('full physical column', r) + assert replay(actual, True) == start, ('inverse physical column', r) + +source_bridges = [] +for q in w['source_ports']: + assert all(apply(canonical[(q,)], v) == apply([('C', q, 1)], v) for v in basis) + source_bridges.append(True) +target_bridges = [] +for t, q in enumerate(w['target_ports']): + cap = tuple(w['final_frames'][3 + t]) + goal = cx.cgate(H, q).adjoint().then(cx.fourier(H)) + endpoint = cx.canonical_frame(H, cap) + correction = endpoint.adjoint().then(goal) + rank = cx.rank([x for x, z, p in correction.tab[H:]]) + equal = all(apply(canonical[cap], v) == apply(goal.circuit, v) for v in basis) + assert not equal and rank == 0 + target_bridges.append({'q': q, 'canonical_equals_legacy_endpoint': equal, 'exit_correction_rank': rank}) + +last_read_cap = [caps[-1][1] for caps in read_caps] +invalid_fixed_caps = [] +for source, caps in enumerate(read_caps): + for t, cap in caps: + if any((u & w['target_ports'][t]).bit_count() % 2 for u in last_read_cap[source]): + invalid_fixed_caps.append({'source': source, 'target': t, 'q': w['target_ports'][t], + 'read_cap': cap, 'last_read_cap': last_read_cap[source]}) +assert invalid_fixed_caps +charges = [sum(Q(1 << len(cap), 8) for t, cap in caps) for caps in read_caps] +assert charges == [Q(3, 2), Q(2), Q(2)] +first = w['recipes'][0] +mutant = list(recipes[tuple(first['old']), tuple(first['new'])]) + [('phase', 1)] +assert apply(mutant, basis[0]) != apply(recipes[tuple(first['old']), tuple(first['new'])], basis[0]) + +result = { + 'status': 'PASS_INDEPENDENT_GROWING_CAP_WORD', + 'word_sha256': EXPECTED_WORD, 'clifford_source_sha256': EXPECTED_CLIFFORD, + 'builder_imported': False, 'lower_child_called': False, + 'canonical_frame_definitions_shared': True, + 'separate_integer_gaussian_interpreter': True, + 'scalar_input_columns': COUNT, + 'recipe_basis_columns': len(recipes) * N, + 'whole_physical_basis_columns': COUNT * N, + 'inverse_round_trip_columns': COUNT * N, + 'all_moves_strict_nested_ascents': True, + 'full_common_labels_at_adds': True, + 'future_targets_compatible_before_each_source_move': True, + 'sources_unchanged_in_scalar_replay': True, + 'target_rows_exact': True, + 'literal_events': len(w['events']), 'scalar_add_reads': len(seen_reads), + 'paid_child_calls': sum(paid.values()), 'distinct_recipe_lowerings': len(recipes), + 'paid_profile': dict(sorted(paid.items())), 'paid_rank_mass': 55, + 'paid_rank_by_register': per_register, 'copies': 0, + 'source_line_bridge_equals_C_e': source_bridges, + 'target_endpoint_bridges': target_bridges, + 'target_exit_adapters_in_frozen_word': False, + 'fixed_last_cap_counterexamples': invalid_fixed_caps, + 'three_selector_analogue_charges_per_carrier': list(map(str, charges)), + 'phase_mutant_rejected': True, + 'scope': 'One finite canonical-frame decoder. No complete scalar factory, legacy exit adapter word, global owner controller, supplier or kappa gain is checked.', +} +result['checker_sha256'] = hashlib.sha256(Path(__file__).read_bytes()).hexdigest() +(HERE / 'RESULT.json').write_text(json.dumps(result, indent=2) + '\n') +print(json.dumps(result, indent=2)) diff --git a/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-RESULT.json b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-RESULT.json new file mode 100644 index 0000000000..bfcfeb638c --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-RESULT.json @@ -0,0 +1,11 @@ +{ + "status": "PASS_EXACT_MONOMIAL_EXITS", + "original_word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "word_sha256": "88f5291e223d99a1d3a883b04f0caa7f7981e9a29086bd07fadc5694f95c241d", + "exits": 8, + "rank_zero_exits": 8, + "address_columns_checked": 512, + "full_global_phase": true, + "extra_paid_rank": 0, + "scope": "The finite decoder has the stated legacy exits. It is not a full factory or parent supplier." +} diff --git a/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-WORD.json b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-WORD.json new file mode 100644 index 0000000000..39decd6633 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-WORD.json @@ -0,0 +1 @@ +{"endpoint_convention":{"scalar_rows":"The scalar row is stated before the address operator.","sources":"F","targets":"F C_q^-1"},"events":[["child",4,[],[1],1],["add",4,0,1,1,[1]],["child",6,[],[1],1],["add",6,0,1,1,[1]],["child",5,[],[4],1],["add",5,1,1,1,[4]],["child",9,[],[4],1],["add",9,1,1,1,[4]],["child",7,[],[16],1],["add",7,2,1,1,[16]],["child",8,[],[16],1],["add",8,2,1,1,[16]],["child",0,[1],[16,1],1],["child",8,[16],[16,1],1],["add",8,0,1,1,[16,1]],["child",10,[],[16,1],2],["add",10,0,1,1,[16,1]],["child",1,[4],[4,1],1],["child",6,[1],[4,1],1],["add",6,1,1,1,[4,1]],["child",1,[4,1],[16,4,1],1],["child",10,[16,1],[16,4,1],1],["add",10,1,1,1,[16,4,1]],["child",2,[16],[16,4],1],["child",9,[4],[16,4],1],["add",9,2,1,1,[16,4]],["child",2,[16,4],[16,4,1],1],["add",10,2,1,1,[16,4,1]],["child",0,[16,1],[32,16,8,4,2,1],4],["child",1,[16,4,1],[32,16,8,4,2,1],3],["child",2,[16,4,1],[32,16,8,4,2,1],3],["child",3,[],[32,17,8,5,2],5],["child",4,[1],[32,18,8,6,1],4],["child",5,[4],[32,17,9,4,2],4],["child",6,[4,1],[32,18,10,4,1],3],["child",7,[16],[33,16,8,5,2],4],["child",8,[16,1],[34,16,8,6,1],3],["child",9,[16,4],[33,16,9,4,2],3],["child",10,[16,4,1],[34,16,10,4,1],2],["monomial_exit",3,0],["monomial_exit",4,1],["monomial_exit",5,2],["monomial_exit",6,3],["monomial_exit",7,4],["monomial_exit",8,5],["monomial_exit",9,6],["monomial_exit",10,7]],"exit_adapters":[{"port":21,"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,5,8,17,32],"offset":1,"phase":3,"quadratic_rows":[0,0,0,0,0,0]},"rank":0,"right":null},"stream":3,"target_circuit":[["C",21,-1],["C",1,1],["C",2,1],["C",4,1],["C",8,1],["C",16,1],["C",32,1]]},{"port":22,"recipe":{"left":{"linear_Z4":[0,2,0,0,0,0],"matrix_rows":[1,2,6,8,18,32],"offset":2,"phase":3,"quadratic_rows":[0,0,0,0,0,0]},"rank":0,"right":null},"stream":4,"target_circuit":[["C",22,-1],["C",1,1],["C",2,1],["C",4,1],["C",8,1],["C",16,1],["C",32,1]]},{"port":25,"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,9,17,32],"offset":1,"phase":3,"quadratic_rows":[0,0,0,0,0,0]},"rank":0,"right":null},"stream":5,"target_circuit":[["C",25,-1],["C",1,1],["C",2,1],["C",4,1],["C",8,1],["C",16,1],["C",32,1]]},{"port":26,"recipe":{"left":{"linear_Z4":[0,2,0,0,0,0],"matrix_rows":[1,2,4,10,18,32],"offset":2,"phase":3,"quadratic_rows":[0,0,0,0,0,0]},"rank":0,"right":null},"stream":6,"target_circuit":[["C",26,-1],["C",1,1],["C",2,1],["C",4,1],["C",8,1],["C",16,1],["C",32,1]]},{"port":37,"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,5,8,16,33],"offset":1,"phase":3,"quadratic_rows":[0,0,0,0,0,0]},"rank":0,"right":null},"stream":7,"target_circuit":[["C",37,-1],["C",1,1],["C",2,1],["C",4,1],["C",8,1],["C",16,1],["C",32,1]]},{"port":38,"recipe":{"left":{"linear_Z4":[0,2,0,0,0,0],"matrix_rows":[1,2,6,8,16,34],"offset":2,"phase":3,"quadratic_rows":[0,0,0,0,0,0]},"rank":0,"right":null},"stream":8,"target_circuit":[["C",38,-1],["C",1,1],["C",2,1],["C",4,1],["C",8,1],["C",16,1],["C",32,1]]},{"port":41,"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,9,16,33],"offset":1,"phase":3,"quadratic_rows":[0,0,0,0,0,0]},"rank":0,"right":null},"stream":9,"target_circuit":[["C",41,-1],["C",1,1],["C",2,1],["C",4,1],["C",8,1],["C",16,1],["C",32,1]]},{"port":42,"recipe":{"left":{"linear_Z4":[0,2,0,0,0,0],"matrix_rows":[1,2,4,10,16,34],"offset":2,"phase":3,"quadratic_rows":[0,0,0,0,0,0]},"rank":0,"right":null},"stream":10,"target_circuit":[["C",42,-1],["C",1,1],["C",2,1],["C",4,1],["C",8,1],["C",16,1],["C",32,1]]}],"final_frames":[[32,16,8,4,2,1],[32,16,8,4,2,1],[32,16,8,4,2,1],[32,17,8,5,2],[32,18,8,6,1],[32,17,9,4,2],[32,18,10,4,1],[33,16,8,5,2],[34,16,8,6,1],[33,16,9,4,2],[34,16,10,4,1]],"h":6,"recipes":[{"new":[1],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[4],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,1],"old":[],"recipe":{"left":{"linear_Z4":[2,2,0,0,0,0],"matrix_rows":[1,4,8,16,2,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":2,"right":{"linear_Z4":[2,0,0,0,2,0],"matrix_rows":[1,16,2,4,8,32],"offset":3,"phase":2,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,17,8,5,2],"old":[],"recipe":{"left":{"linear_Z4":[3,2,3,2,2,0],"matrix_rows":[36,2,5,8,1,16],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":5,"right":{"linear_Z4":[1,2,3,2,0,2],"matrix_rows":[20,2,17,8,32,21],"offset":26,"phase":3,"quadratic_rows":[5,0,5,0,0,0]}}},{"new":[4,1],"old":[1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,1],"old":[1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,18,8,6,1],"old":[1],"recipe":{"left":{"linear_Z4":[3,3,2,2,0,0],"matrix_rows":[16,34,3,4,1,8],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":4,"right":{"linear_Z4":[0,1,3,2,0,2],"matrix_rows":[20,18,8,32,1,22],"offset":12,"phase":2,"quadratic_rows":[0,6,6,0,0,0]}}},{"new":[4,1],"old":[4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,4],"old":[4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,17,9,4,2],"old":[4],"recipe":{"left":{"linear_Z4":[3,2,3,2,0,0],"matrix_rows":[20,2,32,5,1,8],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":4,"right":{"linear_Z4":[1,2,0,3,0,2],"matrix_rows":[24,2,17,32,25,4],"offset":10,"phase":2,"quadratic_rows":[9,0,0,9,0,0]}}},{"new":[16,4,1],"old":[4,1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,18,10,4,1],"old":[4,1],"recipe":{"left":{"linear_Z4":[3,3,2,0,0,0],"matrix_rows":[8,18,32,3,1,4],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,1,0,3,0,2],"matrix_rows":[24,18,32,1,26,4],"offset":4,"phase":1,"quadratic_rows":[0,10,0,10,0,0]}}},{"new":[16,1],"old":[16],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,4],"old":[16],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[33,16,8,5,2],"old":[16],"recipe":{"left":{"linear_Z4":[3,2,3,2,0,0],"matrix_rows":[20,2,5,8,32,1],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":4,"right":{"linear_Z4":[1,2,3,2,0,0],"matrix_rows":[36,2,33,8,37,16],"offset":10,"phase":2,"quadratic_rows":[5,0,5,0,0,0]}}},{"new":[16,4,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,16,8,4,2,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[2,2,2,2,0,0],"matrix_rows":[16,1,2,4,32,8],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":4,"right":{"linear_Z4":[0,2,2,2,0,2],"matrix_rows":[2,4,8,32,1,16],"offset":15,"phase":0,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[34,16,8,6,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[3,3,2,0,0,0],"matrix_rows":[8,18,3,4,32,1],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,1,3,2,0,0],"matrix_rows":[36,34,8,1,38,16],"offset":4,"phase":1,"quadratic_rows":[0,6,6,0,0,0]}}},{"new":[16,4,1],"old":[16,4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[33,16,9,4,2],"old":[16,4],"recipe":{"left":{"linear_Z4":[3,2,3,0,0,0],"matrix_rows":[12,2,16,5,32,1],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":3,"right":{"linear_Z4":[1,2,0,3,0,0],"matrix_rows":[40,2,33,41,4,16],"offset":2,"phase":1,"quadratic_rows":[9,0,0,9,0,0]}}},{"new":[32,16,8,4,2,1],"old":[16,4,1],"recipe":{"left":{"linear_Z4":[2,2,2,0,0,0],"matrix_rows":[8,1,16,2,32,4],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,2,0,2,0,2],"matrix_rows":[2,8,32,1,4,16],"offset":7,"phase":3,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[34,16,10,4,1],"old":[16,4,1],"recipe":{"left":{"linear_Z4":[3,3,0,0,0,0],"matrix_rows":[4,10,16,3,32,1],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":2,"right":{"linear_Z4":[0,1,0,3,0,0],"matrix_rows":[40,34,1,42,4,16],"offset":0,"phase":0,"quadratic_rows":[0,10,0,10,0,0]}}}],"schedule":[[0,1],[0,3],[1,2],[1,6],[2,4],[2,5],[0,5],[0,7],[1,3],[1,7],[2,6],[2,7]],"source_ports":[1,4,16],"target_ports":[21,22,25,26,37,38,41,42]} \ No newline at end of file diff --git a/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-RESULT.json b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-RESULT.json new file mode 100644 index 0000000000..d2aa2b3e48 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-RESULT.json @@ -0,0 +1,25 @@ +{ + "status": "PASS_EXACT_GROWING_CAP_DECODER", + "sources": 3, + "targets": 8, + "scalar_columns": 11, + "reads": 12, + "scalar_carriers": 3, + "initial_frames": "Three source lines and eight zero target frames.", + "source_values_unchanged": true, + "all_target_rows_exact": true, + "monotone_source_and_target_frames": true, + "future_target_compatibility_checked_at_every_read": true, + "paid_profile": { + "1": 15, + "2": 2, + "3": 5, + "4": 4, + "5": 1 + }, + "paid_rank_mass": 55, + "full_phase_lowerings": 23, + "global_phase_and_pauli_columns": true, + "word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "scope": "A finite decoder mechanism. It is not an identity controller, parent supplier or kappa bound." +} diff --git a/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json new file mode 100644 index 0000000000..32d8ffb045 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json @@ -0,0 +1 @@ +{"events":[["child",4,[],[1],1],["add",4,0,1,1,[1]],["child",6,[],[1],1],["add",6,0,1,1,[1]],["child",5,[],[4],1],["add",5,1,1,1,[4]],["child",9,[],[4],1],["add",9,1,1,1,[4]],["child",7,[],[16],1],["add",7,2,1,1,[16]],["child",8,[],[16],1],["add",8,2,1,1,[16]],["child",0,[1],[16,1],1],["child",8,[16],[16,1],1],["add",8,0,1,1,[16,1]],["child",10,[],[16,1],2],["add",10,0,1,1,[16,1]],["child",1,[4],[4,1],1],["child",6,[1],[4,1],1],["add",6,1,1,1,[4,1]],["child",1,[4,1],[16,4,1],1],["child",10,[16,1],[16,4,1],1],["add",10,1,1,1,[16,4,1]],["child",2,[16],[16,4],1],["child",9,[4],[16,4],1],["add",9,2,1,1,[16,4]],["child",2,[16,4],[16,4,1],1],["add",10,2,1,1,[16,4,1]],["child",0,[16,1],[32,16,8,4,2,1],4],["child",1,[16,4,1],[32,16,8,4,2,1],3],["child",2,[16,4,1],[32,16,8,4,2,1],3],["child",3,[],[32,17,8,5,2],5],["child",4,[1],[32,18,8,6,1],4],["child",5,[4],[32,17,9,4,2],4],["child",6,[4,1],[32,18,10,4,1],3],["child",7,[16],[33,16,8,5,2],4],["child",8,[16,1],[34,16,8,6,1],3],["child",9,[16,4],[33,16,9,4,2],3],["child",10,[16,4,1],[34,16,10,4,1],2]],"final_frames":[[32,16,8,4,2,1],[32,16,8,4,2,1],[32,16,8,4,2,1],[32,17,8,5,2],[32,18,8,6,1],[32,17,9,4,2],[32,18,10,4,1],[33,16,8,5,2],[34,16,8,6,1],[33,16,9,4,2],[34,16,10,4,1]],"h":6,"recipes":[{"new":[1],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[4],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16],"old":[],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,1],"old":[],"recipe":{"left":{"linear_Z4":[2,2,0,0,0,0],"matrix_rows":[1,4,8,16,2,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":2,"right":{"linear_Z4":[2,0,0,0,2,0],"matrix_rows":[1,16,2,4,8,32],"offset":3,"phase":2,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,17,8,5,2],"old":[],"recipe":{"left":{"linear_Z4":[3,2,3,2,2,0],"matrix_rows":[36,2,5,8,1,16],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":5,"right":{"linear_Z4":[1,2,3,2,0,2],"matrix_rows":[20,2,17,8,32,21],"offset":26,"phase":3,"quadratic_rows":[5,0,5,0,0,0]}}},{"new":[4,1],"old":[1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,1],"old":[1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,18,8,6,1],"old":[1],"recipe":{"left":{"linear_Z4":[3,3,2,2,0,0],"matrix_rows":[16,34,3,4,1,8],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":4,"right":{"linear_Z4":[0,1,3,2,0,2],"matrix_rows":[20,18,8,32,1,22],"offset":12,"phase":2,"quadratic_rows":[0,6,6,0,0,0]}}},{"new":[4,1],"old":[4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,4],"old":[4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,17,9,4,2],"old":[4],"recipe":{"left":{"linear_Z4":[3,2,3,2,0,0],"matrix_rows":[20,2,32,5,1,8],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":4,"right":{"linear_Z4":[1,2,0,3,0,2],"matrix_rows":[24,2,17,32,25,4],"offset":10,"phase":2,"quadratic_rows":[9,0,0,9,0,0]}}},{"new":[16,4,1],"old":[4,1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,8,16,1,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,0,0,2,0],"matrix_rows":[16,1,2,4,8,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,18,10,4,1],"old":[4,1],"recipe":{"left":{"linear_Z4":[3,3,2,0,0,0],"matrix_rows":[8,18,32,3,1,4],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,1,0,3,0,2],"matrix_rows":[24,18,32,1,26,4],"offset":4,"phase":1,"quadratic_rows":[0,10,0,10,0,0]}}},{"new":[16,1],"old":[16],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[16,4],"old":[16],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[33,16,8,5,2],"old":[16],"recipe":{"left":{"linear_Z4":[3,2,3,2,0,0],"matrix_rows":[20,2,5,8,32,1],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":4,"right":{"linear_Z4":[1,2,3,2,0,0],"matrix_rows":[36,2,33,8,37,16],"offset":10,"phase":2,"quadratic_rows":[5,0,5,0,0,0]}}},{"new":[16,4,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[2,4,1,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[0,0,2,0,0,0],"matrix_rows":[4,1,2,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[32,16,8,4,2,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[2,2,2,2,0,0],"matrix_rows":[16,1,2,4,32,8],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":4,"right":{"linear_Z4":[0,2,2,2,0,2],"matrix_rows":[2,4,8,32,1,16],"offset":15,"phase":0,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[34,16,8,6,1],"old":[16,1],"recipe":{"left":{"linear_Z4":[3,3,2,0,0,0],"matrix_rows":[8,18,3,4,32,1],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,1,3,2,0,0],"matrix_rows":[36,34,8,1,38,16],"offset":4,"phase":1,"quadratic_rows":[0,6,6,0,0,0]}}},{"new":[16,4,1],"old":[16,4],"recipe":{"left":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":1,"right":{"linear_Z4":[2,0,0,0,0,0],"matrix_rows":[1,2,4,8,16,32],"offset":1,"phase":1,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[33,16,9,4,2],"old":[16,4],"recipe":{"left":{"linear_Z4":[3,2,3,0,0,0],"matrix_rows":[12,2,16,5,32,1],"offset":0,"phase":0,"quadratic_rows":[5,0,5,0,0,0]},"rank":3,"right":{"linear_Z4":[1,2,0,3,0,0],"matrix_rows":[40,2,33,41,4,16],"offset":2,"phase":1,"quadratic_rows":[9,0,0,9,0,0]}}},{"new":[32,16,8,4,2,1],"old":[16,4,1],"recipe":{"left":{"linear_Z4":[2,2,2,0,0,0],"matrix_rows":[8,1,16,2,32,4],"offset":0,"phase":0,"quadratic_rows":[0,0,0,0,0,0]},"rank":3,"right":{"linear_Z4":[0,2,0,2,0,2],"matrix_rows":[2,8,32,1,4,16],"offset":7,"phase":3,"quadratic_rows":[0,0,0,0,0,0]}}},{"new":[34,16,10,4,1],"old":[16,4,1],"recipe":{"left":{"linear_Z4":[3,3,0,0,0,0],"matrix_rows":[4,10,16,3,32,1],"offset":0,"phase":0,"quadratic_rows":[3,3,0,0,0,0]},"rank":2,"right":{"linear_Z4":[0,1,0,3,0,0],"matrix_rows":[40,34,1,42,4,16],"offset":0,"phase":0,"quadratic_rows":[0,10,0,10,0,0]}}}],"schedule":[[0,1],[0,3],[1,2],[1,6],[2,4],[2,5],[0,5],[0,7],[1,3],[1,7],[2,6],[2,7]],"source_ports":[1,4,16],"target_ports":[21,22,25,26,37,38,41,42]} \ No newline at end of file diff --git a/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/add_growing_exits.py b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/add_growing_exits.py new file mode 100644 index 0000000000..bd62d957b8 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/add_growing_exits.py @@ -0,0 +1,42 @@ +"""Add exact rank-zero exits to the frozen growing-cap decoder word.""" +from pathlib import Path +import hashlib +import json +import sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE.parents[1] / 'source/research/nodal-pair-async/inputs/work/odd-stages')) +import clifford_exact as c + +source = HERE / 'GROWING-CYCLE-WORD.json' +word = json.loads(source.read_bytes()) +h = word['h'] +exits = [] +for t, q in enumerate(word['target_ports']): + stream = len(word['source_ports']) + t + old = c.canonical_frame(h, tuple(word['final_frames'][stream])) + target = c.cgate(h, q).adjoint().then(c.fourier(h)) + adapter = old.adjoint().then(target) + recipe, emitted = c.lower_child(adapter) + assert recipe['rank'] == 0 + assert emitted.tab == adapter.tab + for column in range(1 << h): + assert old.then(emitted).zero_state(column) == target.zero_state(column) + exits.append(dict(stream=stream, port=q, recipe=recipe, + target_circuit=target.circuit)) + word['events'].append(['monomial_exit', stream, len(exits)-1]) +word['exit_adapters'] = exits +word['endpoint_convention'] = dict( + sources='F', targets='F C_q^-1', + scalar_rows='The scalar row is stated before the address operator.') +raw = json.dumps(word, sort_keys=True, separators=(',', ':')).encode() +(HERE / 'GROWING-CYCLE-LEGACY-EXITS-WORD.json').write_bytes(raw) +receipt = dict(status='PASS_EXACT_MONOMIAL_EXITS', + original_word_sha256=hashlib.sha256(source.read_bytes()).hexdigest(), + word_sha256=hashlib.sha256(raw).hexdigest(), + exits=len(exits), rank_zero_exits=len(exits), + address_columns_checked=len(exits) * (1 << h), + full_global_phase=True, extra_paid_rank=0, + scope='The finite decoder has the stated legacy exits. It is not a full factory or parent supplier.') +(HERE / 'GROWING-CYCLE-LEGACY-EXITS-RESULT.json').write_text(json.dumps(receipt, indent=2)+'\n') +print(json.dumps(receipt, indent=2)) diff --git a/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/growing_cycle.py b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/growing_cycle.py new file mode 100644 index 0000000000..47e6f6bfd0 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/growing_cycle.py @@ -0,0 +1,98 @@ +"""Check an exact three-carrier decoder with repeated monotone read caps.""" +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter +import hashlib, json, sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE.parents[1]/'source/research/nodal-pair-async/inputs/work/odd-stages')) +import clifford_exact as c +h = 6 +ports = [sum(1 << (2*i+((t >> i) & 1)) for i in range(3)) for t in range(8)] +sources = [1 << (2*i) for i in range(3)] +FULL = tuple(1 << i for i in range(h-1, -1, -1)) + +def basis(rows): + rows = list(rows) + out = {} + for x in rows: + for j in sorted(out, reverse=True): + if x >> j & 1: + x ^= out[j] + if x: + j = x.bit_length()-1 + for k in out: + if out[k] >> j & 1: + out[k] ^= x + out[j] = x + return tuple(out[j] for j in sorted(out, reverse=True)) + +def inside(a, b): + return basis(a+b) == b + +cur = [(u,) for u in sources]+[()] * 8 +rows = [{i: Q(1)} for i in range(11)] +events, transitions = [], set() +paid = Counter() +schedule = [(0, 1), (0, 3), (1, 2), (1, 6), (2, 4), (2, 5), + (0, 5), (0, 7), (1, 3), (1, 7), (2, 6), (2, 7)] +pending = [{t for t in range(8) if t >> i & 1} for i in range(3)] + +def climb(stream, out): + old = cur[stream] + assert inside(old, out) + r = len(out)-len(old) + if r: + events.append(['child', stream, list(old), list(out), r]) + transitions.add((old, out)) + paid[r] += 1 + cur[stream] = out + +for i, t in schedule: + assert t in pending[i] + out = basis(cur[i]+cur[3+t]) + assert all((u&ports[q]).bit_count() % 2 == 0 for u in out for q in pending[i]) + climb(i, out) + climb(3+t, out) + assert cur[i] == cur[3+t] + events.append(['add', 3+t, i, 1, 1, list(out)]) + for col, q in rows[i].items(): + rows[3+t][col] = rows[3+t].get(col, Q(0))+q + pending[i].remove(t) +assert not any(pending) +for t in range(8): + expected = {3+t: Q(1)} + expected.update({i: Q(1) for i in range(3) if t >> i & 1}) + assert rows[3+t] == expected +for i in range(3): + assert rows[i] == {i: Q(1)} + +for i in range(3): + climb(i, FULL) +for t in range(8): + cap = basis(c.nullspace((ports[t],), h)) + climb(3+t, cap) + +recipes = [] +for old, new in sorted(transitions): + op = c.canonical_frame(h, old).adjoint().then(c.canonical_frame(h, new)) + record, emitted = c.lower_child(op) + assert record['rank'] == len(new)-len(old) + assert emitted.tab == op.tab and emitted.zero_state() == op.zero_state() + recipes.append(dict(old=list(old), new=list(new), recipe=record)) +word = dict(h=h, source_ports=sources, target_ports=ports, schedule=schedule, + events=events, final_frames=[list(F) for F in cur], recipes=recipes) +raw = json.dumps(word, sort_keys=True, separators=(',', ':')).encode() +HERE.joinpath('GROWING-CYCLE-WORD.json').write_bytes(raw) +receipt = dict(status='PASS_EXACT_GROWING_CAP_DECODER', sources=3, targets=8, + scalar_columns=11, reads=12, scalar_carriers=3, + initial_frames='Three source lines and eight zero target frames.', + source_values_unchanged=True, all_target_rows_exact=True, + monotone_source_and_target_frames=True, + future_target_compatibility_checked_at_every_read=True, + paid_profile=dict(sorted(paid.items())), paid_rank_mass=sum(r*n for r, n in paid.items()), + full_phase_lowerings=len(recipes), global_phase_and_pauli_columns=True, + word_sha256=hashlib.sha256(raw).hexdigest(), + scope='A finite decoder mechanism. It is not an identity controller, parent supplier or kappa bound.') +HERE.joinpath('GROWING-CYCLE-RESULT.json').write_text(json.dumps(receipt, indent=2)+'\n') +print(json.dumps(receipt, indent=2)) diff --git a/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md new file mode 100644 index 0000000000..037885da75 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md @@ -0,0 +1,137 @@ +# Fixed-channel terminal-broadcast limit + +This result applies to a specified compiler class. Each scalar channel +has a distinct zero-entry terminal role in a signed DAG. Each terminal +reads at one fixed maximal common cap of its served target group. The +target decoder retains its basis and uses scalar reads in time order. +Parity and channel reads can interleave. This result does not apply to +copied broadcasts, +smaller caps, a changed decoder, channel fusion, or time reuse of a role +for a different scalar channel. + +## Target frames + +Let the five-cube selector be e in F2^5. Write its root as + + q(e) = q(0) + sum_i e_i d_i, + +where d_i is the sum of the two coordinate axes in pair i. The d_i are +independent and even. The vector q(0) is odd. Let c be an affine selector +coset of ker S, where S has rank d. Its root span is + + U_c = span(q(c), D(ker S)), dim U_c = 6-d. + +Its maximal common cap is U_c^perp, of dimension h-6+d. The odd part of +U_c is exactly the root set of that coset. Thus different cosets have +different caps. No root of a different coset lies in U_c. No root of a +different five-cube lies in U_c either: all odd vectors in U_c select +one coordinate from each of this cube's five pairs. + +If a terminal reaches U_c^perp, it cannot serve any target outside c. +Indeed, U_c^perp is contained in q(t)^perp if and only if q(t) lies in +U_c. Later target-frame growth cannot change that condition. This +prevents one terminal from serving two current cosets or two cubes. + +A new parity normal refines each current coset into two cosets. The +source parity frame joins the old cap to exactly the new cap. If the +normal already lies in S, it does not refine the groups. The independent +check uses literal twenty-coordinate roots to check this join for every +subspace, coset, nonzero normal of weight one through four, and served +parity. + +## Exact root count + +For overlap r from one through four, the reduced parity kernel is + + A_r(t,s) = -(r-dist(t,s)-1)(r-dist(t,s)-3)/8. + +Its nonzero Walsh coefficients per parity block have multiplicities +1, 2, 3, 3. Each target coefficient is a nonzero signed character on its +parity half. Thus each target must read m(a) channels for normal a, +with m(a) given by these four multiplicities. This count uses the fixed +channel outputs in the compiler class above. + +For one target, its cap history defines a monotone normal-span history. +After a channel with normal a is read, that span must contain a. Refine +this history to a complete subspace flag. Move each channel read to the +first flag subspace that contains its normal. This can only reduce the +rank of the cap at that read. + +For a fixed flag, process all available channels in each span before +the next extension. The weighted cost of an extension from S to S' is + + 2^rank(S') * sum_{a in S' minus S} m(a). + +A target read at a cap with normal-span rank d has charge 2^d/32. A +terminal at that fixed cap can serve at most 2^(5-d) targets. Thus the +total charge assigned to one terminal is at most one. The flag DP gives +a per-target charge of at least q/32. The 32 targets in each cube require +at least q terminals. This argument permits arbitrary channel read +orders and different span histories for different targets. It does not +assume one global normal span. + +A forward shortest-path computation over the 374 subspaces of F2^5 +gives these exact minimum terminal demands per target cube: + +| Pair count p | Available overlap | Parity roots | Disjoint roots | Total | +|---|---|---:|---:|---:| +| 8 | 2, 3, 4 | 1326 | 0 | 1326 | +| 9 | 1, 2, 3, 4 | 1454 | 0 | 1454 | +| At least 10 | 0, 1, 2, 3, 4 | 1454 | 1 | 1455 | + +The computation allows only actual positive-weight normals as flag +extensions. It also checks that allowing all nonzero normals gives the +same answer. The disjoint channel can run first and needs one terminal. +The receipt contains flags that attain every count. + +## Retained endpoint ceiling + +Assume the retained endpoint format has m=Lh, L=2K+1 with K>=1, V ports, +copied rank C, T replicas, and deficit + + D = T[2KV - LC]. + +Let R be the number of zero-entry terminal roles per replica. Their +rank increments are at most h and sum to h per role. Therefore their +rank-weighted entropy is at least LTRh log L. The root-count result gives + + R >= q*binom(p,5) = qV/32. + +For a supplier exponent b, the moment uses the factor +exp(b log(m/r)). The inequality exp(x)>=1+x gives b*entropy1. Its derivative has the +sign of log L-L+1, which is negative. The positive atanh series gives +log 3>13/12>1. On dropping C and using L>=3, one obtains + + b < 64/(3hq). + +The exact rational ceilings are 2/1989 for p=8, 16/19629 for p=9, +and 16/21825 for every p>=10. For p from five through seven, C>=V, +so the stated deficit is negative for every K. These facts exclude +b=1/99, and therefore kappa=0.01, for this compiler class. They do not +exclude another construction or decoder for the paired-five family. + +The primary script's comment log(1+b)>=b is false. The entropy argument +above uses exp(x)>=1+x instead. The primary numeric screens agree with +the correct necessary condition. + +## If a terminal reads at several growing caps + +The charge bound above requires one read cap per terminal. It does not +apply to a fixed scalar role that reads at several successively larger +caps. Each fixed scalar channel still requires at least one zero-entry +terminal per target cube. The channel counts are 130, 140, and 141 for +p=8, p=9, and p>=10. No terminal can read a different cube after its +first maximal-cap read, by the cross-cube exclusion above. + +Use these smaller counts in the same entropy inequality. For p=8, +retain C/V=1348/1792 and use the bounds log L>1 and +(1-1/L)-C/V<1-C/V. This gives b<111/29120. For p=9 and p>=10, drop C +as before. This gives b<8/945 and b<16/2115. All three bounds are below +1/99. Thus this weaker argument still excludes kappa=0.01 for the +zero-entry fixed-channel class if roles can read at growing maximal +caps. It still does not bound a changed decoder or channel fusion. diff --git a/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/NOTICE.md b/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/NOTICE.md new file mode 100644 index 0000000000..0b032f7a53 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/NOTICE.md @@ -0,0 +1,11 @@ +# Scoped attribution + +Prepared with OpenAI Codex assistance. Apache-2.0; see LICENSE. Original authorship notices in included vendor code are retained. + +PR507 directly supplies the partial-own factory, 84-pivot reference and its retiming map. PR484 supplies the gauge/kernel construction and wrappers; PR496 supplies whole-owner pooling and invoice ancestry. PR493 supplies the unchanged cited bit operator. PR495 supplies body-frame retiming, with PR501 and PR502 integrating it. PR473's single-gauge proposal inspired our coordinated four-gauge collapse; its updated schedule was also considered. PR505 contains our prior asynchronous complete-invocation scheduling. PR506 supplies a related public comparison and portability feedback. PR477's experiment log informed bounded route selection. + +Earlier retained ancestry includes PR433/425/370 for geometry and the scalar/phase compiler, PR458 for whole-owner spectator wrappers, PR361/315 for exact moments and outer arithmetic, and PR434/417/435/440/401/408/416 for response-kernel and gauge methods. SOURCES.json separates direct ingredients, ancestry, comparisons and excluded interfaces; credits do not mean their gains were added independently. + +Our contribution here is the actual combined reconstructed 99-pivot word and literal whole-owner allocation, with complete fresh checks of the changed complex program. OpenAI math, the Problem 1.8 implementation and the installed machine compiler sources informed the documented research adaptations. No fresh Lean certification is claimed. + +Additional direct inspiration: OpenAI math sparse interpolation, unit-flow/matching, rational Schur history and exact pruning. The source and adaptation ledgers distinguish these roles. Recent PR509-513 were inspected as context, not counted as additional numerical gains. diff --git a/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/SOURCES.json b/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/SOURCES.json new file mode 100644 index 0000000000..c0742547f5 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/SOURCES.json @@ -0,0 +1,119 @@ +{ + "snapshot": "80 recent or updated PR conversations inspected; frozen through PR513 before packaging.", + "direct": [ + { + "pr": 496, + "head": "00cf70efd6a8637531deafef698157ca83e249ee", + "role": "whole-owner parent, invoice and assembly ancestry" + }, + { + "pr": 484, + "head": "035845ce95f31d0a2dcfb42b8c8e13411271fa5f", + "role": "PR496 pinned gauge80-kernel42 parent, not newer moving head" + }, + { + "pr": 493, + "head": "c3a9a436b84fe44fdc223a5784d84736d1c2d3c7", + "role": "unchanged cited R489 bit supplier" + }, + { + "pr": 502, + "head": "4d30b8322184598e65e90a92389e17e1baedd9eb", + "role": "retiming transfer constructor and PR495 schedule fixture" + }, + { + "pr": 501, + "head": "1dc056496fdbbc74073ed26d948a2dc235dbf356", + "role": "parallel retiming integration; credited, no duplicated gain" + }, + { + "pr": 473, + "head": "628b454d3df00367d2d4f78de7d4eb9cbcbd47ca", + "role": "single-helper gauge withdrawal inspiration" + }, + { + "pr": 507, + "head": "8d4444cf8a16d500cbb94add6e4fa8bcfb9c7d5e", + "role": "partial-own factory, 84-pivot reference and retiming map" + }, + { + "pr": 505, + "head": "4ee769c8e28837482272b5f4742497da8e2fc9d4", + "role": "our prior complete-invocation asynchronous scheduling" + }, + { + "pr": 506, + "head": "a4948baee6c7ea35323db74ff636620c6af2925a", + "role": "public asynchronous retiming comparison and portability feedback" + } + ], + "openai_math": { + "repository": "https://github.com/openai/math", + "revision": "adc7f1241b42e322a6451854ab7e4b4c146bf78a", + "status": "source inspection and mathematical adaptation; no new Lean audit" + }, + "other_inspirations": [ + 497, + 458, + 442, + 434, + 433, + 425, + 417, + 435, + 440, + 401, + 408, + 416, + 370, + 361, + 315, + 495, + 503, + 504 + ], + "excluded": { + "494": "under-review split-residual interface not used", + "491": "withdrawn GL sampling argument not used", + "499": "larger claim inherits disputed split-residual interface; not used" + }, + "related_updated": [ + { + "pr": 473, + "head": "94b3c908fb7628142817d995155368aba2eae841", + "role": "new nonuniform scheduling comparison; earlier pinned gauge proposal remains a separate source" + }, + { + "pr": 477, + "head": "2f23f46f1f9e4599168d40096fbacce4973a2978", + "role": "experiment log consulted to avoid repeating old searches" + } + ], + "recent_context": [ + { + "pr": 509, + "head": "7b9c720ecc9f483c383e7cd9c2ab81f06ee5df59", + "role": "abstract Lemma G proof; no new numerical ingredient" + }, + { + "pr": 510, + "head": "64edee18af02aab0c1696b677a0287dd0146381b", + "role": "nonbinding bit improvement; not substituted" + }, + { + "pr": 511, + "head": "79f7c03c7f820ab89955b75ef239cbaccc627e6e", + "role": "formal dispatcher context" + }, + { + "pr": 512, + "head": "73d367fe754cf5921cd954221133b20ac752f932", + "role": "asynchronous partial-own comparison" + }, + { + "pr": 513, + "head": "005dd3f4e3cba8d1761abc4ab391aaf6d14d6f73", + "role": "formal completed-bank context" + } + ] +} diff --git a/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py b/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/prepared-growing-carrier/historical/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<> i) & 1)) for i in range(3)) for t in range(8)] + + +def span(vectors): + points = {0} + for v in vectors: + assert 0 <= v < N + points |= {x ^ v for x in points} + return frozenset(points) + + +def dimension(vectors): + return len(span(vectors)).bit_length() - 1 + + +def invert(rows): + a = [r | (1 << (H + i)) for i, r in enumerate(rows)] + for j in range(H): + i = next(i for i in range(j, H) if (a[i] >> j) & 1) + a[i], a[j] = a[j], a[i] + for i in range(H): + if i != j and (a[i] >> j) & 1: + a[i] ^= a[j] + assert [r & (N - 1) for r in a] == [1 << i for i in range(H)] + return tuple(r >> H for r in a) + + +def monomial(record): + g = tuple(record['matrix_rows']) + q = tuple(record['quadratic_rows']) + alpha = tuple(record['linear_Z4']) + assert len(g) == len(q) == len(alpha) == H + assert dimension(g) == H and 0 <= record['offset'] < N + assert all(((q[i] >> j) & 1) == ((q[j] >> i) & 1) for i in range(H) for j in range(H)) + assert all(alpha[i] % 2 == ((q[i] >> i) & 1) for i in range(H)) + assert 0 <= record['phase'] < 4 + return [('D', q, alpha), ('P', g), ('X', record['offset']), ('phase', record['phase'])] + + +def normalize(v, denominator): + if not any(a or b for a, b in v): + return ((0, 0),) * N, 0 + while denominator and all(a % 2 == b % 2 == 0 for a, b in v): + v = tuple((a // 2, b // 2) for a, b in v) + denominator -= 1 + return tuple(v), denominator + + +permutations, phases = {}, {} + + +def apply(circuit, state): + v, denominator = state + if not any(a or b for a, b in v): + return state + for e in circuit: + tag = e[0] + if tag == 'P': + key = tuple(e[1]) + if key not in permutations: + permutations[key] = [sum(((row & x).bit_count() % 2) << i for i, row in enumerate(key)) for x in range(N)] + out = [(0, 0)] * N + for x, y in enumerate(permutations[key]): + out[y] = v[x] + v = out + elif tag == 'X': + v = [v[x ^ e[1]] for x in range(N)] + elif tag in ('D', 'phase'): + if tag == 'phase': + powers = [e[1] % 4] * N + else: + key = tuple(e[1]), tuple(e[2]) + if key not in phases: + phases[key] = [(sum(e[2][i] for i in range(H) if (x >> i) & 1) + + 2 * sum((e[1][i] >> j) & 1 for i in range(H) for j in range(i + 1, H) + if ((x >> i) & 1) and ((x >> j) & 1))) % 4 for x in range(N)] + powers = phases[key] + units = ((1, 0), (0, 1), (-1, 0), (0, -1)) + v = [(a * units[p][0] - b * units[p][1], a * units[p][1] + b * units[p][0]) + for (a, b), p in zip(v, powers)] + elif tag == 'C': + q, sign = e[1:] + out = [] + for x, (a, b) in enumerate(v): + c, d = v[x ^ q] + out.append((a - sign * b + c + sign * d, b + sign * a + d - sign * c)) + v = out + denominator += 1 + else: + raise AssertionError(e) + return normalize(v, denominator) + + +def adjoint(circuit): + out = [] + for e in reversed(circuit): + if e[0] == 'P': + out.append(('P', invert(tuple(e[1])))) + elif e[0] == 'D': + out.append(('D', tuple(e[1]), tuple((-x) % 4 for x in e[2]))) + elif e[0] == 'C': + out.append(('C', e[1], -e[2])) + elif e[0] == 'phase': + out.append(('phase', (-e[1]) % 4)) + else: + assert e[0] == 'X' + out.append(tuple(e)) + return out + + +def plus(a, b, coefficient=Q(1)): + assert coefficient.denominator & (coefficient.denominator - 1) == 0 + extra = coefficient.denominator.bit_length() - 1 + power = max(a[1], b[1] + extra) + aa, bb = 1 << (power - a[1]), coefficient.numerator << (power - b[1] - extra) + return normalize([(aa * x + bb * u, aa * y + bb * z) for (x, y), (u, z) in zip(a[0], b[0])], power) + + +zero = (((0, 0),) * N, 0) +basis = [(tuple((int(j == col), 0) for j in range(N)), 0) for col in range(N)] +initial = [(q,) for q in w['source_ports']] + [()] * 8 +frames = {tuple(f) for f in initial + [tuple(f) for f in w['final_frames']]} +for e in w['events']: + frames |= {tuple(e[2]), tuple(e[3])} if e[0] == 'child' else {tuple(e[-1])} +assert all(dimension(f) == len(f) for f in frames) +canonical = {f: cx.canonical_frame(H, f).circuit for f in frames} +recipes = {} +for item in w['recipes']: + old, new, r = tuple(item['old']), tuple(item['new']), item['recipe'] + assert (old, new) not in recipes + assert span(old) < span(new) + assert r['rank'] == len(new) - len(old) + serialized = monomial(r['right']) + [('C', 1 << i, 1) for i in range(r['rank'])] + monomial(r['left']) + expected = adjoint(canonical[old]) + canonical[new] + for state in basis: + assert apply(serialized, state) == apply(expected, state), ('full recipe column', old, new) + recipes[old, new] = serialized + +labels = [('T', f) for f in initial] +rows = [{r: Q(1)} for r in range(COUNT)] +pending = [{t for t, q in enumerate(w['target_ports']) if not (q & u).bit_count() % 2} for u in w['source_ports']] +paid = Counter() +per_register = [0] * COUNT +read_caps = [[] for _ in w['source_ports']] +seen_reads, used = [], set() +for e in w['events']: + if e[0] == 'child': + _, r, old, new, charged = e + old, new = tuple(old), tuple(new) + assert labels[r] == ('T', old) + assert span(old) < span(new) and charged == len(new) - len(old) + assert (old, new) in recipes + if r < 3: + assert all(not (u & w['target_ports'][t]).bit_count() % 2 for u in new for t in pending[r]) + else: + assert all(not (u & w['target_ports'][r - 3]).bit_count() % 2 for u in new) + labels[r] = ('T', new) + paid[charged] += 1 + per_register[r] += charged + used.add((old, new)) + else: + assert e[0] == 'add' + _, t, s, num, den, f = e + assert 3 <= t < COUNT and 0 <= s < 3 + assert labels[t] == labels[s] == ('T', tuple(f)) + assert t - 3 in pending[s] + pending[s].remove(t - 3) + seen_reads.append([s, t - 3]) + read_caps[s].append((t - 3, tuple(f))) + for col, value in rows[s].items(): + rows[t][col] = rows[t].get(col, Q(0)) + Q(num, den) * value +assert not any(pending) and seen_reads == w['schedule'] +assert used == set(recipes) and len(recipes) == 23 +assert [f for _, f in labels] == [tuple(f) for f in w['final_frames']] +for r in range(COUNT): + expected = {r: Q(1)} + if r >= 3: + expected.update({s: Q(1) for s in range(3) if (r - 3) >> s & 1}) + assert rows[r] == expected +for t, q in enumerate(w['target_ports']): + assert span(w['final_frames'][3 + t]) == frozenset(x for x in range(N) if not (x & q).bit_count() % 2) +assert per_register == [5] * 11 +assert sum(r * n for r, n in paid.items()) == 55 + + +def replay(state, inverse=False): + state = list(state) + events = list(reversed(w['events'])) if inverse else w['events'] + for e in events: + if e[0] == 'child': + circuit = recipes[tuple(e[2]), tuple(e[3])] + state[e[1]] = apply(adjoint(circuit) if inverse else circuit, state[e[1]]) + else: + q = Q(e[3], e[4]) * (-1 if inverse else 1) + state[e[1]] = plus(state[e[1]], state[e[2]], q) + return state + + +for r in range(COUNT): + for vector in basis: + start = [zero] * COUNT + start[r] = vector + actual = replay(start) + logical = [apply(adjoint(canonical[initial[s]]), start[s]) for s in range(COUNT)] + wanted = [] + for output in range(COUNT): + value = zero + for col, q in rows[output].items(): + value = plus(value, logical[col], q) + wanted.append(apply(canonical[tuple(w['final_frames'][output])], value)) + assert actual == wanted, ('full physical column', r) + assert replay(actual, True) == start, ('inverse physical column', r) + +source_bridges = [] +for q in w['source_ports']: + assert all(apply(canonical[(q,)], v) == apply([('C', q, 1)], v) for v in basis) + source_bridges.append(True) +target_bridges = [] +for t, q in enumerate(w['target_ports']): + cap = tuple(w['final_frames'][3 + t]) + goal = cx.cgate(H, q).adjoint().then(cx.fourier(H)) + endpoint = cx.canonical_frame(H, cap) + correction = endpoint.adjoint().then(goal) + rank = cx.rank([x for x, z, p in correction.tab[H:]]) + equal = all(apply(canonical[cap], v) == apply(goal.circuit, v) for v in basis) + assert not equal and rank == 0 + target_bridges.append({'q': q, 'canonical_equals_legacy_endpoint': equal, 'exit_correction_rank': rank}) + +last_read_cap = [caps[-1][1] for caps in read_caps] +invalid_fixed_caps = [] +for source, caps in enumerate(read_caps): + for t, cap in caps: + if any((u & w['target_ports'][t]).bit_count() % 2 for u in last_read_cap[source]): + invalid_fixed_caps.append({'source': source, 'target': t, 'q': w['target_ports'][t], + 'read_cap': cap, 'last_read_cap': last_read_cap[source]}) +assert invalid_fixed_caps +charges = [sum(Q(1 << len(cap), 8) for t, cap in caps) for caps in read_caps] +assert charges == [Q(3, 2), Q(2), Q(2)] +first = w['recipes'][0] +mutant = list(recipes[tuple(first['old']), tuple(first['new'])]) + [('phase', 1)] +assert apply(mutant, basis[0]) != apply(recipes[tuple(first['old']), tuple(first['new'])], basis[0]) + +result = { + 'status': 'PASS_INDEPENDENT_GROWING_CAP_WORD', + 'word_sha256': EXPECTED_WORD, 'clifford_source_sha256': EXPECTED_CLIFFORD, + 'builder_imported': False, 'lower_child_called': False, + 'canonical_frame_definitions_shared': True, + 'separate_integer_gaussian_interpreter': True, + 'scalar_input_columns': COUNT, + 'recipe_basis_columns': len(recipes) * N, + 'whole_physical_basis_columns': COUNT * N, + 'inverse_round_trip_columns': COUNT * N, + 'all_moves_strict_nested_ascents': True, + 'full_common_labels_at_adds': True, + 'future_targets_compatible_before_each_source_move': True, + 'sources_unchanged_in_scalar_replay': True, + 'target_rows_exact': True, + 'literal_events': len(w['events']), 'scalar_add_reads': len(seen_reads), + 'paid_child_calls': sum(paid.values()), 'distinct_recipe_lowerings': len(recipes), + 'paid_profile': dict(sorted(paid.items())), 'paid_rank_mass': 55, + 'paid_rank_by_register': per_register, 'copies': 0, + 'source_line_bridge_equals_C_e': source_bridges, + 'target_endpoint_bridges': target_bridges, + 'target_exit_adapters_in_frozen_word': False, + 'fixed_last_cap_counterexamples': invalid_fixed_caps, + 'three_selector_analogue_charges_per_carrier': list(map(str, charges)), + 'phase_mutant_rejected': True, + 'scope': 'One finite canonical-frame decoder. No complete scalar factory, legacy exit adapter word, global owner controller, supplier or kappa gain is checked.', +} +result['checker_sha256'] = hashlib.sha256(Path(__file__).read_bytes()).hexdigest() +args.output.write_text(json.dumps(result, indent=2) + '\n') +print(json.dumps(result, indent=2)) diff --git a/research/prepared-growing-carrier/replayed-receipt.json b/research/prepared-growing-carrier/replayed-receipt.json new file mode 100644 index 0000000000..043acaaa1c --- /dev/null +++ b/research/prepared-growing-carrier/replayed-receipt.json @@ -0,0 +1,226 @@ +{ + "status": "PASS_PREPARED_GROWING_CARRIER", + "stages": [ + "construct", + "exits", + "independent" + ], + "independent": { + "status": "PASS_INDEPENDENT_GROWING_CAP_WORD", + "word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "clifford_source_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "builder_imported": false, + "lower_child_called": false, + "canonical_frame_definitions_shared": true, + "separate_integer_gaussian_interpreter": true, + "scalar_input_columns": 11, + "recipe_basis_columns": 1472, + "whole_physical_basis_columns": 704, + "inverse_round_trip_columns": 704, + "all_moves_strict_nested_ascents": true, + "full_common_labels_at_adds": true, + "future_targets_compatible_before_each_source_move": true, + "sources_unchanged_in_scalar_replay": true, + "target_rows_exact": true, + "literal_events": 39, + "scalar_add_reads": 12, + "paid_child_calls": 27, + "distinct_recipe_lowerings": 23, + "paid_profile": { + "1": 15, + "2": 2, + "3": 5, + "4": 4, + "5": 1 + }, + "paid_rank_mass": 55, + "paid_rank_by_register": [ + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5 + ], + "copies": 0, + "source_line_bridge_equals_C_e": [ + true, + true, + true + ], + "target_endpoint_bridges": [ + { + "q": 21, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 22, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 25, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 26, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 37, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 38, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 41, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 42, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + } + ], + "target_exit_adapters_in_frozen_word": false, + "fixed_last_cap_counterexamples": [ + { + "source": 0, + "target": 1, + "q": 22, + "read_cap": [ + 1 + ], + "last_read_cap": [ + 16, + 1 + ] + }, + { + "source": 0, + "target": 3, + "q": 26, + "read_cap": [ + 1 + ], + "last_read_cap": [ + 16, + 1 + ] + }, + { + "source": 1, + "target": 2, + "q": 25, + "read_cap": [ + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 1, + "target": 6, + "q": 41, + "read_cap": [ + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 1, + "target": 3, + "q": 26, + "read_cap": [ + 4, + 1 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 4, + "q": 37, + "read_cap": [ + 16 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 5, + "q": 38, + "read_cap": [ + 16 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 6, + "q": 41, + "read_cap": [ + 16, + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + } + ], + "three_selector_analogue_charges_per_carrier": [ + "3/2", + "2", + "2" + ], + "phase_mutant_rejected": true, + "scope": "One finite canonical-frame decoder. No complete scalar factory, legacy exit adapter word, global owner controller, supplier or kappa gain is checked." + }, + "source_manifest_sha256": "5fe4a164c6c2e0a61f049081abe825179a4ee46f6995f2e122609d52a8851855", + "portable_checker_sha256": "3f1c36505bb7283f8e1ab86129272d1db1fbc66cf0c0c5e284dfac09155c2022", + "legacy_exits": { + "status": "PASS_EXACT_MONOMIAL_EXITS", + "original_word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "word_sha256": "88f5291e223d99a1d3a883b04f0caa7f7981e9a29086bd07fadc5694f95c241d", + "exits": 8, + "rank_zero_exits": 8, + "address_columns_checked": 512, + "full_global_phase": true, + "extra_paid_rank": 0, + "scope": "The finite decoder has the stated legacy exits. It is not a full factory or parent supplier." + } +} diff --git a/research/prepared-growing-carrier/review/CHECKED-FILES.json b/research/prepared-growing-carrier/review/CHECKED-FILES.json new file mode 100644 index 0000000000..156e652f42 --- /dev/null +++ b/research/prepared-growing-carrier/review/CHECKED-FILES.json @@ -0,0 +1,131 @@ +{ + "status": "PASS_INDEPENDENT_AGENT_REVIEW", + "package": "work/project-final-cleanup-20261022/early-projects-audit/packages/prepared-growing-carrier", + "files": [ + { + "path": "README.md", + "bytes": 5318, + "sha256": "205f356a69a46ebb9bc88a5fa362121e79a7033f84d49e304d0efc54abd9ca3a" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 5432, + "sha256": "5fe4a164c6c2e0a61f049081abe825179a4ee46f6995f2e122609d52a8851855" + }, + { + "path": "VALIDATION.json", + "bytes": 691, + "sha256": "560b31bca3e461da8f9660311e59c30c2eafb6c30a783f5a113d5f00c0e0d9c7" + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/FROZEN-WORD.json", + "bytes": 7971, + "sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5" + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/PROOF.md", + "bytes": 8107, + "sha256": "90f799133f1018e9ad6dbc8c232b1cc081170fc67c72fcd3ab1048dacc3093a8" + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/RESULT.json", + "bytes": 3896, + "sha256": "8f731e0d989273c00cd11fcb84e0da9bc8ef78412ce099656bd47b9b74008456" + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/SOURCE-PINS.json", + "bytes": 1047, + "sha256": "e5bc79fb24e4c4b9c4821db8130a97ee707d5148c58252147658306a0f177ed8" + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/VERIFICATION.json", + "bytes": 1003, + "sha256": "f780153c2dbf4d269eca1847117fc849c002f6138dde8f43de354551e800aa08" + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/check.py", + "bytes": 12646, + "sha256": "5bbb842f74b0dff8ecbe7756a0a83937d89c853dcf7813a406b51a782949b165" + }, + { + "path": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-RESULT.json", + "bytes": 455, + "sha256": "039950b8d9318c8bb4f61b31923e7843d241d0465a0a8705ba75003faed79854" + }, + { + "path": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-WORD.json", + "bytes": 10426, + "sha256": "88f5291e223d99a1d3a883b04f0caa7f7981e9a29086bd07fadc5694f95c241d" + }, + { + "path": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-RESULT.json", + "bytes": 764, + "sha256": "9800893733d820aaae969716d106c2aefcaee3a36d5a4b42d614a244af4dc6f7" + }, + { + "path": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json", + "bytes": 7971, + "sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5" + }, + { + "path": "historical/work/p518-next/complex/paired-five/add_growing_exits.py", + "bytes": 2012, + "sha256": "67893edbbdfd380ccd9270954f9e76ae023c27787cad92bb0e5c6eaaafe997c6" + }, + { + "path": "historical/work/p518-next/complex/paired-five/growing_cycle.py", + "bytes": 3754, + "sha256": "fef1dc7c979b39235b6ef41396835f8778548e702b4e085aec10e3d5cdcafe58" + }, + { + "path": "historical/work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md", + "bytes": 6162, + "sha256": "a75a50aeae792a1b67c9b3b1cb5c95bfd6a3cf56cf1c3dfed304a7088118887e" + }, + { + "path": "historical/work/p518-next/source/research/nodal-pair-async/NOTICE.md", + "bytes": 1818, + "sha256": "ec590608ddae58b227fe28040c29cd026699e2e5c26faad63da71a79dc50e159" + }, + { + "path": "historical/work/p518-next/source/research/nodal-pair-async/SOURCES.json", + "bytes": 3286, + "sha256": "e82688d40483797d7fb5599cde3502018f9bf56acf66a803a7c6a497e885d7db" + }, + { + "path": "historical/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "public-source/NOTICE.md", + "bytes": 1451, + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "path": "public-source/SOURCES.json", + "bytes": 2592, + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f" + }, + { + "path": "replay.log", + "bytes": 944, + "sha256": "bcbfb1e05a91fcf673568e6f7f06d7e837f0634e01daeccdfe59bb9c49382c56" + }, + { + "path": "replay.py", + "bytes": 12836, + "sha256": "3f1c36505bb7283f8e1ab86129272d1db1fbc66cf0c0c5e284dfac09155c2022" + }, + { + "path": "replayed-receipt.json", + "bytes": 5036, + "sha256": "150c3b181f82936bc55c6aa51fa7d704be3c0d08903bbde2d7b7d85a99d373f4" + }, + { + "path": "verify.py", + "bytes": 3219, + "sha256": "64dbbe42c80055534ff148bcc84cafc3fa1756413326bdef8aaee4a3eb5ea846" + } + ] +} diff --git a/research/prepared-growing-carrier/review/CONTROLS.json b/research/prepared-growing-carrier/review/CONTROLS.json new file mode 100644 index 0000000000..3d53523ba6 --- /dev/null +++ b/research/prepared-growing-carrier/review/CONTROLS.json @@ -0,0 +1,1074 @@ +{ + "status": "PASS_PREPARED_CARRIER_CONTROLS", + "exit_columns": 512, + "exit_inverse_columns": 512, + "all_checks": 1066, + "checks": [ + "optimized wrapper rejected", + "optimized wrapper rejected: stated error", + "optimized checker rejected", + "optimized checker rejected: stated error", + "occupied build rejected", + "occupied build rejected: stated error", + "occupied directory unchanged", + "changed frozen source rejected", + "changed frozen source rejected: stated error", + "changed word pin rejected", + "changed compiler pin rejected", + "occupied receipt rejected", + "occupied receipt rejected: stated error", + "occupied receipt unchanged", + "exit extension keeps every base event", + "eight exits occur after every ADD", + "exit stream and port 0", + "exit rank and shape 0", + "exit column 0:0", + "exit inverse 0:0", + "exit column 0:1", + "exit inverse 0:1", + "exit column 0:2", + "exit inverse 0:2", + "exit column 0:3", + "exit inverse 0:3", + "exit column 0:4", + "exit inverse 0:4", + "exit column 0:5", + "exit inverse 0:5", + "exit column 0:6", + "exit inverse 0:6", + "exit column 0:7", + "exit inverse 0:7", + "exit column 0:8", + "exit inverse 0:8", + "exit column 0:9", + "exit inverse 0:9", + "exit column 0:10", + "exit inverse 0:10", + "exit column 0:11", + "exit inverse 0:11", + "exit column 0:12", + "exit inverse 0:12", + "exit column 0:13", + "exit inverse 0:13", + "exit column 0:14", + "exit inverse 0:14", + "exit column 0:15", + "exit inverse 0:15", + "exit column 0:16", + "exit inverse 0:16", + "exit column 0:17", + "exit inverse 0:17", + "exit column 0:18", + "exit inverse 0:18", + "exit column 0:19", + "exit inverse 0:19", + "exit column 0:20", + "exit inverse 0:20", + "exit column 0:21", + "exit inverse 0:21", + "exit column 0:22", + "exit inverse 0:22", + "exit column 0:23", + "exit inverse 0:23", + "exit column 0:24", + "exit inverse 0:24", + "exit column 0:25", + "exit inverse 0:25", + "exit column 0:26", + "exit inverse 0:26", + "exit column 0:27", + "exit inverse 0:27", + "exit column 0:28", + "exit inverse 0:28", + "exit column 0:29", + "exit inverse 0:29", + "exit column 0:30", + "exit inverse 0:30", + "exit column 0:31", + "exit inverse 0:31", + "exit column 0:32", + "exit inverse 0:32", + "exit column 0:33", + "exit inverse 0:33", + "exit column 0:34", + "exit inverse 0:34", + "exit column 0:35", + "exit inverse 0:35", + "exit column 0:36", + "exit inverse 0:36", + "exit column 0:37", + "exit inverse 0:37", + "exit column 0:38", + "exit inverse 0:38", + "exit column 0:39", + "exit inverse 0:39", + "exit column 0:40", + "exit inverse 0:40", + "exit column 0:41", + "exit inverse 0:41", + "exit column 0:42", + "exit inverse 0:42", + "exit column 0:43", + "exit inverse 0:43", + "exit column 0:44", + "exit inverse 0:44", + "exit column 0:45", + "exit inverse 0:45", + "exit column 0:46", + "exit inverse 0:46", + "exit column 0:47", + "exit inverse 0:47", + "exit column 0:48", + "exit inverse 0:48", + "exit column 0:49", + "exit inverse 0:49", + "exit column 0:50", + "exit inverse 0:50", + "exit column 0:51", + "exit inverse 0:51", + "exit column 0:52", + "exit inverse 0:52", + "exit column 0:53", + "exit inverse 0:53", + "exit column 0:54", + "exit inverse 0:54", + "exit column 0:55", + "exit inverse 0:55", + "exit column 0:56", + "exit inverse 0:56", + "exit column 0:57", + "exit inverse 0:57", + "exit column 0:58", + "exit inverse 0:58", + "exit column 0:59", + "exit inverse 0:59", + "exit column 0:60", + "exit inverse 0:60", + "exit column 0:61", + "exit inverse 0:61", + "exit column 0:62", + "exit inverse 0:62", + "exit column 0:63", + "exit inverse 0:63", + "exit phase mutation 0", + "exit stream and port 1", + "exit rank and shape 1", + "exit column 1:0", + "exit inverse 1:0", + "exit column 1:1", + "exit inverse 1:1", + "exit column 1:2", + "exit inverse 1:2", + "exit column 1:3", + "exit inverse 1:3", + "exit column 1:4", + "exit inverse 1:4", + "exit column 1:5", + "exit inverse 1:5", + "exit column 1:6", + "exit inverse 1:6", + "exit column 1:7", + "exit inverse 1:7", + "exit column 1:8", + "exit inverse 1:8", + "exit column 1:9", + "exit inverse 1:9", + "exit column 1:10", + "exit inverse 1:10", + "exit column 1:11", + "exit inverse 1:11", + "exit column 1:12", + "exit inverse 1:12", + "exit column 1:13", + "exit inverse 1:13", + "exit column 1:14", + "exit inverse 1:14", + "exit column 1:15", + "exit inverse 1:15", + "exit column 1:16", + "exit inverse 1:16", + "exit column 1:17", + "exit inverse 1:17", + "exit column 1:18", + "exit inverse 1:18", + "exit column 1:19", + "exit inverse 1:19", + "exit column 1:20", + "exit inverse 1:20", + "exit column 1:21", + "exit inverse 1:21", + "exit column 1:22", + "exit inverse 1:22", + "exit column 1:23", + "exit inverse 1:23", + "exit column 1:24", + "exit inverse 1:24", + "exit column 1:25", + "exit inverse 1:25", + "exit column 1:26", + "exit inverse 1:26", + "exit column 1:27", + "exit inverse 1:27", + "exit column 1:28", + "exit inverse 1:28", + "exit column 1:29", + "exit inverse 1:29", + "exit column 1:30", + "exit inverse 1:30", + "exit column 1:31", + "exit inverse 1:31", + "exit column 1:32", + "exit inverse 1:32", + "exit column 1:33", + "exit inverse 1:33", + "exit column 1:34", + "exit inverse 1:34", + "exit column 1:35", + "exit inverse 1:35", + "exit column 1:36", + "exit inverse 1:36", + "exit column 1:37", + "exit inverse 1:37", + "exit column 1:38", + "exit inverse 1:38", + "exit column 1:39", + "exit inverse 1:39", + "exit column 1:40", + "exit inverse 1:40", + "exit column 1:41", + "exit inverse 1:41", + "exit column 1:42", + "exit inverse 1:42", + "exit column 1:43", + "exit inverse 1:43", + "exit column 1:44", + "exit inverse 1:44", + "exit column 1:45", + "exit inverse 1:45", + "exit column 1:46", + "exit inverse 1:46", + "exit column 1:47", + "exit inverse 1:47", + "exit column 1:48", + "exit inverse 1:48", + "exit column 1:49", + "exit inverse 1:49", + "exit column 1:50", + "exit inverse 1:50", + "exit column 1:51", + "exit inverse 1:51", + "exit column 1:52", + "exit inverse 1:52", + "exit column 1:53", + "exit inverse 1:53", + "exit column 1:54", + "exit inverse 1:54", + "exit column 1:55", + "exit inverse 1:55", + "exit column 1:56", + "exit inverse 1:56", + "exit column 1:57", + "exit inverse 1:57", + "exit column 1:58", + "exit inverse 1:58", + "exit column 1:59", + "exit inverse 1:59", + "exit column 1:60", + "exit inverse 1:60", + "exit column 1:61", + "exit inverse 1:61", + "exit column 1:62", + "exit inverse 1:62", + "exit column 1:63", + "exit inverse 1:63", + "exit phase mutation 1", + "exit stream and port 2", + "exit rank and shape 2", + "exit column 2:0", + "exit inverse 2:0", + "exit column 2:1", + "exit inverse 2:1", + "exit column 2:2", + "exit inverse 2:2", + "exit column 2:3", + "exit inverse 2:3", + "exit column 2:4", + "exit inverse 2:4", + "exit column 2:5", + "exit inverse 2:5", + "exit column 2:6", + "exit inverse 2:6", + "exit column 2:7", + "exit inverse 2:7", + "exit column 2:8", + "exit inverse 2:8", + "exit column 2:9", + "exit inverse 2:9", + "exit column 2:10", + "exit inverse 2:10", + "exit column 2:11", + "exit inverse 2:11", + "exit column 2:12", + "exit inverse 2:12", + "exit column 2:13", + "exit inverse 2:13", + "exit column 2:14", + "exit inverse 2:14", + "exit column 2:15", + "exit inverse 2:15", + "exit column 2:16", + "exit inverse 2:16", + "exit column 2:17", + "exit inverse 2:17", + "exit column 2:18", + "exit inverse 2:18", + "exit column 2:19", + "exit inverse 2:19", + "exit column 2:20", + "exit inverse 2:20", + "exit column 2:21", + "exit inverse 2:21", + "exit column 2:22", + "exit inverse 2:22", + "exit column 2:23", + "exit inverse 2:23", + "exit column 2:24", + "exit inverse 2:24", + "exit column 2:25", + "exit inverse 2:25", + "exit column 2:26", + "exit inverse 2:26", + "exit column 2:27", + "exit inverse 2:27", + "exit column 2:28", + "exit inverse 2:28", + "exit column 2:29", + "exit inverse 2:29", + "exit column 2:30", + "exit inverse 2:30", + "exit column 2:31", + "exit inverse 2:31", + "exit column 2:32", + "exit inverse 2:32", + "exit column 2:33", + "exit inverse 2:33", + "exit column 2:34", + "exit inverse 2:34", + "exit column 2:35", + "exit inverse 2:35", + "exit column 2:36", + "exit inverse 2:36", + "exit column 2:37", + "exit inverse 2:37", + "exit column 2:38", + "exit inverse 2:38", + "exit column 2:39", + "exit inverse 2:39", + "exit column 2:40", + "exit inverse 2:40", + "exit column 2:41", + "exit inverse 2:41", + "exit column 2:42", + "exit inverse 2:42", + "exit column 2:43", + "exit inverse 2:43", + "exit column 2:44", + "exit inverse 2:44", + "exit column 2:45", + "exit inverse 2:45", + "exit column 2:46", + "exit inverse 2:46", + "exit column 2:47", + "exit inverse 2:47", + "exit column 2:48", + "exit inverse 2:48", + "exit column 2:49", + "exit inverse 2:49", + "exit column 2:50", + "exit inverse 2:50", + "exit column 2:51", + "exit inverse 2:51", + "exit column 2:52", + "exit inverse 2:52", + "exit column 2:53", + "exit inverse 2:53", + "exit column 2:54", + "exit inverse 2:54", + "exit column 2:55", + "exit inverse 2:55", + "exit column 2:56", + "exit inverse 2:56", + "exit column 2:57", + "exit inverse 2:57", + "exit column 2:58", + "exit inverse 2:58", + "exit column 2:59", + "exit inverse 2:59", + "exit column 2:60", + "exit inverse 2:60", + "exit column 2:61", + "exit inverse 2:61", + "exit column 2:62", + "exit inverse 2:62", + "exit column 2:63", + "exit inverse 2:63", + "exit phase mutation 2", + "exit stream and port 3", + "exit rank and shape 3", + "exit column 3:0", + "exit inverse 3:0", + "exit column 3:1", + "exit inverse 3:1", + "exit column 3:2", + "exit inverse 3:2", + "exit column 3:3", + "exit inverse 3:3", + "exit column 3:4", + "exit inverse 3:4", + "exit column 3:5", + "exit inverse 3:5", + "exit column 3:6", + "exit inverse 3:6", + "exit column 3:7", + "exit inverse 3:7", + "exit column 3:8", + "exit inverse 3:8", + "exit column 3:9", + "exit inverse 3:9", + "exit column 3:10", + "exit inverse 3:10", + "exit column 3:11", + "exit inverse 3:11", + "exit column 3:12", + "exit inverse 3:12", + "exit column 3:13", + "exit inverse 3:13", + "exit column 3:14", + "exit inverse 3:14", + "exit column 3:15", + "exit inverse 3:15", + "exit column 3:16", + "exit inverse 3:16", + "exit column 3:17", + "exit inverse 3:17", + "exit column 3:18", + "exit inverse 3:18", + "exit column 3:19", + "exit inverse 3:19", + "exit column 3:20", + "exit inverse 3:20", + "exit column 3:21", + "exit inverse 3:21", + "exit column 3:22", + "exit inverse 3:22", + "exit column 3:23", + "exit inverse 3:23", + "exit column 3:24", + "exit inverse 3:24", + "exit column 3:25", + "exit inverse 3:25", + "exit column 3:26", + "exit inverse 3:26", + "exit column 3:27", + "exit inverse 3:27", + "exit column 3:28", + "exit inverse 3:28", + "exit column 3:29", + "exit inverse 3:29", + "exit column 3:30", + "exit inverse 3:30", + "exit column 3:31", + "exit inverse 3:31", + "exit column 3:32", + "exit inverse 3:32", + "exit column 3:33", + "exit inverse 3:33", + "exit column 3:34", + "exit inverse 3:34", + "exit column 3:35", + "exit inverse 3:35", + "exit column 3:36", + "exit inverse 3:36", + "exit column 3:37", + "exit inverse 3:37", + "exit column 3:38", + "exit inverse 3:38", + "exit column 3:39", + "exit inverse 3:39", + "exit column 3:40", + "exit inverse 3:40", + "exit column 3:41", + "exit inverse 3:41", + "exit column 3:42", + "exit inverse 3:42", + "exit column 3:43", + "exit inverse 3:43", + "exit column 3:44", + "exit inverse 3:44", + "exit column 3:45", + "exit inverse 3:45", + "exit column 3:46", + "exit inverse 3:46", + "exit column 3:47", + "exit inverse 3:47", + "exit column 3:48", + "exit inverse 3:48", + "exit column 3:49", + "exit inverse 3:49", + "exit column 3:50", + "exit inverse 3:50", + "exit column 3:51", + "exit inverse 3:51", + "exit column 3:52", + "exit inverse 3:52", + "exit column 3:53", + "exit inverse 3:53", + "exit column 3:54", + "exit inverse 3:54", + "exit column 3:55", + "exit inverse 3:55", + "exit column 3:56", + "exit inverse 3:56", + "exit column 3:57", + "exit inverse 3:57", + "exit column 3:58", + "exit inverse 3:58", + "exit column 3:59", + "exit inverse 3:59", + "exit column 3:60", + "exit inverse 3:60", + "exit column 3:61", + "exit inverse 3:61", + "exit column 3:62", + "exit inverse 3:62", + "exit column 3:63", + "exit inverse 3:63", + "exit phase mutation 3", + "exit stream and port 4", + "exit rank and shape 4", + "exit column 4:0", + "exit inverse 4:0", + "exit column 4:1", + "exit inverse 4:1", + "exit column 4:2", + "exit inverse 4:2", + "exit column 4:3", + "exit inverse 4:3", + "exit column 4:4", + "exit inverse 4:4", + "exit column 4:5", + "exit inverse 4:5", + "exit column 4:6", + "exit inverse 4:6", + "exit column 4:7", + "exit inverse 4:7", + "exit column 4:8", + "exit inverse 4:8", + "exit column 4:9", + "exit inverse 4:9", + "exit column 4:10", + "exit inverse 4:10", + "exit column 4:11", + "exit inverse 4:11", + "exit column 4:12", + "exit inverse 4:12", + "exit column 4:13", + "exit inverse 4:13", + "exit column 4:14", + "exit inverse 4:14", + "exit column 4:15", + "exit inverse 4:15", + "exit column 4:16", + "exit inverse 4:16", + "exit column 4:17", + "exit inverse 4:17", + "exit column 4:18", + "exit inverse 4:18", + "exit column 4:19", + "exit inverse 4:19", + "exit column 4:20", + "exit inverse 4:20", + "exit column 4:21", + "exit inverse 4:21", + "exit column 4:22", + "exit inverse 4:22", + "exit column 4:23", + "exit inverse 4:23", + "exit column 4:24", + "exit inverse 4:24", + "exit column 4:25", + "exit inverse 4:25", + "exit column 4:26", + "exit inverse 4:26", + "exit column 4:27", + "exit inverse 4:27", + "exit column 4:28", + "exit inverse 4:28", + "exit column 4:29", + "exit inverse 4:29", + "exit column 4:30", + "exit inverse 4:30", + "exit column 4:31", + "exit inverse 4:31", + "exit column 4:32", + "exit inverse 4:32", + "exit column 4:33", + "exit inverse 4:33", + "exit column 4:34", + "exit inverse 4:34", + "exit column 4:35", + "exit inverse 4:35", + "exit column 4:36", + "exit inverse 4:36", + "exit column 4:37", + "exit inverse 4:37", + "exit column 4:38", + "exit inverse 4:38", + "exit column 4:39", + "exit inverse 4:39", + "exit column 4:40", + "exit inverse 4:40", + "exit column 4:41", + "exit inverse 4:41", + "exit column 4:42", + "exit inverse 4:42", + "exit column 4:43", + "exit inverse 4:43", + "exit column 4:44", + "exit inverse 4:44", + "exit column 4:45", + "exit inverse 4:45", + "exit column 4:46", + "exit inverse 4:46", + "exit column 4:47", + "exit inverse 4:47", + "exit column 4:48", + "exit inverse 4:48", + "exit column 4:49", + "exit inverse 4:49", + "exit column 4:50", + "exit inverse 4:50", + "exit column 4:51", + "exit inverse 4:51", + "exit column 4:52", + "exit inverse 4:52", + "exit column 4:53", + "exit inverse 4:53", + "exit column 4:54", + "exit inverse 4:54", + "exit column 4:55", + "exit inverse 4:55", + "exit column 4:56", + "exit inverse 4:56", + "exit column 4:57", + "exit inverse 4:57", + "exit column 4:58", + "exit inverse 4:58", + "exit column 4:59", + "exit inverse 4:59", + "exit column 4:60", + "exit inverse 4:60", + "exit column 4:61", + "exit inverse 4:61", + "exit column 4:62", + "exit inverse 4:62", + "exit column 4:63", + "exit inverse 4:63", + "exit phase mutation 4", + "exit stream and port 5", + "exit rank and shape 5", + "exit column 5:0", + "exit inverse 5:0", + "exit column 5:1", + "exit inverse 5:1", + "exit column 5:2", + "exit inverse 5:2", + "exit column 5:3", + "exit inverse 5:3", + "exit column 5:4", + "exit inverse 5:4", + "exit column 5:5", + "exit inverse 5:5", + "exit column 5:6", + "exit inverse 5:6", + "exit column 5:7", + "exit inverse 5:7", + "exit column 5:8", + "exit inverse 5:8", + "exit column 5:9", + "exit inverse 5:9", + "exit column 5:10", + "exit inverse 5:10", + "exit column 5:11", + "exit inverse 5:11", + "exit column 5:12", + "exit inverse 5:12", + "exit column 5:13", + "exit inverse 5:13", + "exit column 5:14", + "exit inverse 5:14", + "exit column 5:15", + "exit inverse 5:15", + "exit column 5:16", + "exit inverse 5:16", + "exit column 5:17", + "exit inverse 5:17", + "exit column 5:18", + "exit inverse 5:18", + "exit column 5:19", + "exit inverse 5:19", + "exit column 5:20", + "exit inverse 5:20", + "exit column 5:21", + "exit inverse 5:21", + "exit column 5:22", + "exit inverse 5:22", + "exit column 5:23", + "exit inverse 5:23", + "exit column 5:24", + "exit inverse 5:24", + "exit column 5:25", + "exit inverse 5:25", + "exit column 5:26", + "exit inverse 5:26", + "exit column 5:27", + "exit inverse 5:27", + "exit column 5:28", + "exit inverse 5:28", + "exit column 5:29", + "exit inverse 5:29", + "exit column 5:30", + "exit inverse 5:30", + "exit column 5:31", + "exit inverse 5:31", + "exit column 5:32", + "exit inverse 5:32", + "exit column 5:33", + "exit inverse 5:33", + "exit column 5:34", + "exit inverse 5:34", + "exit column 5:35", + "exit inverse 5:35", + "exit column 5:36", + "exit inverse 5:36", + "exit column 5:37", + "exit inverse 5:37", + "exit column 5:38", + "exit inverse 5:38", + "exit column 5:39", + "exit inverse 5:39", + "exit column 5:40", + "exit inverse 5:40", + "exit column 5:41", + "exit inverse 5:41", + "exit column 5:42", + "exit inverse 5:42", + "exit column 5:43", + "exit inverse 5:43", + "exit column 5:44", + "exit inverse 5:44", + "exit column 5:45", + "exit inverse 5:45", + "exit column 5:46", + "exit inverse 5:46", + "exit column 5:47", + "exit inverse 5:47", + "exit column 5:48", + "exit inverse 5:48", + "exit column 5:49", + "exit inverse 5:49", + "exit column 5:50", + "exit inverse 5:50", + "exit column 5:51", + "exit inverse 5:51", + "exit column 5:52", + "exit inverse 5:52", + "exit column 5:53", + "exit inverse 5:53", + "exit column 5:54", + "exit inverse 5:54", + "exit column 5:55", + "exit inverse 5:55", + "exit column 5:56", + "exit inverse 5:56", + "exit column 5:57", + "exit inverse 5:57", + "exit column 5:58", + "exit inverse 5:58", + "exit column 5:59", + "exit inverse 5:59", + "exit column 5:60", + "exit inverse 5:60", + "exit column 5:61", + "exit inverse 5:61", + "exit column 5:62", + "exit inverse 5:62", + "exit column 5:63", + "exit inverse 5:63", + "exit phase mutation 5", + "exit stream and port 6", + "exit rank and shape 6", + "exit column 6:0", + "exit inverse 6:0", + "exit column 6:1", + "exit inverse 6:1", + "exit column 6:2", + "exit inverse 6:2", + "exit column 6:3", + "exit inverse 6:3", + "exit column 6:4", + "exit inverse 6:4", + "exit column 6:5", + "exit inverse 6:5", + "exit column 6:6", + "exit inverse 6:6", + "exit column 6:7", + "exit inverse 6:7", + "exit column 6:8", + "exit inverse 6:8", + "exit column 6:9", + "exit inverse 6:9", + "exit column 6:10", + "exit inverse 6:10", + "exit column 6:11", + "exit inverse 6:11", + "exit column 6:12", + "exit inverse 6:12", + "exit column 6:13", + "exit inverse 6:13", + "exit column 6:14", + "exit inverse 6:14", + "exit column 6:15", + "exit inverse 6:15", + "exit column 6:16", + "exit inverse 6:16", + "exit column 6:17", + "exit inverse 6:17", + "exit column 6:18", + "exit inverse 6:18", + "exit column 6:19", + "exit inverse 6:19", + "exit column 6:20", + "exit inverse 6:20", + "exit column 6:21", + "exit inverse 6:21", + "exit column 6:22", + "exit inverse 6:22", + "exit column 6:23", + "exit inverse 6:23", + "exit column 6:24", + "exit inverse 6:24", + "exit column 6:25", + "exit inverse 6:25", + "exit column 6:26", + "exit inverse 6:26", + "exit column 6:27", + "exit inverse 6:27", + "exit column 6:28", + "exit inverse 6:28", + "exit column 6:29", + "exit inverse 6:29", + "exit column 6:30", + "exit inverse 6:30", + "exit column 6:31", + "exit inverse 6:31", + "exit column 6:32", + "exit inverse 6:32", + "exit column 6:33", + "exit inverse 6:33", + "exit column 6:34", + "exit inverse 6:34", + "exit column 6:35", + "exit inverse 6:35", + "exit column 6:36", + "exit inverse 6:36", + "exit column 6:37", + "exit inverse 6:37", + "exit column 6:38", + "exit inverse 6:38", + "exit column 6:39", + "exit inverse 6:39", + "exit column 6:40", + "exit inverse 6:40", + "exit column 6:41", + "exit inverse 6:41", + "exit column 6:42", + "exit inverse 6:42", + "exit column 6:43", + "exit inverse 6:43", + "exit column 6:44", + "exit inverse 6:44", + "exit column 6:45", + "exit inverse 6:45", + "exit column 6:46", + "exit inverse 6:46", + "exit column 6:47", + "exit inverse 6:47", + "exit column 6:48", + "exit inverse 6:48", + "exit column 6:49", + "exit inverse 6:49", + "exit column 6:50", + "exit inverse 6:50", + "exit column 6:51", + "exit inverse 6:51", + "exit column 6:52", + "exit inverse 6:52", + "exit column 6:53", + "exit inverse 6:53", + "exit column 6:54", + "exit inverse 6:54", + "exit column 6:55", + "exit inverse 6:55", + "exit column 6:56", + "exit inverse 6:56", + "exit column 6:57", + "exit inverse 6:57", + "exit column 6:58", + "exit inverse 6:58", + "exit column 6:59", + "exit inverse 6:59", + "exit column 6:60", + "exit inverse 6:60", + "exit column 6:61", + "exit inverse 6:61", + "exit column 6:62", + "exit inverse 6:62", + "exit column 6:63", + "exit inverse 6:63", + "exit phase mutation 6", + "exit stream and port 7", + "exit rank and shape 7", + "exit column 7:0", + "exit inverse 7:0", + "exit column 7:1", + "exit inverse 7:1", + "exit column 7:2", + "exit inverse 7:2", + "exit column 7:3", + "exit inverse 7:3", + "exit column 7:4", + "exit inverse 7:4", + "exit column 7:5", + "exit inverse 7:5", + "exit column 7:6", + "exit inverse 7:6", + "exit column 7:7", + "exit inverse 7:7", + "exit column 7:8", + "exit inverse 7:8", + "exit column 7:9", + "exit inverse 7:9", + "exit column 7:10", + "exit inverse 7:10", + "exit column 7:11", + "exit inverse 7:11", + "exit column 7:12", + "exit inverse 7:12", + "exit column 7:13", + "exit inverse 7:13", + "exit column 7:14", + "exit inverse 7:14", + "exit column 7:15", + "exit inverse 7:15", + "exit column 7:16", + "exit inverse 7:16", + "exit column 7:17", + "exit inverse 7:17", + "exit column 7:18", + "exit inverse 7:18", + "exit column 7:19", + "exit inverse 7:19", + "exit column 7:20", + "exit inverse 7:20", + "exit column 7:21", + "exit inverse 7:21", + "exit column 7:22", + "exit inverse 7:22", + "exit column 7:23", + "exit inverse 7:23", + "exit column 7:24", + "exit inverse 7:24", + "exit column 7:25", + "exit inverse 7:25", + "exit column 7:26", + "exit inverse 7:26", + "exit column 7:27", + "exit inverse 7:27", + "exit column 7:28", + "exit inverse 7:28", + "exit column 7:29", + "exit inverse 7:29", + "exit column 7:30", + "exit inverse 7:30", + "exit column 7:31", + "exit inverse 7:31", + "exit column 7:32", + "exit inverse 7:32", + "exit column 7:33", + "exit inverse 7:33", + "exit column 7:34", + "exit inverse 7:34", + "exit column 7:35", + "exit inverse 7:35", + "exit column 7:36", + "exit inverse 7:36", + "exit column 7:37", + "exit inverse 7:37", + "exit column 7:38", + "exit inverse 7:38", + "exit column 7:39", + "exit inverse 7:39", + "exit column 7:40", + "exit inverse 7:40", + "exit column 7:41", + "exit inverse 7:41", + "exit column 7:42", + "exit inverse 7:42", + "exit column 7:43", + "exit inverse 7:43", + "exit column 7:44", + "exit inverse 7:44", + "exit column 7:45", + "exit inverse 7:45", + "exit column 7:46", + "exit inverse 7:46", + "exit column 7:47", + "exit inverse 7:47", + "exit column 7:48", + "exit inverse 7:48", + "exit column 7:49", + "exit inverse 7:49", + "exit column 7:50", + "exit inverse 7:50", + "exit column 7:51", + "exit inverse 7:51", + "exit column 7:52", + "exit inverse 7:52", + "exit column 7:53", + "exit inverse 7:53", + "exit column 7:54", + "exit inverse 7:54", + "exit column 7:55", + "exit inverse 7:55", + "exit column 7:56", + "exit inverse 7:56", + "exit column 7:57", + "exit inverse 7:57", + "exit column 7:58", + "exit inverse 7:58", + "exit column 7:59", + "exit inverse 7:59", + "exit column 7:60", + "exit inverse 7:60", + "exit column 7:61", + "exit inverse 7:61", + "exit column 7:62", + "exit inverse 7:62", + "exit column 7:63", + "exit inverse 7:63", + "exit phase mutation 7", + "ADD sign mutation changes physical endpoint", + "child phase mutation changes physical endpoint" + ] +} diff --git a/research/prepared-growing-carrier/review/RELOCATION-RECEIPT.json b/research/prepared-growing-carrier/review/RELOCATION-RECEIPT.json new file mode 100644 index 0000000000..86dcd071dc --- /dev/null +++ b/research/prepared-growing-carrier/review/RELOCATION-RECEIPT.json @@ -0,0 +1,233 @@ +{ + "status": "PASS_RELOCATED_ISOLATED_ENVIRONMENT", + "command_shape": "python3 -I -B RELOCATED_PACKAGE/verify.py --build NEW_DIRECTORY", + "environment": "PYTHONOPTIMIZE=1", + "returncode": 0, + "final_line": "PASS_PREPARED_GROWING_CARRIER 704 55 8", + "receipt": { + "status": "PASS_PREPARED_GROWING_CARRIER", + "stages": [ + "construct", + "exits", + "independent" + ], + "independent": { + "status": "PASS_INDEPENDENT_GROWING_CAP_WORD", + "word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "clifford_source_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "builder_imported": false, + "lower_child_called": false, + "canonical_frame_definitions_shared": true, + "separate_integer_gaussian_interpreter": true, + "scalar_input_columns": 11, + "recipe_basis_columns": 1472, + "whole_physical_basis_columns": 704, + "inverse_round_trip_columns": 704, + "all_moves_strict_nested_ascents": true, + "full_common_labels_at_adds": true, + "future_targets_compatible_before_each_source_move": true, + "sources_unchanged_in_scalar_replay": true, + "target_rows_exact": true, + "literal_events": 39, + "scalar_add_reads": 12, + "paid_child_calls": 27, + "distinct_recipe_lowerings": 23, + "paid_profile": { + "1": 15, + "2": 2, + "3": 5, + "4": 4, + "5": 1 + }, + "paid_rank_mass": 55, + "paid_rank_by_register": [ + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5 + ], + "copies": 0, + "source_line_bridge_equals_C_e": [ + true, + true, + true + ], + "target_endpoint_bridges": [ + { + "q": 21, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 22, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 25, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 26, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 37, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 38, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 41, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 42, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + } + ], + "target_exit_adapters_in_frozen_word": false, + "fixed_last_cap_counterexamples": [ + { + "source": 0, + "target": 1, + "q": 22, + "read_cap": [ + 1 + ], + "last_read_cap": [ + 16, + 1 + ] + }, + { + "source": 0, + "target": 3, + "q": 26, + "read_cap": [ + 1 + ], + "last_read_cap": [ + 16, + 1 + ] + }, + { + "source": 1, + "target": 2, + "q": 25, + "read_cap": [ + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 1, + "target": 6, + "q": 41, + "read_cap": [ + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 1, + "target": 3, + "q": 26, + "read_cap": [ + 4, + 1 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 4, + "q": 37, + "read_cap": [ + 16 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 5, + "q": 38, + "read_cap": [ + 16 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 6, + "q": 41, + "read_cap": [ + 16, + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + } + ], + "three_selector_analogue_charges_per_carrier": [ + "3/2", + "2", + "2" + ], + "phase_mutant_rejected": true, + "scope": "One finite canonical-frame decoder. No complete scalar factory, legacy exit adapter word, global owner controller, supplier or kappa gain is checked." + }, + "source_manifest_sha256": "5fe4a164c6c2e0a61f049081abe825179a4ee46f6995f2e122609d52a8851855", + "portable_checker_sha256": "3f1c36505bb7283f8e1ab86129272d1db1fbc66cf0c0c5e284dfac09155c2022", + "legacy_exits": { + "status": "PASS_EXACT_MONOMIAL_EXITS", + "original_word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "word_sha256": "88f5291e223d99a1d3a883b04f0caa7f7981e9a29086bd07fadc5694f95c241d", + "exits": 8, + "rank_zero_exits": 8, + "address_columns_checked": 512, + "full_global_phase": true, + "extra_paid_rank": 0, + "scope": "The finite decoder has the stated legacy exits. It is not a full factory or parent supplier." + } + } +} diff --git a/research/prepared-growing-carrier/review/REPLAY-RECEIPT.json b/research/prepared-growing-carrier/review/REPLAY-RECEIPT.json new file mode 100644 index 0000000000..043acaaa1c --- /dev/null +++ b/research/prepared-growing-carrier/review/REPLAY-RECEIPT.json @@ -0,0 +1,226 @@ +{ + "status": "PASS_PREPARED_GROWING_CARRIER", + "stages": [ + "construct", + "exits", + "independent" + ], + "independent": { + "status": "PASS_INDEPENDENT_GROWING_CAP_WORD", + "word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "clifford_source_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "builder_imported": false, + "lower_child_called": false, + "canonical_frame_definitions_shared": true, + "separate_integer_gaussian_interpreter": true, + "scalar_input_columns": 11, + "recipe_basis_columns": 1472, + "whole_physical_basis_columns": 704, + "inverse_round_trip_columns": 704, + "all_moves_strict_nested_ascents": true, + "full_common_labels_at_adds": true, + "future_targets_compatible_before_each_source_move": true, + "sources_unchanged_in_scalar_replay": true, + "target_rows_exact": true, + "literal_events": 39, + "scalar_add_reads": 12, + "paid_child_calls": 27, + "distinct_recipe_lowerings": 23, + "paid_profile": { + "1": 15, + "2": 2, + "3": 5, + "4": 4, + "5": 1 + }, + "paid_rank_mass": 55, + "paid_rank_by_register": [ + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5 + ], + "copies": 0, + "source_line_bridge_equals_C_e": [ + true, + true, + true + ], + "target_endpoint_bridges": [ + { + "q": 21, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 22, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 25, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 26, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 37, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 38, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 41, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + }, + { + "q": 42, + "canonical_equals_legacy_endpoint": false, + "exit_correction_rank": 0 + } + ], + "target_exit_adapters_in_frozen_word": false, + "fixed_last_cap_counterexamples": [ + { + "source": 0, + "target": 1, + "q": 22, + "read_cap": [ + 1 + ], + "last_read_cap": [ + 16, + 1 + ] + }, + { + "source": 0, + "target": 3, + "q": 26, + "read_cap": [ + 1 + ], + "last_read_cap": [ + 16, + 1 + ] + }, + { + "source": 1, + "target": 2, + "q": 25, + "read_cap": [ + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 1, + "target": 6, + "q": 41, + "read_cap": [ + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 1, + "target": 3, + "q": 26, + "read_cap": [ + 4, + 1 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 4, + "q": 37, + "read_cap": [ + 16 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 5, + "q": 38, + "read_cap": [ + 16 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + }, + { + "source": 2, + "target": 6, + "q": 41, + "read_cap": [ + 16, + 4 + ], + "last_read_cap": [ + 16, + 4, + 1 + ] + } + ], + "three_selector_analogue_charges_per_carrier": [ + "3/2", + "2", + "2" + ], + "phase_mutant_rejected": true, + "scope": "One finite canonical-frame decoder. No complete scalar factory, legacy exit adapter word, global owner controller, supplier or kappa gain is checked." + }, + "source_manifest_sha256": "5fe4a164c6c2e0a61f049081abe825179a4ee46f6995f2e122609d52a8851855", + "portable_checker_sha256": "3f1c36505bb7283f8e1ab86129272d1db1fbc66cf0c0c5e284dfac09155c2022", + "legacy_exits": { + "status": "PASS_EXACT_MONOMIAL_EXITS", + "original_word_sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "word_sha256": "88f5291e223d99a1d3a883b04f0caa7f7981e9a29086bd07fadc5694f95c241d", + "exits": 8, + "rank_zero_exits": 8, + "address_columns_checked": 512, + "full_global_phase": true, + "extra_paid_rank": 0, + "scope": "The finite decoder has the stated legacy exits. It is not a full factory or parent supplier." + } +} diff --git a/research/prepared-growing-carrier/review/RESULT.json b/research/prepared-growing-carrier/review/RESULT.json new file mode 100644 index 0000000000..516f6ef083 --- /dev/null +++ b/research/prepared-growing-carrier/review/RESULT.json @@ -0,0 +1,31 @@ +{ + "status": "PASS_NO_MATERIAL_FINDINGS", + "reviewer": "Separate OpenAI Codex agent; not human review", + "package_files": 25, + "unchanged_source_files": 18, + "base_events": 39, + "scalar_adds": 12, + "paid_children": 27, + "rank_profile": { + "1": 15, + "2": 2, + "3": 5, + "4": 4, + "5": 1 + }, + "rank_mass": 55, + "applied_base_monomial_records": 54, + "exit_monomial_records": 8, + "copies": 0, + "recipe_columns": 1472, + "whole_word_columns": 704, + "inverse_columns": 704, + "independent_exit_columns": 512, + "independent_exit_inverse_columns": 512, + "mutations_and_pin_guards": "PASS", + "relocated_isolated_replay": "PASS with PYTHONOPTIMIZE=1", + "kappa_improvement": false, + "useful_scope": "Prepared-input local complex decoder with growing compatible carrier frames and exact optional legacy exits.", + "review_sha256": "b041aaa2def4fc9ccf05db7a92772634821317ec8df59c541c2007b6e5da304f", + "checked_files_sha256": "75224e31892dfcea29840dd95a806e9f664bfc8f7d28d86d7d0adc964c356050" +} diff --git a/research/prepared-growing-carrier/review/REVIEW.txt b/research/prepared-growing-carrier/review/REVIEW.txt new file mode 100644 index 0000000000..3bc9761131 --- /dev/null +++ b/research/prepared-growing-carrier/review/REVIEW.txt @@ -0,0 +1,144 @@ +Independent agent review: prepared growing carriers +================================================== + +Result: PASS. No material finding remains in the stated local scope. +This is a separate OpenAI Codex agent review, not human peer review or a +proof-assistant result. I read PR-DESCRIPTION-STANDARD.md before this report. + +What the result supplies +------------------------ +The package gives one finite complex decoder on eleven streams of 64 +values. Three carrier inputs have the specified line-frame interface. +All eight target inputs are arbitrary; a zero target frame means the +identity operator, not a zero value. In scalar coordinates it implements + +X_i -> X_i, +Y_t -> Y_t + sum_i bit_i(t) X_i. + +The physical carriers finish in the full frame, so they are not returned +as the same physical arrays. Each target finishes in its canonical +q(t)-perpendicular frame. The separate saved extension changes those eight +target operators to F C_q^-1 with exact monomial adapters. + +The new capability is an explicit legal schedule in which a carrier can +grow after an earlier target is served. One final read frame does not fit +all earlier reads. This invalidates an extension of fixed-read-frame +counting to arbitrary growing frames. It does not invalidate the stated +fixed-frame theorem or prove a bound for every decoder. + +Exact local account +------------------- +There are 39 base events: 12 scalar ADD scans and 27 positive-rank children. +Their profile is 15 H_1 + 2 H_2 + 5 H_3 + 4 H_4 + H_5, with rank mass 55. +The 27 calls use 23 distinct saved recipes. Each applied positive-rank +recipe has left and right monomial factors: 54 applied monomial records +in the base word. There is no COPY. The saved extension adds eight more +monomial records and zero positive child rank. This count of records is +not a primitive-operation invoice. + +Every stream pays five units of rank growth. A carrier grows from rank +one to rank six; a target grows from rank zero to rank five. All moves are +strict nested ascents. This explains 3*5 + 8*5 = 55 without omitting a +nonmonotone transition. + +The count assumes the prepared carrier interface. It does not price the +source factory, initial frame preparation, scalar or monomial primitives, +routing, workspace management, precision, owner controller, or recursive +hosting. No complete supplier, strict total-cost improvement, or verified +kappa improvement follows. + +Proof and source review +----------------------- +I read the frozen proof, literal builder, saved exit builder, portable +checker, wrapper, all canonical Clifford definitions, and source ledger. +All 18 historical package sources match both their manifest hashes and +their existing original files byte for byte. The consumed Clifford source +also matches the public Git object + +e07a8a3f9f79c22113398a0c5dbbc7601f489b3e:research/direct-delivery504-global/vendor/clifford/clifford_exact.py + +with SHA256 2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962. +The old checker and portable replay differ only in input/output path +handling, argument parsing, and an optimization guard. + +For a child, the serialized execution order is right monomial, rank-r +Fourier child, then left monomial. The separate Gaussian-integer +interpreter checks the complete matrix, including global phase. Its +arithmetic uses integers and powers of two, not floating point. Its D +adjoint negates linear Z4 coefficients; the cross terms have coefficient +two and keep the same residue. Permutations and C gates have explicit +inverses. ADD inverses negate the scalar coefficient in reverse order. + +At an ADD, both registers have the same full canonical label. Thus the +invariant physical_value = T_frame scalar_value gives the stated scalar +endpoint. All pending target ports remain compatible before a carrier +move. The proof removes only targets already served. The final target +frames equal the intended hyperplanes. + +The separate finite checker tests all 704 independent physical input +columns. Its operations are complex-linear, so these basis columns imply +the displayed endpoint for arbitrary complex inputs, including all +original target values. Inverse round trips verify the exact inverse +word. They do not change the forward carrier restoration contract. + +Fresh replay and controls +------------------------- +Command, from the project root: + +python3 -B work/project-final-cleanup-20261022/early-projects-audit/packages/prepared-growing-carrier/verify.py --build /tmp/prepared-carrier-independent-review-20261023 + +Result: + +PASS_PREPARED_GROWING_CARRIER 704 55 8 + +The wrapper reproduced both saved words and receipts byte for byte. The +independent checker passed 1472 recipe basis columns, 704 full-word columns, +and 704 inverse columns. It also passed the source-line bridges, all label +and pending-target checks, exact rank profile, and phase mutation. +REPLAY-RECEIPT.json and replay.log retain the run. + +Additional review command: + +python3 -B work/project-final-cleanup-20261022/reviews/prepared-carrier/controls.py work/project-final-cleanup-20261022/early-projects-audit/packages/prepared-growing-carrier work/project-final-cleanup-20261022/reviews/prepared-carrier/CONTROLS.json + +This uses the separate Gaussian interpreter to parse the saved exit +monomials. All 512 exit columns equal the stated legacy target operator, +and all 512 exit inverse columns return their input. The eight exits are +after every ADD and preserve all base events. Every phase-mutated exit is +rejected. A base ADD sign mutation and a base child phase mutation change +the physical endpoint. Optimized Python, changed word/compiler/source +pins, occupied output paths, and overwritten receipts are rejected. +CONTROLS.json gives the exact checks; its 1066 checks include individual +basis-column assertions, not 1066 independent mutation cases. + +A second fresh replay from a relocated package passed with an isolated +parent and PYTHONOPTIMIZE=1. Child commands use -E -B, so the historical +assertions remain enabled. RELOCATION-RECEIPT.json records that check. + +Overlap, credit, and limits +-------------------------- +I checked the supplied comparison with shared-carrier-decoder at main +cef4b52f2a59009865bf8eabde1be3f159063703. That module has 452 dirty helpers, +a different P111 endpoint, and a nonzero COPY; it is not this prepared +three-carrier component. Searches of current research proof/README files, +paths, and the supplied 315-open-PR snapshot found no duplicate of this +exact growing-carrier word. + +The package retains the consumed Clifford notices and source ledgers, +credits the historical PR518 source copy and exact PR531 public bytes, +and discloses Codex and research-agent assistance. The coordinator must +check final GitHub link targets, description rendering, and readback. + +The included historical delivery-flags proof is context for the fixed-frame +restriction. I did not rerun its separate dynamic programs or certify its +numerical ceilings in this review. The local growing-frame counterexample +does not depend on those numerical claims. No whole source factory, +controller, physical primitive invoice, proof-assistant certificate, or +complete kappa calculation was checked. + +The one wording finding was corrected: the README no longer says this +package preserves a proved rank saving against an unspecified baseline. +It asks whether a complete composition can give a favorable cost. + +CHECKED-FILES.json binds the exact publication files reviewed. Later edits +to proof or executable content require a focused recheck. diff --git a/research/prepared-growing-carrier/review/SOURCE-CHECK.json b/research/prepared-growing-carrier/review/SOURCE-CHECK.json new file mode 100644 index 0000000000..f4f03e189a --- /dev/null +++ b/research/prepared-growing-carrier/review/SOURCE-CHECK.json @@ -0,0 +1,117 @@ +{ + "status": "PASS", + "sources": [ + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/PROOF.md", + "sha256": "90f799133f1018e9ad6dbc8c232b1cc081170fc67c72fcd3ab1048dacc3093a8", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/check.py", + "sha256": "5bbb842f74b0dff8ecbe7756a0a83937d89c853dcf7813a406b51a782949b165", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/FROZEN-WORD.json", + "sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/SOURCE-PINS.json", + "sha256": "e5bc79fb24e4c4b9c4821db8130a97ee707d5148c58252147658306a0f177ed8", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/VERIFICATION.json", + "sha256": "f780153c2dbf4d269eca1847117fc849c002f6138dde8f43de354551e800aa08", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/autonomous-kappa-run/growing-cycle-independent/RESULT.json", + "sha256": "8f731e0d989273c00cd11fcb84e0da9bc8ef78412ce099656bd47b9b74008456", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/complex/paired-five/growing_cycle.py", + "sha256": "fef1dc7c979b39235b6ef41396835f8778548e702b4e085aec10e3d5cdcafe58", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json", + "sha256": "15d7b2143c360357a1f372926b1ff77378b48099118fa8b506d752daf7f33da5", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-RESULT.json", + "sha256": "9800893733d820aaae969716d106c2aefcaee3a36d5a4b42d614a244af4dc6f7", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/complex/paired-five/add_growing_exits.py", + "sha256": "67893edbbdfd380ccd9270954f9e76ae023c27787cad92bb0e5c6eaaafe997c6", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-WORD.json", + "sha256": "88f5291e223d99a1d3a883b04f0caa7f7981e9a29086bd07fadc5694f95c241d", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-RESULT.json", + "sha256": "039950b8d9318c8bb4f61b31923e7843d241d0465a0a8705ba75003faed79854", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/complex/paired-five/independent/DELIVERY-FLAGS-PROOF.md", + "sha256": "a75a50aeae792a1b67c9b3b1cb5c95bfd6a3cf56cf1c3dfed304a7088118887e", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/source/research/nodal-pair-async/NOTICE.md", + "sha256": "ec590608ddae58b227fe28040c29cd026699e2e5c26faad63da71a79dc50e159", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "historical/work/p518-next/source/research/nodal-pair-async/SOURCES.json", + "sha256": "e82688d40483797d7fb5599cde3502018f9bf56acf66a803a7c6a497e885d7db", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "public-source/NOTICE.md", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1", + "origin_exists": true, + "origin_bytes_equal": true + }, + { + "path": "public-source/SOURCES.json", + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f", + "origin_exists": true, + "origin_bytes_equal": true + } + ], + "public_clifford": { + "git_object": "e07a8a3f9f79c22113398a0c5dbbc7601f489b3e:research/direct-delivery504-global/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } +} diff --git a/research/prepared-growing-carrier/review/controls.log b/research/prepared-growing-carrier/review/controls.log new file mode 100644 index 0000000000..750d118ecd --- /dev/null +++ b/research/prepared-growing-carrier/review/controls.log @@ -0,0 +1 @@ +PASS_PREPARED_CARRIER_CONTROLS 512 512 1066 diff --git a/research/prepared-growing-carrier/review/controls.py b/research/prepared-growing-carrier/review/controls.py new file mode 100644 index 0000000000..06bcda0e8f --- /dev/null +++ b/research/prepared-growing-carrier/review/controls.py @@ -0,0 +1,102 @@ +"""Check frozen pins, exit adapters, and finite decoder mutations.""" +import contextlib +import io +import json +import os +from pathlib import Path +import runpy +import shutil +import subprocess +import sys +import tempfile + +package = Path(sys.argv[1]).resolve() +output = Path(sys.argv[2]).resolve() +checks = [] +def require(value, label): + if not value: + raise RuntimeError(label) + checks.append(label) + +def reject(command, label, expected=None, env=None): + result = subprocess.run(command, capture_output=True, text=True, env=env) + require(result.returncode != 0, label) + if expected is not None: + require(expected in result.stdout + result.stderr, label + ': stated error') + +word = package / 'historical/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json' +exitword = package / 'historical/work/p518-next/complex/paired-five/GROWING-CYCLE-LEGACY-EXITS-WORD.json' +clifford = package / 'historical/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py' +with tempfile.TemporaryDirectory(prefix='prepared-carrier-controls-') as directory: + tmp = Path(directory) + reject([sys.executable,'-O','-B',str(package/'verify.py'),'--build',str(tmp/'optimized')], 'optimized wrapper rejected', 'without -O') + reject([sys.executable,'-O','-B',str(package/'replay.py')], 'optimized checker rejected', 'without -O') + occupied = tmp/'occupied' + occupied.mkdir() + (occupied/'sentinel').write_text('retained') + reject([sys.executable,'-B',str(package/'verify.py'),'--build',str(occupied)], 'occupied build rejected', 'build directory exists') + require((occupied/'sentinel').read_text() == 'retained', 'occupied directory unchanged') + copied = tmp/'package' + shutil.copytree(package,copied) + changed = copied/word.relative_to(package) + changed.write_bytes(changed.read_bytes() + b'\n') + reject([sys.executable,'-B',str(copied/'verify.py'),'--build',str(tmp/'mutated')], 'changed frozen source rejected', 'Source hash:') + reject([sys.executable,'-B',str(package/'replay.py'),'--word',str(changed),'--clifford',str(clifford),'--output',str(tmp/'bad-result.json')], 'changed word pin rejected') + corrupt = tmp/'clifford.py' + corrupt.write_bytes(clifford.read_bytes() + b'\n') + reject([sys.executable,'-B',str(package/'replay.py'),'--word',str(word),'--clifford',str(corrupt),'--output',str(tmp/'bad-clifford.json')], 'changed compiler pin rejected') + frozen_output = tmp/'existing.json' + frozen_output.write_text('retained') + reject([sys.executable,'-B',str(package/'replay.py'),'--word',str(word),'--clifford',str(clifford),'--output',str(frozen_output)], 'occupied receipt rejected', 'output file exists') + require(frozen_output.read_text() == 'retained', 'occupied receipt unchanged') + + old_argv = sys.argv + sys.argv = [str(package/'replay.py'),'--word',str(word),'--clifford',str(clifford),'--output',str(tmp/'base-result.json')] + try: + with contextlib.redirect_stdout(io.StringIO()): + g = runpy.run_path(str(package/'replay.py'),run_name='__main__') + finally: + sys.argv = old_argv + exits = json.loads(exitword.read_bytes()) + require(exits['events'][:len(g['w']['events'])] == g['w']['events'], 'exit extension keeps every base event') + require(exits['events'][len(g['w']['events']):] == [['monomial_exit',3+t,t] for t in range(8)], 'eight exits occur after every ADD') + columns = inverse_columns = 0 + for t,item in enumerate(exits['exit_adapters']): + require(item['stream'] == 3+t and item['port'] == g['w']['target_ports'][t], 'exit stream and port '+str(t)) + record = item['recipe'] + require(record['rank'] == 0 and record['right'] is None, 'exit rank and shape '+str(t)) + circuit = g['monomial'](record['left']) + cap = tuple(g['w']['final_frames'][3+t]) + goal = g['cx'].cgate(6,item['port']).adjoint().then(g['cx'].fourier(6)).circuit + for state in g['basis']: + old = g['apply'](g['canonical'][cap],state) + new = g['apply'](circuit,old) + require(new == g['apply'](goal,state), 'exit column '+str(t)+':'+str(columns%64)) + require(g['apply'](g['adjoint'](circuit),new) == old, 'exit inverse '+str(t)+':'+str(inverse_columns%64)) + columns += 1 + inverse_columns += 1 + require(g['apply'](circuit + [('phase',1)],g['basis'][0]) != g['apply'](circuit,g['basis'][0]), 'exit phase mutation '+str(t)) + + events = g['w']['events'] + at = next(i for i,e in enumerate(events) if e[0] == 'add') + event = events[at] + start = [g['zero']]*11 + start[event[2]] = g['basis'][0] + expected = g['replay'](start) + saved = event[3] + event[3] = -saved + require(g['replay'](start) != expected, 'ADD sign mutation changes physical endpoint') + event[3] = saved + child = next(e for e in events if e[0] == 'child') + key = tuple(child[2]),tuple(child[3]) + start = [g['zero']]*11 + start[child[1]] = g['basis'][0] + expected = g['replay'](start) + saved = g['recipes'][key] + g['recipes'][key] = saved + [('phase',1)] + require(g['replay'](start) != expected, 'child phase mutation changes physical endpoint') + g['recipes'][key] = saved + +result = {'status':'PASS_PREPARED_CARRIER_CONTROLS','exit_columns':columns,'exit_inverse_columns':inverse_columns,'all_checks':len(checks),'checks':checks} +output.write_text(json.dumps(result,indent=2)+'\n') +print('PASS_PREPARED_CARRIER_CONTROLS',columns,inverse_columns,len(checks)) diff --git a/research/prepared-growing-carrier/review/replay.log b/research/prepared-growing-carrier/review/replay.log new file mode 100644 index 0000000000..f68f266c0f --- /dev/null +++ b/research/prepared-growing-carrier/review/replay.log @@ -0,0 +1,4 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /private/tmp/prepared-carrier-independent-review-20261023/work/p518-next/complex/paired-five/growing_cycle.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /private/tmp/prepared-carrier-independent-review-20261023/work/p518-next/complex/paired-five/add_growing_exits.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/prepared-growing-carrier/replay.py --word /private/tmp/prepared-carrier-independent-review-20261023/work/p518-next/complex/paired-five/GROWING-CYCLE-WORD.json --clifford /private/tmp/prepared-carrier-independent-review-20261023/work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py --output /private/tmp/prepared-carrier-independent-review-20261023/independent-result.json +PASS_PREPARED_GROWING_CARRIER 704 55 8 diff --git a/research/prepared-growing-carrier/verify.py b/research/prepared-growing-carrier/verify.py new file mode 100644 index 0000000000..f889a23474 --- /dev/null +++ b/research/prepared-growing-carrier/verify.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python3 +"""Repeat the saved construction and independent finite check.""" +import argparse +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import sys + +if not __debug__: + raise SystemExit("Run this verifier without -O. Historical sources use assert.") +ROOT = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--build", type=Path, required=True) + args = parser.parse_args() + build = args.build.resolve() + require(not build.exists(), "The build directory exists.") + manifest = json.loads((ROOT / "SOURCE-MANIFEST.json").read_text()) + for item in manifest["files"]: + require(hashlib.sha256((ROOT / item["package"]).read_bytes()).hexdigest() + == item["sha256"], "Source hash: " + item["package"]) + shutil.copytree(ROOT / "historical", build) + primary = build / "work/p518-next/complex/paired-five" + independent = build / "work/autonomous-kappa-run/growing-cycle-independent" + clifford = build / "work/p518-next/source/research/nodal-pair-async/inputs/work/odd-stages/clifford_exact.py" + stages = [] + def run(name, command): + print("Run:", " ".join(map(str, command)), flush=True) + with (build / (name + ".stdout.log")).open("w") as out, (build / (name + ".stderr.log")).open("w") as err: + subprocess.run(list(map(str, command)), stdout=out, stderr=err, check=True) + stages.append(name) + run("construct", [sys.executable, "-E", "-B", primary / "growing_cycle.py"]) + run("exits", [sys.executable, "-E", "-B", primary / "add_growing_exits.py"]) + for name in ["GROWING-CYCLE-WORD.json", "GROWING-CYCLE-RESULT.json", + "GROWING-CYCLE-LEGACY-EXITS-WORD.json", "GROWING-CYCLE-LEGACY-EXITS-RESULT.json"]: + frozen = ROOT / "historical/work/p518-next/complex/paired-five" / name + require((primary / name).read_bytes() == frozen.read_bytes(), "Saved construction: " + name) + result_path = build / "independent-result.json" + run("independent", [sys.executable, "-E", "-B", ROOT / "replay.py", "--word", + primary / "GROWING-CYCLE-WORD.json", "--clifford", clifford, + "--output", result_path]) + actual = json.loads(result_path.read_text()) + expected = json.loads((independent / "RESULT.json").read_text()) + for value in [actual, expected]: + value.pop("checker_sha256") + require(actual == expected, "Historical independent result") + result = {"status": "PASS_PREPARED_GROWING_CARRIER", "stages": stages, + "independent": actual, + "source_manifest_sha256": hashlib.sha256((ROOT / "SOURCE-MANIFEST.json").read_bytes()).hexdigest(), + "portable_checker_sha256": hashlib.sha256((ROOT / "replay.py").read_bytes()).hexdigest(), + "legacy_exits": json.loads((primary / "GROWING-CYCLE-LEGACY-EXITS-RESULT.json").read_text())} + (build / "receipt.json").write_text(json.dumps(result, indent=2) + "\n") + print("PASS_PREPARED_GROWING_CARRIER 704 55 8") + + +if __name__ == "__main__": + main()