diff --git a/research/t74-low-alias-borrowing/.gitattributes b/research/t74-low-alias-borrowing/.gitattributes new file mode 100644 index 0000000000..f82e427c0e --- /dev/null +++ b/research/t74-low-alias-borrowing/.gitattributes @@ -0,0 +1,2 @@ +# Preserve exact PR2269 bytes (CRLF) so the pinned git blob ids in SOURCES.json stay valid. +vendor/pr2269/*.py -text diff --git a/research/t74-low-alias-borrowing/README.md b/research/t74-low-alias-borrowing/README.md new file mode 100644 index 0000000000..fd19c7a622 --- /dev/null +++ b/research/t74-low-alias-borrowing/README.md @@ -0,0 +1,242 @@ +# PR2226 low (anticipatory) aliases on the T74 pivot-566+554 borrow words + +**Construction (local, verified) plus exact packing ceiling and model prices. No kappa claim.** PR2269 (Jeremy Kothe) put +43 **high** PR2226 aliases on both T74 local words (`gauge44` "base" and `extra`). This +package adds PR2226's **32 low (anticipatory) aliases** and the **5 high aliases that PR2269 +omitted** to both words. Each word now has 80 aliases. The 32 low aliases come with the +64 initial compensation terms `c K_G z`. + +| word | aliases | helpers | local paid profile | local mass | +|---|---|---|---|---| +| gauge44, PR2269 (43 high) | 43 | 437 | `{1:2351,2:501,3:414,4:129,5:42,8:8}` | 5385 | +| gauge44 + 32 low | 75 | 405 | `{1:2303,2:527,3:386,4:125,5:42,8:8}` | 5289 | +| gauge44 + 5 high | 48 | 432 | `{1:2351,2:501,3:414,4:129,5:37,8:8}` | 5360 | +| **gauge44, this package (80)** | 80 | **400** | **`{1:2303,2:527,3:386,4:125,5:37,8:8}`** | **5264** | +| extra, PR2269 (43 high) | 43 | 437 | `{1:2339,2:509,3:418,4:125,5:42,8:8}` | 5385 | +| extra + 32 low | 75 | 405 | `{1:2287,2:535,3:386,4:125,5:42,8:8}` | 5289 | +| extra + 5 high | 48 | 432 | `{1:2339,2:509,3:418,4:125,5:37,8:8}` | 5360 | +| **extra, this package (80)** | 80 | **400** | **`{1:2287,2:535,3:386,4:125,5:37,8:8}`** | **5264** | + +Change per call: −121 rank units, i.e. −96 from the low aliases and −25 from the five high +aliases. COPY64 is still included. Each word has 624 independent input columns and 44 private +FULL-cleanup zero buffers (PR2269 had 76). The identity `mass = 1856 + sum of helper widths` +still holds: width inventory `{4:4,5:4,7:36,8:84,9:272}`, sum 3408. + +All 16 low helpers that were not aliased are blocked by one exact condition: no lender is +left (see below). There is no second construction choice that would avoid it. + +## What was checked + +`python3 -B build_ext.py --controls` is deterministic. Run it with +`PYTHONPATH` pointing at a numpy install; numpy is needed only for the Gaussian products. It +does the following: + +1. Checks the git-blob pins of every input. The inputs are copied from PR2269 head `b479fc55` + and PR2226 head `dacaf3d8`. +2. Replays PR2269's shipped 43-pair witnesses with `replay_core.py` and reproduces its + recorded profiles exactly. `replay_core.py` is PR2226's `replay.py` in function form. Its + semantics are unchanged; only the `80 pairs / 32 low` assertion is now a parameter. +3. Builds the low and high pairs. The initial corrections are read off the residual of an + exact diagnostic replay. Every residual term must have the form `(lender, (op,))` for a + low operator, with a dyadic coefficient. No other term is allowed. +4. Re-runs the full exact replay for all three variants: free noncommutative operator + algebra over all 624/629/656 independent inputs, `Y'=Y+X`, nested frame chronology, + cold restoration, inverse cleanup at FULL with private zero buffers, and the + omitted-inverse-warp control. It also confirms that dropping the compensation fails, and + so does flipping one coefficient's sign. +5. Runs PR2226 `operators.py` on all 80 warps per word: exact Gaussian handoff and FULL-exit + products, all 512 columns, phases included. The 43 inherited records are reproduced + byte-for-byte. +6. Emits `words/BORROW-WORD-80{base,extra}.json.gz` with PR2269's unchanged emitter, then + runs PR2269's independent `audit_local.py` as a subprocess. It passes in both + orientations (`PASS_INDEPENDENT_EXACT_BORROWING_WORD`: 80 warps, 64 corrections, profile + and width inventory re-derived from the word alone). +7. With `--controls`, runs PR2269's `borrow_controls.py`. All 23 mutations are rejected for + the expected reason, including the four initial-correction controls, which are not + vacuous here (`receipts/CONTROLS-80*.json`). + +Receipts: `receipts/BUILD.json` (per-candidate decisions and blockers), +`receipts/AUDIT-80*.json` and `receipts/CONTROLS-80*.json`. + +## Independent check and model prices + +- `python3 -I -B check_ext.py --out` (standard library only; imports no PR or construction code; + reads the reference inputs as git blobs at the PR2269/PR2226 heads) prints + `PASS_T74_LOW_ALIAS_WORDS_INDEPENDENT`: warp algebra, anticipatory-term structure (frame-zero + source = lender of its own operator), frame recount, exact forward and dual replay, links to + the canonical words, and 28/28 negative controls per word (`check_ext.receipt.json`). +- `python3 -I -B run_all.py --out` re-runs the check, then prices the recounted profiles with + `price_ext.py` (`price_ext.ext80.receipt.json`). E = 80586 extra freed mass versus PR2269. + These are **model prices of an idle refill that was not built**: + +| model | b (floor, 1e-22) | vs PR2269 b | +|---|---|---| +| F | 0.0017255088890837212072 | +1.725% | +| C | 0.0017126737497248571464 | +0.968% | +| C8 | 0.0017140567316684824711 | +1.050% | +| P | 0.0016871233700042746562 | −0.538% | + +Model caveats. F keeps PR2269's realized idle remnants fixed and caps idle children at rank 48; +it is not a ceiling (fully repacking all idle mass into rank 48 would give about 0.001748). +P is not a floor for a real supplier, because hosting may add paid adapters. C reproduces +PR2269's own refill exactly by construction. Out of sample, both calibrated rules overshoot +the realized record they were not fitted to: C on T8 by 2.0e-6 and C8 on T74 by 2.3e-6. +C8 is not exact even in sample; it is 5.2e-6 above PR2260's realized b (`price_ext.py controls`). + +## Packing ceiling for the new local words (exact, any hosting) + +`python3 -I -B cap_ext.py` evaluates the merged fixed-word packing ceiling +(`research/complex-local-word-ceiling/ceiling.py`) on the call-weighted local profile. It uses +m = 73, 896 families per nine-stage replica and centre 64, with the largest idle child R = 48 +(T74's maximum child) or 51. Each cap is an upper bound on b for **any** hosting, owner packing or +idle refill of that fixed local word under the coverage law. + +| local words | cap, R = 48 | cap, R = 51 | +|---|---|---| +| PR2269 (43 high) | 0.001717935928829 | 0.001727257612832 | +| **this package (80)** | **0.001747958371974** | **0.001758245201617** | + +The ceiling rises by +1.75%. PR2269's claimed b realizes 98.74% of its own R = 48 cap. PR2322 +reports 98.66% of a 0.001720061 cap for its profile. At the same 98.74%, the new words would +give b ≈ 0.0017259. **This is an estimate, not a bound or a claim.** It sits above every open +T74 claim (top: PR2322, 0.001697060296). It needs every obligation under *Scope and limits*. + +## Reproduce + +From the repository root, with the standard library and `git`. It takes about 25 s and fetches +the pinned PR heads if they are absent: + +```sh +python3 -I -B research/t74-low-alias-borrowing/run_all.py --fetch +python3 -I -B research/t74-low-alias-borrowing/cap_ext.py +``` + +Expected final lines: `PASS_T74_LOW_ALIAS_RUN_ALL check=PASS price=PASS crosscheck=PASS ...` and +`PASS_T74_LOW_ALIAS_PACKING_CAPS cap48_high43=0.001717935929 cap48_ext80=0.001747958372`. +`run_all.py` rewrites its receipts. Repeated runs differ only in elapsed-time fields. + +Rebuilding the words needs numpy, which is used only for the Gaussian products: +`python3 -B research/t74-low-alias-borrowing/run_all.py --build --numpy-site DIR`. It +reproduces `words/` and `witness/` byte for byte. + +## How PR2269 derived its T74 witnesses from PR2226 (reconstructed) + +PR2269 ships its T74 witnesses as inputs; the derivation script is not in the PR. Diffing +`witness_43_*.json` against PR2226 `WITNESS.json` shows how they were made: + +- The 43 kept high pairs keep the PR2226 register and lender. +- Each handoff index is the T74 block `first_input`, which is the T8 index + 7. +- `retirement_B_event` is moved to the T74 index. +- `handoff_basis` is recomputed as the first `dim(lender)` vectors of the echelon basis of the + helper's first post-handoff frame. +- The 48 early-tail gates are unchanged, with `before_B` moved to T74 indices. +- `initial_corrections = []`, and every low pair is dropped. +- High pairs 606, 635, 637, 638 and 639 are dropped. + +## Low aliases: conditions and outcome + +These are the PR2226 low-pair conditions as enforced here: + +- **(a)** The lender is retired before the handoff. It has no B, deferred or early-tail touch + after the handoff. +- **(b)** At the handoff, the lender is exactly its own initial dirty input (asserted in the + replay). +- **(c)** The lender's entrance frame has dimension 0. Every compensation term + `c K_op z_lender` then reads a frame-zero helper input, so the monomial `K_G` is free. The + auditor also requires that the source is the lender of its operator. +- **(d)** The handoff has rank zero: `E` is the first `dim(lender)` vectors of the helper's + first post-handoff frame. +- **(e)** Every pre-handoff event on the low helper, other than the deferred helper-only + corrections, is either an echo (`target += c L`, which is deleted) or a temporary + external addition (`L += a ext`) with zero net change. An echo that reads a nonzero + temporary part is rewritten as direct reads `target += c a ext` at the same index and frame. +- **(f)** The residual target response is exactly `-sum c K_op z_lender`, with dyadic `c`. + +**32 transfer, with PR2226's own lenders.** The 64 corrections form the same +`(target, source, coefficient)` multiset as PR2226's 64 T8 terms; only the operator ids +differ. The prefix rewrites come from the T74 pivot kernels: + +- 628 gets two rewrites, because the kernel inserts a temporary `±2·567` pair. +- 672 gets two, because the kernel's `B[6]` donates `−2·566` until `B[232]`. +- 676 gets one, as in T8. + +The exact replay accepts all five rewrite gates (`add 214 566 -1`, `add 151 567 1`, +`add 117 566 1`, `add 181 566 -1`, `add 181 566 1`, all at frame 3). + +**16 are blocked:** low helpers 632, 633, 634, 636, 640, 641, 642, 644, 648, 649, 650, 652, +656, 657, 658 and 660. Each one has a legal prefix plan. The blocker is lender supply. At +every one of the 12 handoffs, exactly 32 registers satisfy (a)–(c): the PR2226 low lenders +273…394, all at dimension 4. No other register qualifies, including registers that B never +touches. All 32 are used. Every low alias saves the same 3 units +(the lender is at dimension 4, the helper enters at dimension 1), so choosing a different 32 +cannot help. + +The other 16 cold registers with entrance dimension 0 are 311, 327, 498, 500, 501, 510, +512, 513 (final dimension 8) and 572–575, 580–583 (final dimension 7). Restoring them early +by moving more tail gates would hand off at dimension 7–8 into first frames of dimension 4–5. +That is a paid dimension-drop handoff. It is outside PR2226's rank-zero scope, and it costs +more mass than it saves. + +## The five omitted high aliases + +In T74, helpers 606, 635, 637, 638 and 639 enter at dimension 4. Their first frame after the +handoff is also dimension 4, because the pivot kernels re-solved those frames. The PR2226 +lenders 395, 363, 530, 331 and 299 are at dimension 5 at the handoff. Using them would need +a paid 5→4 drop. That is why PR2269 dropped these aliases. + +An exhaustive search over retired, unused, non-target registers found rank-zero lenders at +dimension 4: the X registers 12, 6, 31, 4 and 1. They retire in B between 732 and 862, and +their final frame is FULL. Each alias saves 5 units because the climbs to FULL merge. +Precedent: PR2226 and PR2269 already lend X register 73 to helper 653. The only other +rank-zero dimension-4 lenders are the 32 low lenders, and using them would give up a low +alias for no saving. + +## Scope and limits + +This covers the local scalar/frame construction plus exact Gaussian handoff products. It +does **not** include any of the following: + +- native lowering of the new words in either orientation (PR2269 `run_native_borrow.py` + chain, warp recipes, the Lemma G stage); +- a window-exact owner fill for 400-helper words; +- a refreeze of PLAN/SPEC; +- a certified price (only the model prices above), outer assembly or a kappa. + +Hosting caveats: + +- The five new high aliases lend X-register fields. +- The 64 compensation terms read 32 frame-zero helper inputs before the preconditioner. + +Whole-call ownership of these must be re-checked in the hosted owner map. A naive +per-call-type difference, `249·Δgauge44 + 417·Δextra`, gives +`{1:−33636, 2:+17316, 3:−20316, 4:−996, 5:−3330}` (mass −80586). That figure is only +arithmetic: how the freed units fill idle depends on a new fill. + +## Open next questions + +1. Run PR2269's native chain (`bw_transport`, `bw_emit`, warp recipes, LOCAL-PROGRAMS, Lemma G + labels) on `BORROW-WORD-80*`. Do the 64 frame-zero compensation reads and the X-register + lenders lower without paid adapters in both orientations? +2. Build a window-exact owner fill at 400 helpers per call, then price it. The model prices + above (-0.54% to +1.73% on b; calibrated about +1%) stay unverified until that fill exists. +3. Is there a rank-zero source of extra low lenders for blocks 632, 640, 648 and 656? One + option is a dimension-4 cold register with entrance dimension 0 created by re-solving a + pivot-kernel frame. The 16 remaining helpers would save at most 48 more units per call. + +## Credit + +- PR2226, anticipatory dirty borrowing (Cinna Davis, @1337isnot1337, with OpenAI Codex): the + mechanism, the alias rule, initial compensation, `replay.py` (adapted here as + `replay_core.py`) and `operators.py` (vendored). +- PR2269 (Jeremy Kothe, `research/gmx-t74-borrow43`): the T74 canonical words, the 43-alias + witnesses, and the BORROW-WORD emitter, auditor and controls (vendored byte copies). +- PR2260 (Dugongue): concurrent application of high aliases to the T8 parent. +- PR2322 (Vlado Vojdanovski) found concurrently and independently that retired source fields + can serve as rank-zero lenders for high roles: 619/621/622/623 to X fields 1/4/6/12 at a + common rank-4 chart. This package's five extra high lenders (X 12, 6, 31, 4, 1) use the same + idea. Its owner exchanges and the other open records (PR2302, PR2309, PR2312) use high aliases + only. None of them adds the 32 low (anticipatory) aliases. + +The full predecessor lineage is in `vendor/*/NOTICE*` and `SOURCES-PR.json`. Prepared with +substantial AI assistance (Claude Code, Anthropic); Apache-2.0. No independent human review +is claimed. diff --git a/research/t74-low-alias-borrowing/SOURCES-PR.json b/research/t74-low-alias-borrowing/SOURCES-PR.json new file mode 100644 index 0000000000..1251e1ab92 --- /dev/null +++ b/research/t74-low-alias-borrowing/SOURCES-PR.json @@ -0,0 +1,96 @@ +{ + "heads": { + "PR2269": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "PR2226": "dacaf3d81f1936bb55b8454b1244e5d014272754", + "PR2260": "fde6b107e26a14da5bac5b66913c914708ea6901" + }, + "base_main": "0fdd7d82d", + "files": { + "inputs/blocks.json": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/blocks.json", + "git_blob": "c683574b3861678081fd5c5944dbd7a47309f6fd", + "sha256": "ddfac1dae1fe7cc0a91e7c7205c6d9d0c07c682880aa34eed83bf4ad7384da9f" + }, + "inputs/gauge44.canonical.json.gz": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/gauge44.canonical.json.gz", + "git_blob": "4abb6e28f02c95b41ed345d4e4401d16d58ae791", + "sha256": "65c6d17ffee2eacf27bff438f37fc549c9ed0c909cbc7a52976cc75cf2d15b91" + }, + "inputs/extra.canonical.json.gz": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/extra.canonical.json.gz", + "git_blob": "e0d670d4351229ce6921ecfbecf180070b17616b", + "sha256": "d7e48dcbafa236a2e1e41f7958244211506f7c7630fe6a2d43d2bdf17b7ae015" + }, + "inputs/witness_43_base.json": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/witness_43_base.json", + "git_blob": "9f4b93f3bc52d4f4ffaa128cfd7ae574fd36c462", + "sha256": "67ffb66d94067f6e53aee9118fe90e14a57f497fc8b3f708b6dac3de2e58ff28" + }, + "inputs/witness_43_extra.json": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/witness_43_extra.json", + "git_blob": "864ba533f50c2f1f639a6a3559b185bd321b923a", + "sha256": "d46449c6dbf4477f260cf5baea9bbb570a66ee0b6db81f4a220b9e3086ae9e46" + }, + "inputs/PR2226-WITNESS.json": { + "pr": "PR2226", + "path": "research/anticipatory-dirty-borrowing/WITNESS.json", + "git_blob": "62edbcce166f7cf388231078c2cd7f75939b97e2", + "sha256": "86392adde6992a08ae90f7a69c58cace1b52d942f4d2c96e82ca79e5d1e15235" + }, + "vendor/pr2269/emit_word.py": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/emit_word.py", + "git_blob": "a97e3d7506b63aacb8c845a4702be9ecded710b8", + "sha256": "c38cd936c5dfc5988c6d50294f94ff003dd1fcd2bab5c4161d7de2cc445ba8ab" + }, + "vendor/pr2269/build_word.py": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/build_word.py", + "git_blob": "8684d54b319c3d3a3cbaeaf1bb3af8d45bde92cd", + "sha256": "a174c4ca05ef3c2dda789a042e16b20164fbc7d6ed7781c6b63964d30b498f36" + }, + "vendor/pr2269/audit_local.py": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/audit_local.py", + "git_blob": "a90b00e0232bc9d7bc85138bad8d95553db673d4", + "sha256": "36c82ecbface61a5b824c59ea90d1f31a31ff4b87bfef24e16742f06e18fa3c5" + }, + "vendor/pr2269/borrow_controls.py": { + "pr": "PR2269", + "path": "research/gmx-t74-borrow43/new/borrow/borrow_controls.py", + "git_blob": "99789e011d0d3dd699560e002a1c0b9ef7fbb3ac", + "sha256": "07fbbf8e2f06df063dc9d88e5e4f721222a9fcf30b983bf9127cd5aa4b611627" + }, + "vendor/pr2226/operators.py": { + "pr": "PR2226", + "path": "research/anticipatory-dirty-borrowing/operators.py", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + "vendor/pr2226/NOTICE.md": { + "pr": "PR2226", + "path": "research/anticipatory-dirty-borrowing/NOTICE.md", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + } + }, + "adapted": { + "replay_core.py": "function form of PR2226 research/anticipatory-dirty-borrowing/replay.py (blob see PR2226 head) ; only the 80/32 pair-count assertion parameterised, diagnostic residual mode and probe hook added" + }, + "outputs": { + "witness/witness_80_base.json": "9380f74c032b0616d5b13e8ef94b6d9f80cac36239e329357e7d5fcab5283ad0", + "witness/witness_80_extra.json": "6737072dcca47c6e6526bd62a41585dd09026549550c9e62eb53e64b265a6709", + "words/BORROW-WORD-80base.json.gz": "61290abffd8c8225e0abb3958c1506674e256de688fc4cdf358bbe7c981df493", + "words/BORROW-WORD-80extra.json.gz": "1dd2d6f2ae5b5a27b5f89fb830203f0cca7a78d0323a7845e85e1e80f8f6d1a5" + }, + "tools": { + "check_ext.py": "independent word check (stdlib only; reads PR2269/PR2226 blobs via git at the heads above)", + "price_ext.py": "model pricing harness; `sources` re-reads PR2269/PR2260/PR2226 constants via git; PR2312 kappa is a reference value only", + "run_all.py": "runs check_ext.py + price_ext.py and cross-checks" + } +} diff --git a/research/t74-low-alias-borrowing/SOURCES.json b/research/t74-low-alias-borrowing/SOURCES.json new file mode 100644 index 0000000000..437931a716 --- /dev/null +++ b/research/t74-low-alias-borrowing/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + } + ] +} diff --git a/research/t74-low-alias-borrowing/TASK.json b/research/t74-low-alias-borrowing/TASK.json new file mode 100644 index 0000000000..4651524538 --- /dev/null +++ b/research/t74-low-alias-borrowing/TASK.json @@ -0,0 +1,76 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "refined", + "actual_scope": "Add PR2226's 32 low (anticipatory) aliases and the 5 high aliases PR2269 omitted to the record T74 pivot-566+554 borrow words (PR2269 head b479fc55); exact local construction and independent check; exact fixed-word packing ceilings and modelled idle-refill prices. Native lowering, owner fill and outer assembly are not done.", + "scope_change_reason": "The card asks whether a new local cost interface (helper inventory) can change the deficit-to-recursive-cost ratio; this refines it to one concrete inventory change on the current record words: anticipatory low aliases, which no record had used.", + "bottleneck_link": "Binding complex supplier: the 80-alias words lower local mass 5385 -> 5264 per call (400 helpers) and raise the exact fixed-word packing ceiling from 0.0017179 to 0.0017480 (R=48); at the realization records already achieve this is ~+1.6% b over the current top open claim, conditional on native lowering and a new owner fill.", + "budget_minutes": 180, + "stop_rule": "All 32 PR2226 low aliases and 5 omitted highs attempted on both words; the 16 remaining low helpers proven lender-blocked at every handoff; pricing by explicit models only.", + "outcome": "completed", + "evidence": "run_all.py: PASS_T74_LOW_ALIAS_RUN_ALL (independent check_ext 28/28 controls per word; model prices F/C/C8/P); cap_ext.py: PASS_T74_LOW_ALIAS_PACKING_CAPS; build_ext.py --controls (numpy, construction-time): PASS_T74_LOW_ALIAS_EXTENSION incl. PR2269 audit_local in both orientations and 23 borrow_controls mutations.", + "author": "Sagar Thakrar", + "ai_assistance": "Substantial AI assistance: Claude Code (Anthropic, Claude Opus 5.5) subagents constructed the witnesses/words (reusing PR2226/PR2269 tooling with credit), wrote an independent stdlib checker and pricing harness, and adversarially reviewed the result; the main session reran the checks and computed the packing caps.", + "open_questions": [ + { + "question": "Do the 64 frame-zero anticipatory compensation reads and the X-register lenders lower natively in both orientations without paid adapters?", + "why_it_matters": "No PR has natively lowered anticipatory compensation; the reflected handoffs need exact Gaussian-phase Clifford lifts.", + "first_step": "Run PR2269's native chain (bw_transport, bw_emit, warp recipes, Lemma G labels) on BORROW-WORD-80*.", + "blocked_by": "Native lowering tooling for initial corrections." + }, + { + "question": "What b does a window-exact owner fill at 400 helpers per call attain?", + "why_it_matters": "The ceiling is 0.0017480 (R=48); model prices range 0.0016871-0.0017255; only an actual fill decides.", + "first_step": "Re-run the T74 owner solver with the 80-alias widths and recount the idle profile.", + "blocked_by": "Owner-fill tooling of the T74 lineage." + }, + { + "question": "Can extra rank-zero low lenders be created for blocks 632/640/648/656?", + "why_it_matters": "16 more low helpers would save up to 48 units per call.", + "first_step": "Re-solve a pivot-kernel frame to create a dimension-4 cold register with entrance dimension 0.", + "blocked_by": "Lender supply is exhausted at every handoff in the current words." + } + ] +} diff --git a/research/t74-low-alias-borrowing/VERIFY.json b/research/t74-low-alias-borrowing/VERIFY.json new file mode 100644 index 0000000000..355797a246 --- /dev/null +++ b/research/t74-low-alias-borrowing/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/complex-local-word-ceiling/ceiling.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/run_all.py", + "--fetch" + ], + "timeout_seconds": 600, + "checks": "fetch pinned PR heads if absent; independent stdlib check of both 80-alias words (exact replay, frames, profiles, 28 controls per word); model prices with positive controls" + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/cap_ext.py" + ], + "timeout_seconds": 300, + "checks": "exact fixed-word packing ceilings (merged ceiling.py) for PR2269 and the 80-alias words, positive control" + } + ] +} diff --git a/research/t74-low-alias-borrowing/build_ext.py b/research/t74-low-alias-borrowing/build_ext.py new file mode 100644 index 0000000000..40924f32d0 --- /dev/null +++ b/research/t74-low-alias-borrowing/build_ext.py @@ -0,0 +1,418 @@ +#!/usr/bin/env python3 +"""Deterministic builder: PR2226 LOW (anticipatory) aliases + the 5 omitted high aliases on the two +T74 pivot-566+554 borrow words of PR2269. + +Construction-time oracle: the exact free-operator replay of PR2226 (replay_core.py, a function +form of PR2226 replay.py with only the 80/32 count assertion parameterised). Emission: PR2269's +BORROW-WORD builder (vendor/pr2269/emit_word.py, build_word.py, byte copies). Independent audit: +PR2269's audit_local.py (byte copy, run as a subprocess; it re-derives frames, profile, inverse +cleanup and both free-algebra orientations from the emitted word alone). Exact Gaussian handoff +products: PR2226 operators.py (byte copy; needs numpy). + +usage: python3 -B build_ext.py [--skip-gaussian] [--skip-audit] [--controls] +Writes witness/, words/, receipts/ under this directory. Exit 0 only if every check passes. + +Credits: PR2226 anticipatory dirty borrowing (Cinna Davis, @1337isnot1337, with OpenAI Codex +assistance): mechanism, alias rule, initial compensation, replay, operators. PR2269 (Jeremy +Kothe, research/gmx-t74-borrow43): T74 canonical words, 43-alias witnesses, BORROW-WORD emitter +and auditor. PR2260 (Dugongue): concurrent high-alias application on the T8 parent. +Prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0. +""" +import argparse, gzip, hashlib, json, os, subprocess, sys, time +from fractions import Fraction as Q +from pathlib import Path + +if not __debug__: + raise RuntimeError('assertions must remain enabled') +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.path.insert(0, str(HERE / 'vendor' / 'pr2269')) +from replay_core import replay, span, frame_basis, incident, ReplayError # noqa: E402 + +INP = HERE / 'inputs' +CASES = [('gauge44', 'base', 'eeb6a236'), ('extra', 'extra', 'cd417b90')] +PINS = { # git blob ids at PR2269 head b479fc55 / PR2226 head dacaf3d8 + 'blocks.json': 'c683574b3861678081fd5c5944dbd7a47309f6fd', + 'gauge44.canonical.json.gz': '4abb6e28f02c95b41ed345d4e4401d16d58ae791', + 'extra.canonical.json.gz': 'e0d670d4351229ce6921ecfbecf180070b17616b', + 'witness_43_base.json': '9f4b93f3bc52d4f4ffaa128cfd7ae574fd36c462', + 'witness_43_extra.json': '864ba533f50c2f1f639a6a3559b185bd321b923a', + 'PR2226-WITNESS.json': '62edbcce166f7cf388231078c2cd7f75939b97e2', +} +OMITTED_HIGH = [639, 638, 635, 606, 637] # PR2226 order; PR2269 omitted these five + + +def git_blob(path): + data = Path(path).read_bytes() + return hashlib.sha1(b'blob %d\0' % len(data) + data).hexdigest() + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def load(canon, wt): + w = json.loads(gzip.decompress((INP / f'{canon}.canonical.json.gz').read_bytes())) + blocks = json.loads((INP / 'blocks.json').read_text())['sources'][0]['blocks'] + wit = json.loads((INP / f'witness_43_{wt}.json').read_text()) + return w, blocks, wit + + +def deferred_sets(w, blocks): + deferred = {}; skip = set() + for b in blocks: + ss = set(b['helpers']); part = [] + for i in range(b['first_correction'], b['first_input']): + e = w['B'][i] + if set(incident(e)) <= ss: + part.append(e); skip.add(i) + deferred[b['first_input']] = part + return deferred, skip + + +def prefix_plan(w, block, L, skip): + """PR2226 section 3: pre-handoff events touching a low helper must be echoes (target += c L) + or temporary external additions (L += a ext) with zero net change. Echoes are deleted; + an echo that reads a nonzero temporary part is rewritten as direct reads of the sources.""" + v = w['v']; i0 = block['first_input'] + events = [(j, w['B'][j]) for j in range(i0) if j not in skip and L in incident(w['B'][j])] + tmp = {}; deleted = []; echoes = []; rewrites = {} + for j, e in events: + if e[0] == 'add' and e[2] == L and v <= e[1] < 2 * v: + c = Q(e[3], e[4]); gates = [] + for ext, a in sorted(tmp.items()): + if a: + cc = c * a + gates.append(['add', e[1], ext, cc.numerator, cc.denominator, e[-1]]) + deleted.append(j); echoes.append(j); rewrites[str(j)] = gates + elif e[0] == 'add' and e[1] == L and e[2] != L and not (v <= e[2] < 2 * v): + tmp[e[2]] = tmp.get(e[2], Q(0)) + Q(e[3], e[4]); deleted.append(j) + else: + return None, {'condition': 'prefix events are echoes or temporary external additions', + 'witness_event': [j, e]} + if any(a for a in tmp.values()): + return None, {'condition': 'net temporary change is zero', + 'witness': {str(k): str(a) for k, a in tmp.items() if a}} + return {'deleted_prefix_indices': deleted, 'deleted_echo_indices': echoes, + 'early_prefix_rewrites': rewrites}, None + + +def touches(w, wit, deferred, skip): + t = {} + for e in wit['early_tail_events']: + for r in incident(e['gate']): + t.setdefault(r, []).append(('tail', e['before_B'])) + for i, e in enumerate(w['B']): + for d in deferred.get(i, []): + for r in incident(d): + t.setdefault(r, []).append(('B', i)) + if i not in skip: + for r in incident(e): + t.setdefault(r, []).append(('B', i)) + return t + + +def first_frame(w, i, L, deferred, skip, removed_echoes, rewrites): + for j in range(i, len(w['B'])): + gl = list(deferred.get(j, [])) + list(rewrites.get(j, [])) + if j not in skip and j not in removed_echoes: + gl.append(w['B'][j]) + for g in gl: + if L in incident(g): + return j, g[-1] + raise AssertionError(('helper never used after handoff', L)) + + +class Builder: + def __init__(self, canon, wt): + self.canon, self.wt = canon, wt + self.w, self.blocks, self.wit = load(canon, wt) + w = self.w + self.v = w['v']; self.n = 2 * w['v'] + w['R']; self.h = w['h'] + self.frames = list(map(span, w['frames'])) + self.frame_index = {} + for k, f in enumerate(self.frames): + self.frame_index.setdefault(f, k) + self.deferred, self.skip = deferred_sets(w, self.blocks) + self.tch = touches(w, self.wit, self.deferred, self.skip) + self.block_of = {L: b for b in self.blocks for L in b['helpers']} + self.probe = {b['first_input']: None for b in self.blocks} + r0 = replay(w, self.blocks, self.wit, expect_pairs=43, probe=self.probe) + # the shipped PR2269 witness replays to its recorded profile + assert r0['local_profile'] == {int(k): c for k, c in self.wit['replay']['local_profile'].items()} + self.base43 = r0 + + def retired(self, r, i): + return all((t == 'B' and x < i) or (t == 'tail' and x <= i) for t, x in self.tch.get(r, [])) + + def lender_facts(self, r, i, L_first_dim): + w = self.w; snap = self.probe[i] + return {'register': r, 'target_register': self.v <= r < 2 * self.v, + 'entrance_dim': len(w['frames'][w['start'][r]]), + 'final_dim': len(w['frames'][w['final'][r]]), + 'retired_before_handoff': self.retired(r, i), + 'equals_initial_input_at_handoff': r in snap['pristine'], + 'dim_at_handoff': len(snap['cur'].get(r, [])) if r in snap['cur'] else None, + 'zero_rank_handoff_possible': r in snap['cur'] and len(snap['cur'][r]) <= L_first_dim} + + def make_pair(self, L, lender, low, plan): + w = self.w; b = self.block_of[L]; i = b['first_input']; snap = self.probe[i] + plan = plan or {'deleted_prefix_indices': [], 'deleted_echo_indices': [], 'early_prefix_rewrites': {}} + rew = {int(k): g for k, g in plan['early_prefix_rewrites'].items()} + j, f1 = first_frame(w, i, L, self.deferred, self.skip, set(plan['deleted_prefix_indices']), rew) + fb = frame_basis(self.frames[f1]); du = len(snap['cur'][lender]) + assert len(fb) >= du, 'paid handoff' + E = fb[:du] + last = self.tch.get(lender, []) + lastB = max([x for t, x in last if t == 'B'], default=-1) + lastT = max([x for t, x in last if t == 'tail'], default=-1) + cb = frame_basis(span(b['common_frame'])) + p = {'register': L, 'base': b['base'], 'common_basis': cb, 'dimension': len(cb), 'deadline': i, + 'deleted_echo_indices': plan['deleted_echo_indices'], 'low': low, 'borrow_from': lender, + 'retirement_B_event': max(lastB, lastT - 1), + 'retirement_frame': self.frame_index[span(snap['cur'][lender])], + 'retirement_dimension': du, 'old_final_dimension': len(w['frames'][w['final'][lender]]), + 'handoff_B': i, 'handoff_basis': E, 'handoff_paid_rank': 0, 'anticipate': low, + 'retirement_basis': snap['cur'][lender], 'first_use_B': j} + if low: + p['deleted_prefix_indices'] = plan['deleted_prefix_indices'] + p['early_prefix_rewrites'] = plan['early_prefix_rewrites'] + return p + + def solve_corrections(self, pairs): + inv = {'pairs': pairs, 'initial_corrections': [], 'early_tail_events': self.wit['early_tail_events']} + d = replay(self.w, self.blocks, inv, diagnose=True) + bad = [op for op, old, ok in d['lender_check'] if not ok] + assert not bad, ('low lender not its restored initial input', bad) + lender = {k + 1: x['borrow_from'] for k, x in enumerate(pairs)} + low_ops = {k + 1 for k, x in enumerate(pairs) if x['low']} + corr = []; foreign = {} + for t, row in sorted(d['residual'].items()): + for (var, word), c in sorted(row.items(), key=lambda kv: (kv[0][1], kv[0][0])): + ok = (len(word) == 1 and word[0] in low_ops and var == lender[word[0]] + and c.denominator & (c.denominator - 1) == 0) + if not ok: + foreign.setdefault(t, []).append([var, list(word), str(c)]) + continue + corr.append({'target': t, 'source': var, 'operator_word': [word[0]], 'coefficient': str(-c)}) + return corr, foreign + + def high_candidates(self, L): + b = self.block_of[L]; i = b['first_input']; snap = self.probe[i] + _, f1 = first_frame(self.w, i, L, self.deferred, self.skip, set(), {}) + d1 = len(self.w['frames'][f1]) + return i, d1, snap + + +def gaussian_records(pairs, w, keep): + import importlib.util + spec = importlib.util.spec_from_file_location('pr2226_operators', HERE / 'vendor' / 'pr2226' / 'operators.py') + ops = importlib.util.module_from_spec(spec); spec.loader.exec_module(ops) + import numpy as np + h = w['h']; size = 1 << h; out = []; negative_rejected = False + for k, x in enumerate(pairs, 1): + U = w['frames'][x['retirement_frame']]; E = x['handoff_basis'] + assert len(U) == len(E) + G = ops.change(U, E, h); K = ops.monomial(G, h) + z = (np.eye(size, dtype=np.int64), np.zeros((size, size), dtype=np.int64), 0) + z = ops.frame(z, U, h, -1); z = ops.apply_mono(z, K); z = ops.frame(z, E, h, 1) + hh = ops.check(z) + if not negative_rejected: + zb = (np.eye(size, dtype=np.int64), np.zeros((size, size), dtype=np.int64), 0) + zb = ops.frame(zb, U, h, -1); zb = ops.frame(zb, E, h, 1) + try: + ops.check(zb) + except AssertionError: + negative_rejected = True + z = (np.eye(size, dtype=np.int64), np.zeros((size, size), dtype=np.int64), 0) + z = ops.coord(z, range(h), -1); z = ops.apply_mono(z, K, -1); z = ops.coord(z, range(h), 1) + eh = ops.check(z) + rec = {'operator': k, 'G_columns': G, 'handoff_exact_monomial_sha256': hh, + 'full_exit_exact_monomial_sha256': eh} + if k in keep: # PR2269's recorded products for its 43 operators are reproduced exactly + assert keep[k] == rec, ('PR2269 gaussian record not reproduced', k) + out.append(rec) + return out, negative_rejected + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument('--skip-gaussian', action='store_true') + ap.add_argument('--skip-audit', action='store_true') + ap.add_argument('--controls', action='store_true') + a = ap.parse_args() + t0 = time.monotonic() + for name, pin in PINS.items(): + assert git_blob(INP / name) == pin, ('input pin', name) + w8 = json.loads((INP / 'PR2226-WITNESS.json').read_text()) + P8 = {x['register']: x for x in w8['pairs']} + summary = {'status': None, 'pins_git_blob': PINS, 'words': {}} + for d in ('witness', 'words', 'receipts'): + (HERE / d).mkdir(exist_ok=True) + ok = True + for canon, wt, hname in CASES: + B = Builder(canon, wt); w = B.w; v = B.v + pairs = [dict(x) for x in B.wit['pairs']] + used = {x['borrow_from'] for x in pairs} | {x['register'] for x in pairs} + rec = {'base_43': {'local_profile': B.base43['local_profile'], 'local_mass': B.base43['local_mass'], + 'helpers': w['R'] - 43}} + # ---------- 1. low candidates: all 48 low helpers of the 12 blocks ---------- + low_report = {}; low_pairs = [] + handoffs = sorted({b['first_input'] for b in B.blocks}) + pools = {} + for i in handoffs: + snap = B.probe[i] + pools[i] = sorted(r for r in range(B.n) if not (v <= r < 2 * v) and r not in used + and r in snap['pristine'] and len(w['frames'][w['start'][r]]) == 0 + and B.retired(r, i)) + assert len({tuple(p) for p in pools.values()}) == 1, 'pool differs between handoffs' + pool = pools[handoffs[0]] + t8_low = [x for x in w8['pairs'] if x['low']] + assert sorted(x['borrow_from'] for x in t8_low) == pool, 'eligible low lenders != PR2226 low lenders' + for x8 in t8_low: # PR2226 order, PR2226 lender + L = x8['register']; b = B.block_of[L] + plan, why = prefix_plan(w, b, L, B.skip) + assert why is None, (L, why) + facts = B.lender_facts(x8['borrow_from'], b['first_input'], 9) + assert facts['retired_before_handoff'] and facts['equals_initial_input_at_handoff'] and facts['entrance_dim'] == 0 + p = B.make_pair(L, x8['borrow_from'], True, plan) + low_pairs.append(p); used |= {L, p['borrow_from']} + low_report[L] = {'status': 'ALIASED', 'lender': p['borrow_from'], 'lender_source': 'PR2226 lender transfers', + 'deleted_prefix_indices': plan['deleted_prefix_indices'], + 'early_prefix_rewrites': {k: g for k, g in plan['early_prefix_rewrites'].items() if g}} + for b in B.blocks: + for L in b['low']: + if L in low_report: + continue + plan, why = prefix_plan(w, b, L, B.skip) + i = b['first_input'] + free = [r for r in pools[i] if r not in used] + low_report[L] = {'status': 'BLOCKED', 'prefix_plan_legal': why is None, + 'prefix_events_deleted': plan['deleted_prefix_indices'] if plan else None, + 'blocker': 'no eligible lender: the set of non-target registers that are retired ' + 'before the handoff, have a zero-dimensional entrance frame (so K_G z is free ' + 'to read into the frame-zero target) and equal their own initial dirty input ' + 'at the handoff has exactly %d members at every one of the 12 handoffs; all ' + '%d are consumed by the 32 transferred low aliases (free now: %d)' % (len(pool), len(pool), len(free))} + # ---------- 2. the five omitted high aliases ---------- + high_report = {}; high_pairs = [] + for L in OMITTED_HIGH: + x8 = P8[L]; i, d1, snap = B.high_candidates(L) + t8 = x8['borrow_from'] + entry = {'T8_lender': t8, 'T8_lender_dim_at_handoff': len(snap['cur'][t8]), + 'helper_first_frame_dim_T74': d1, + 'helper_entrance_dim_T74': len(w['frames'][w['start'][L]]), + 'T8_lender_blocker': ('paid dimension-drop handoff %d->%d (outside PR2226 rank-zero scope)' + % (len(snap['cur'][t8]), d1)) if len(snap['cur'][t8]) > d1 else None} + cands = sorted((r for r in range(B.n) if not (v <= r < 2 * v) and r not in used and B.retired(r, i) + and r in snap['cur'] and 0 < len(snap['cur'][r]) <= d1), + key=lambda r: (-len(snap['cur'][r]), len(w['frames'][w['final'][r]]) < B.h, r)) + entry['zero_rank_candidates'] = len(cands) + chosen = None + for r in cands: + p = B.make_pair(L, r, False, None) + trial = pairs + low_pairs + high_pairs + [p] + corr, foreign = B.solve_corrections(trial) + if foreign: + continue + chosen = p; break + assert chosen is not None, ('no high lender', L) + high_pairs.append(chosen); used |= {L, chosen['borrow_from']} + entry.update(status='ALIASED', lender=chosen['borrow_from'], + lender_dim_at_handoff=chosen['retirement_dimension'], + lender_final_dim=chosen['old_final_dimension']) + high_report[L] = entry + # ---------- 3. corrections, exact replay of all variants ---------- + variants = {'low32': pairs + low_pairs, 'high5': pairs + high_pairs, 'ext80': pairs + low_pairs + high_pairs} + results = {} + for vn, prs in variants.items(): + corr, foreign = B.solve_corrections(prs) + assert not foreign, (vn, foreign) + inv = {'pairs': prs, 'initial_corrections': corr, 'early_tail_events': B.wit['early_tail_events']} + r = replay(w, B.blocks, inv) + assert all(ok_ for _, _, ok_ in r['lender_check']) + # negative control: omit the initial compensation -> the exact replay must fail + if corr: + try: + replay(w, B.blocks, dict(inv, initial_corrections=[])); raise AssertionError('no-compensation control passed') + except ReplayError: + pass + bad = [dict(c) for c in corr]; bad[0]['coefficient'] = str(-Q(bad[0]['coefficient'])) + try: + replay(w, B.blocks, dict(inv, initial_corrections=bad)); raise AssertionError('sign control passed') + except ReplayError: + pass + results[vn] = (inv, r) + rec[vn] = {'pairs': len(prs), 'low': sum(x['low'] for x in prs), 'initial_corrections': len(corr), + 'helpers': w['R'] - len(prs), 'local_profile': r['local_profile'], 'local_mass': r['local_mass'], + 'independent_input_columns': r['independent_input_columns'], + 'zero_FULL_cleanup_buffers': r['zero_FULL_cleanup_buffers'], + 'controls': 'omitted compensation and one flipped sign rejected' if corr else 'n/a'} + print(canon, vn, rec[vn], flush=True) + inv, r = results['ext80'] + # ---------- 4. exact Gaussian handoff products (PR2226 operators.py) ---------- + keep = {g['operator']: g for g in B.wit['gaussian']['records']} + assert sorted(keep) == list(range(1, 44)) + if a.skip_gaussian: + raise SystemExit('gaussian records are required to emit the word') + recs, neg = gaussian_records(inv['pairs'], w, keep) + assert neg, 'omitted logical basis map negative control did not fail' + witness = {'credit': 'PR2226 anticipatory dirty borrowing (Cinna Davis / 1337isnot1337, OpenAI Codex); ' + 'PR2269 T74 words and 43-alias witness (Jeremy Kothe); low aliases + 5 high aliases ' + 'added by research/t74-low-alias-borrowing (Claude Code assistance)', + 'variant': f'80_{wt}', 'pairs': inv['pairs'], 'initial_corrections': inv['initial_corrections'], + 'early_tail_events': inv['early_tail_events'], + 'replay': {k: r[k] for k in ('status', 'local_profile', 'local_mass', 'remaining_registers', + 'zero_FULL_cleanup_buffers', 'exact_cold_restoration', 'symbolic_warps')}, + 'gaussian': {'status': 'PASS_EXACT_GAUSSIAN_BORROW_HANDOFFS', 'operators': len(recs), + 'columns_per_operator': 1 << w['h'], 'physical_rank_zero_products_checked': 2 * len(recs), + 'omitted_logical_basis_map_rejected': neg, 'records': recs}} + witness['replay']['local_profile'] = {str(k): c for k, c in r['local_profile'].items()} + wp = HERE / 'witness' / f'witness_80_{wt}.json' + wp.write_text(json.dumps(witness, indent=1) + '\n') + # ---------- 5. emit BORROW-WORD with PR2269's builder ---------- + import build_word + out = HERE / 'words' / f'BORROW-WORD-80{wt}.json.gz' + cwd = os.getcwd(); os.chdir(HERE / 'vendor' / 'pr2269') + try: + build_word.main(str(INP / f'{canon}.canonical.json.gz'), str(INP / 'blocks.json'), str(wp), str(out), hname) + finally: + os.chdir(cwd) + # make the gzip deterministic (mtime 0) + content = gzip.decompress(out.read_bytes()) + out.write_bytes(gzip.compress(content, mtime=0)) + rec['word'] = {'path': str(out.relative_to(HERE)), 'content_sha256': hashlib.sha256(content).hexdigest()} + # ---------- 6. independent audit (PR2269 audit_local.py, subprocess) ---------- + if not a.skip_audit: + ar = HERE / 'receipts' / f'AUDIT-80{wt}.json' + pr = subprocess.run([sys.executable, '-B', str(HERE / 'vendor' / 'pr2269' / 'audit_local.py'), '--word', str(out), + '--base', str(INP / f'{canon}.canonical.json.gz'), '--output', str(ar)], + capture_output=True, text=True) + ok &= pr.returncode == 0 + rep = json.loads(ar.read_text()) if pr.returncode == 0 else {'stderr': pr.stderr[-2000:]} + rec['independent_audit'] = {k: rep.get(k) for k in ('status', 'removed_helpers', 'independent_inputs', 'warps', + 'corrections', 'restored_cold', 'local_profile', 'local_mass', + 'width_inventory', 'orientations')} if pr.returncode == 0 else rep + print(canon, 'audit', rec['independent_audit'], flush=True) + if pr.returncode == 0: + assert rep['local_mass'] == r['local_mass'] and {int(k): c for k, c in rep['local_profile'].items()} == r['local_profile'] + wi = rep['width_inventory']; rec['width_sum'] = sum(int(k) * c for k, c in wi.items()) + rec['mass_identity_1856_plus_width_sum'] = rep['local_mass'] == 1856 + rec['width_sum'] + if a.controls: + cr = HERE / 'receipts' / f'CONTROLS-80{wt}.json' + pr = subprocess.run([sys.executable, '-B', str(HERE / 'vendor' / 'pr2269' / 'borrow_controls.py'), str(out), + str(INP / f'{canon}.canonical.json.gz'), str(cr)], capture_output=True, text=True) + ok &= pr.returncode == 0; rec['controls_rc'] = pr.returncode + rec['low_candidates'] = {str(k): low_report[k] for k in sorted(low_report)} + rec['omitted_high'] = {str(k): high_report[k] for k in OMITTED_HIGH} + rec['low_lender_pool'] = pool + summary['words'][canon] = rec + summary['status'] = 'PASS_T74_LOW_ALIAS_EXTENSION' if ok else 'FAIL' + summary['seconds'] = round(time.monotonic() - t0, 1) + (HERE / 'receipts' / 'BUILD.json').write_text(json.dumps(summary, indent=1, sort_keys=True) + '\n') + print(summary['status']) + sys.exit(0 if ok else 1) + + +if __name__ == '__main__': + main() diff --git a/research/t74-low-alias-borrowing/cap_ext.py b/research/t74-low-alias-borrowing/cap_ext.py new file mode 100644 index 0000000000..04cdbcb9f1 --- /dev/null +++ b/research/t74-low-alias-borrowing/cap_ext.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +"""Fixed-local-profile packing caps (exact intervals) for the T74 borrow words, using the merged +research/complex-local-word-ceiling/ceiling.py (Douglas Colkitt's interval engine lineage; see that package). + +For a fixed per-call local paid profile, ceiling() bounds the complex saving a of ANY hosting, owner packing or +idle-remainder choice under PR1012's coverage law (m = 73, 896 families per nine-stage replica, centre 64): all +idle mass in (fractional) children of the largest allowed rank R. The T74 supplier's maximum child is 48; R = 51 +(the halving-guard maximum) is also reported. The local profile used is the call-weighted average +(249 gauge44 + 417 extra calls) of the two words. These are upper bounds, not attained savings. +Prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0.""" +import importlib.util +import os +import sys +from fractions import Fraction as Q + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(os.path.dirname(HERE)) +spec = importlib.util.spec_from_file_location('ceiling', os.path.join(ROOT, 'research/complex-local-word-ceiling/ceiling.py')) +C = importlib.util.module_from_spec(spec) +spec.loader.exec_module(C) + +PROFILES = { + 'pr2269_high43': ({1: 2351, 2: 501, 3: 414, 4: 129, 5: 42, 8: 8}, {1: 2339, 2: 509, 3: 418, 4: 125, 5: 42, 8: 8}), + 'ext80_this_package': ({1: 2303, 2: 527, 3: 386, 4: 125, 5: 37, 8: 8}, {1: 2287, 2: 535, 3: 386, 4: 125, 5: 37, 8: 8}), +} +CLAIMED_2269_B = Q('0.0016962471390584742207696225394800943861') + + +def avg(pg, pe): + return {r: Q(249 * pg.get(r, 0) + 417 * pe.get(r, 0), 666) for r in set(pg) | set(pe)} + + +def main(): + caps = {} + for R in (48, 51): + for name, (pg, pe) in PROFILES.items(): + lo, hi = C.ceiling(avg(pg, pe), 73, 896, 9, 64, R=R) + caps[(name, R)] = (lo, hi) + print('R=%d %-20s cap in [%s, %s]' % (R, name, float(lo), float(hi))) + lo69, hi69 = caps[('pr2269_high43', 48)] + assert CLAIMED_2269_B < lo69, 'positive control: #2269 claimed b must lie below its own cap' + lo80, hi80 = caps[('ext80_this_package', 48)] + assert lo80 > hi69, 'the 80-alias cap must exceed the 43-alias cap' + frac = CLAIMED_2269_B / hi69 + print('#2269 realised fraction of its R=48 cap >= %.6f' % float(frac)) + print('same fraction of the ext80 cap (estimate, not a bound): %.10f' % float(frac * lo80)) + print('PASS_T74_LOW_ALIAS_PACKING_CAPS cap48_high43=%.12f cap48_ext80=%.12f' % (float(hi69), float(lo80))) + return 0 + + +if __name__ == '__main__': + if not __debug__: + sys.exit('refusing to run with -O') + sys.exit(main()) diff --git a/research/t74-low-alias-borrowing/check_ext.py b/research/t74-low-alias-borrowing/check_ext.py new file mode 100644 index 0000000000..4ba868c75d --- /dev/null +++ b/research/t74-low-alias-borrowing/check_ext.py @@ -0,0 +1,1524 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independent check of the extended T74 borrow words BORROW-WORD-80{base,extra} (48 high + 32 LOW aliases, +64 anticipatory initial corrections) produced by build_ext.py in this package. + +Objects under test (local files of this package, pinned below by sha256 and git blob id): + words/BORROW-WORD-80base.json.gz, words/BORROW-WORD-80extra.json.gz, + witness/witness_80_base.json, witness/witness_80_extra.json. +Reference inputs, read as git blobs at pinned commits (no copies are trusted): + PR #2269 head b479fc55 (research/gmx-t74-borrow43/): canonical unborrowed T74 words, block certificate, + 43-alias witnesses and the BORROW-WORD-43 words (positive control), the pivot-566 predecessor words; + PR #2226 head dacaf3d8 (research/anticipatory-dirty-borrowing/WITNESS.json): the 64 T8 correction terms. + +Adapted from our own iteration-3 independent checker (fork commit 4a2f20ea339e30348448096ca789d0efe55df9bb, +research/t74-borrow43-independent-check/words_check.py, Apache-2.0, same authors). The extension to LOW pairs +with anticipatory initial corrections is implemented from the WRITTEN semantics of PR2226 (PROOF.md sections +1-4 and README.md) only. This file imports and runs no PR code and no code of build_ext.py / replay_core.py / +the vendored files; it shares no code with them. + +Credit: PR2226 (Cinna Davis / @1337isnot1337, with OpenAI Codex) for anticipatory dirty borrowing, the alias +rule, initial monomial compensation and the free-operator replay idea; PR2269 (Jeremy Kothe / jeremykothe2) for +the T74 borrow43 package, canonical words, witnesses and the BORROW-WORD format; PR2260 (Dugongue) for the +concurrent high-alias application on the T8 parent; the T74 lineage PR1319/PR1297 (Rohan Arun), PR1625 +(mdumitrean) and the pivot-554 kernel; Ali Romman's block certificate; icekylinx (Zhihao Chen) for the +Clifford-frame normal forms (notes/general-clifford-frames.tex) and the local-word checker lineage. + +Prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0. + +Usage: python3 -I -B check_ext.py [--repo PATH] [--out] [--skip-controls] [--skip-predecessor] +The final stdout line is PASS_T74_LOW_ALIAS_WORDS_INDEPENDENT or FAIL_T74_LOW_ALIAS_WORDS_INDEPENDENT. +--out writes check_ext.receipt.json next to this script. + +MODEL (stated precisely; see also the receipt field "model"). + * Registers 0..v-1 are X (sources), v..2v-1 are Y (targets), 2v..2v+R-1 helpers; n = 2v+R. Removed helpers + do not exist. A buffer register b = r+n exists only for r in helper_final (restored cold helpers) and only + in cleanup. + * Frame = GF(2)-subspace of F_2^h (h = 9), compared as spans. Start: X_i = span(port_i), Y = 0, helper = + start_extra[r] or 0. End: X = FULL, Y_i = port_i^perp, helper = helper_final[r] or FULL. + * Initial (anticipatory) corrections {target t, source s, operator_word [k], coefficient c} run FIRST, before + the preconditioner (PR2226 PROOF section 3): t += c K_k s. Structure: t is a Y register, s a live + non-target register, c a non-zero dyadic rational, k an existing forward warp whose lender is s (each term is + c K_G z for the pair lent by s), operator words have length one. Frames: t and s must both be at frame 0 + when the term runs (s's entrance frame is 0); K_k fixes L_0 (checked for every warp), so applying K_k to s, + reading it into t and inverting it is rank zero and pays nothing. + * Every framed gate (add t s c F | scale t c F) climbs each incident register from its current frame S to F; + legal only if S <= F; a strict climb pays one child of rank dim F - dim S. precondition/compensation are at + frame 0 and write targets only. + * After A every target sits at its level and every centre at its centre frame; cut gates add c*centre into a + target at its level; each centre pays one COPY child of rank dim(centre frame) - dim(level) per distinct + served level (nested chain). + * warp [pos, L, G, U, E] is inserted before B[pos] (list order inside a position): requires cur[L] == span U, + sets cur[L] = span E, pays nothing (rank-zero reference change K_G); logically L <- K_G L. + * After B and restore every live register climbs to its end frame (paid). cleanup items must all be at FULL, + may touch only live registers at FULL or buffers; they pay nothing. + * Logic: exact replay over Q (rationals x free group on K_1..K_80). Every live register starts as an + independent symbol (arbitrary dirty content); buffers start at 0. add t += c s, scale t *= c, warp + left-multiplies by K_k^{+-1} with free-group cancellation, a correction adds c K_k (row of s) to t. LOW-lender + exactness (PR2226 PROOF section 3): immediately before every warp whose operator occurs in a correction, the + lender's row must be exactly its own input symbol. Accept iff after cleanup Y_i = Y_i + X_i, every other + live register is its own input and every buffer is 0. The dual orientation replays g^{-T} for every item + (add -> s -= c t, scale -> 1/c, K -> K^{-T} as new free letters, correction -> s -= c K_k^T t with + K_k^T = (K_k^{-T})^{-1}) and expects X_i = X_i - Y_i. + * Warp algebra over GF(2): G invertible, dim U = dim E, G span U = span E, M = [[G,0],[G+G^-T,G^-T]] + symplectic, M L_0 = L_0, M L_FULL = L_FULL, M L_U = L_E (Fourier rank 0), G^-T U^perp = E^perp. Exact + Clifford phases / Gaussian lifts are NOT checked here. + * Links (witness/canonical/block certificate): the B section is the canonical B plus the 48 moved tail gates, + each removed helper renamed to its lender, minus the low helpers' pre-handoff echo/temporary gates, plus + the direct-read rewrites that this checker DERIVES from those deleted gates (temporaries must be net zero; + an echo t += c h reading a temporary part a*ext becomes t += c*a ext at the echo's frame). Every other + pre-handoff event of an aliased helper must be a helper-only correction inside its block. +""" + +import sys + +if sys.flags.optimize: + sys.stdout.write('refusing to run under python -O\nFAIL_T74_LOW_ALIAS_WORDS_INDEPENDENT\n') + sys.exit(2) + +import argparse +import copy +import gzip +import hashlib +import json +import os +import subprocess +import time +from collections import Counter +from fractions import Fraction + +PASS_LINE = 'PASS_T74_LOW_ALIAS_WORDS_INDEPENDENT' +FAIL_LINE = 'FAIL_T74_LOW_ALIAS_WORDS_INDEPENDENT' +HERE = os.path.dirname(os.path.abspath(__file__)) +DEFAULT_REPO = os.path.dirname(os.path.dirname(HERE)) +RECEIPT = 'check_ext.receipt.json' + +PR2269 = 'b479fc5567bc09ab9185bffe89b62594f36d74e5' +PR2269_PKG = 'research/gmx-t74-borrow43/' +PR2226 = 'dacaf3d81f1936bb55b8454b1244e5d014272754' +PR2226_PKG = 'research/anticipatory-dirty-borrowing/' + +# key -> (commit, repo path, git blob id, sha256) +GIT_PINS = { + 'word43_base': (PR2269, PR2269_PKG + 'new/borrow/words/BORROW-WORD-43base.json.gz', + '448dd795adba29392a90b34aa3f1b1b796c7e0bd', + '9492a5537fb87d9ca98dffcd0230f7625b3789744fa94e2f18acf23d91d998b5'), + 'word43_extra': (PR2269, PR2269_PKG + 'new/borrow/words/BORROW-WORD-43extra.json.gz', + '2b51ba96256283bbc5578f99b694c50edd8a0e35', + '87d51f5298101d5947f45c43ee02f0ec45d6acbddabb808d0d02db1eaf063734'), + 'canon_base': (PR2269, PR2269_PKG + 'new/borrow/inputs/gauge44.canonical.json.gz', + '4abb6e28f02c95b41ed345d4e4401d16d58ae791', + '65c6d17ffee2eacf27bff438f37fc549c9ed0c909cbc7a52976cc75cf2d15b91'), + 'canon_extra': (PR2269, PR2269_PKG + 'new/borrow/inputs/extra.canonical.json.gz', + 'e0d670d4351229ce6921ecfbecf180070b17616b', + 'd7e48dcbafa236a2e1e41f7958244211506f7c7630fe6a2d43d2bdf17b7ae015'), + 'blocks': (PR2269, PR2269_PKG + 'new/borrow/inputs/blocks.json', + 'c683574b3861678081fd5c5944dbd7a47309f6fd', + 'ddfac1dae1fe7cc0a91e7c7205c6d9d0c07c682880aa34eed83bf4ad7384da9f'), + 'witness43_base': (PR2269, PR2269_PKG + 'new/borrow/inputs/witness_43_base.json', + '9f4b93f3bc52d4f4ffaa128cfd7ae574fd36c462', + '67ffb66d94067f6e53aee9118fe90e14a57f497fc8b3f708b6dac3de2e58ff28'), + 'witness43_extra': (PR2269, PR2269_PKG + 'new/borrow/inputs/witness_43_extra.json', + '864ba533f50c2f1f639a6a3559b185bd321b923a', + 'd46449c6dbf4477f260cf5baea9bbb570a66ee0b6db81f4a220b9e3086ae9e46'), + 'word566_base': (PR2269, PR2269_PKG + 'new/gauge44-word-566.json.gz', + '76c01583a0286cddb0f71e0cb13077e4317104f6', + 'eeb6a236ed0ea8873b8800947d0cd19c36a6fcfdf857fc42913cb45cd984f219'), + 'word566_extra': (PR2269, PR2269_PKG + 'new/extra-word-566.json.gz', + 'e86142b352466f54a3da38c96a6e1484145c3b5c', + 'cd417b904408c221d9840d08faff8af040cc4207f9804284f2f5375d21298a62'), + 'pr2226_witness': (PR2226, PR2226_PKG + 'WITNESS.json', + '62edbcce166f7cf388231078c2cd7f75939b97e2', + '86392adde6992a08ae90f7a69c58cace1b52d942f4d2c96e82ca79e5d1e15235'), +} + +# key -> (path relative to this package, git blob id, sha256): the constructed objects under test +LOCAL_PINS = { + 'word80_base': ('words/BORROW-WORD-80base.json.gz', 'c5953dfdb0ee9ac0c2c73eb29e320582b4569d2b', + '61290abffd8c8225e0abb3958c1506674e256de688fc4cdf358bbe7c981df493'), + 'word80_extra': ('words/BORROW-WORD-80extra.json.gz', '852868543ed36efa799b3ed6dd76a0442b0d6ff1', + '1dd2d6f2ae5b5a27b5f89fb830203f0cca7a78d0323a7845e85e1e80f8f6d1a5'), + 'witness80_base': ('witness/witness_80_base.json', 'cdcd39ff1beb577b975e48633d05ee629caa1362', + '9380f74c032b0616d5b13e8ef94b6d9f80cac36239e329357e7d5fcab5283ad0'), + 'witness80_extra': ('witness/witness_80_extra.json', '6b87d35600c44d053bf5ce03e34fc315d5a2af4a', + '6737072dcca47c6e6526bd62a41585dd09026549550c9e62eb53e64b265a6709'), +} + +# Claims under test, written here from the construction report (not read from the files). +CLAIMS = { + 'ext80': { + 'base': dict(profile={1: 2303, 2: 527, 3: 386, 4: 125, 5: 37, 8: 8}, base_tag='eeb6a236'), + 'extra': dict(profile={1: 2287, 2: 535, 3: 386, 4: 125, 5: 37, 8: 8}, base_tag='cd417b90'), + 'width_inventory': {4: 4, 5: 4, 7: 36, 8: 84, 9: 272}, 'helpers': 400, 'warps': 80, 'low': 32, + 'high': 48, 'corrections': 64, 'mass': 5264, 'buffers': 44, 'inputs': 624, 'rewrites': 5, + 'new_high_X_lenders': [1, 4, 6, 12, 31]}, + 'b43': { # PR2269 predecessor (positive control of this checker on zero-correction words) + 'base': dict(profile={1: 2351, 2: 501, 3: 414, 4: 129, 5: 42, 8: 8}, base_tag='eeb6a236'), + 'extra': dict(profile={1: 2339, 2: 509, 3: 418, 4: 125, 5: 42, 8: 8}, base_tag='cd417b90'), + 'width_inventory': {4: 36, 5: 9, 7: 36, 8: 116, 9: 240}, 'helpers': 437, 'warps': 43, 'low': 0, + 'high': 43, 'corrections': 0, 'mass': 5385, 'buffers': 76, 'inputs': 661, 'rewrites': 0}, + 'canonical': {'base': {1: 2348, 2: 500, 3: 416, 4: 130, 5: 82, 8: 8}, + 'extra': {1: 2340, 2: 508, 3: 420, 4: 126, 5: 82, 8: 8}}, + 'helpers_before': 480, +} + + +class Reject(Exception): + """A failed check; .check names the check family that rejected.""" + + def __init__(self, check, msg): + Exception.__init__(self, '[%s] %s' % (check, msg)) + self.check = check + self.msg = msg + + +def need(cond, check, msg): + if not cond: + raise Reject(check, msg) + + +# ---------------------------------------------------------------------------- +# Input loading and pinning +# ---------------------------------------------------------------------------- + +def git_blob_id(data): + h = hashlib.sha1() + h.update(b'blob %d\0' % len(data)) + h.update(data) + return h.hexdigest() + + +def verify_bytes(what, data, blob, sha): + need(git_blob_id(data) == blob, 'pin', 'git blob id mismatch for %s' % what) + need(hashlib.sha256(data).hexdigest() == sha, 'pin', 'sha256 mismatch for %s' % what) + + +def load_inputs(repo): + raw, pins = {}, {} + for key in sorted(GIT_PINS): + commit, path, blob, sha = GIT_PINS[key] + got = subprocess.run(['git', '-C', repo, 'rev-parse', commit + ':' + path], capture_output=True, text=True) + need(got.returncode == 0, 'pin', 'cannot resolve %s at %s (fetch the PR head first: git fetch ' + 'https://github.com/CrocSwap/integer-mult-bounds pull//head)' % (path, commit[:8])) + need(got.stdout.strip() == blob, 'pin', 'path %s does not resolve to the pinned blob' % path) + got = subprocess.run(['git', '-C', repo, 'cat-file', 'blob', blob], capture_output=True) + need(got.returncode == 0, 'pin', 'cannot read blob %s' % blob) + verify_bytes(path, got.stdout, blob, sha) + raw[key] = got.stdout + pins[key] = dict(commit=commit, path=path, git_blob=blob, sha256=sha, bytes=len(got.stdout)) + for key in sorted(LOCAL_PINS): + rel, blob, sha = LOCAL_PINS[key] + with open(os.path.join(HERE, rel), 'rb') as fh: + data = fh.read() + verify_bytes(rel, data, blob, sha) + raw[key] = data + pins[key] = dict(local=rel, git_blob=blob, sha256=sha, bytes=len(data)) + js = {} + for key, data in raw.items(): + path = GIT_PINS[key][1] if key in GIT_PINS else LOCAL_PINS[key][0] + if path.endswith('.gz'): + data = gzip.decompress(data) + js[key] = json.loads(data.decode('utf-8')) + return js, pins, raw + + +# ---------------------------------------------------------------------------- +# GF(2) linear algebra on integer bit vectors +# ---------------------------------------------------------------------------- + +def parity(x): + return bin(x).count('1') & 1 + + +def echelon(vectors): + """Fully reduced echelon basis {pivot bit: vector} of the span of the vectors.""" + piv = {} + for x in vectors: + x = int(x) + for b in list(piv): + if (x >> b) & 1: + x ^= piv[b] + if x: + lead = x.bit_length() - 1 + for b in list(piv): + if (piv[b] >> lead) & 1: + piv[b] ^= x + piv[lead] = x + return piv + + +def span(vectors): + """Canonical key of a subspace: its reduced echelon basis, sorted decreasingly.""" + return tuple(sorted(echelon(vectors).values(), reverse=True)) + + +def reduce_by(x, piv): + for b, vec in piv.items(): + if (x >> b) & 1: + x ^= vec + return x + + +def contains(small, big): + piv = echelon(big) + return all(reduce_by(x, piv) == 0 for x in small) + + +def dim_sum(a, b): + return len(span(list(a) + list(b))) + + +def perp(sub, h): + return span([x for x in range(1, 1 << h) if all(parity(x & u) == 0 for u in sub)]) + + +def mat_apply(cols, x): + y = 0 + i = 0 + while x: + if x & 1: + y ^= cols[i] + x >>= 1 + i += 1 + return y + + +def mat_inverse(cols, h): + """Columns of G^{-1}, or None if G is singular over GF(2).""" + piv = {} + for i in range(h): + a, b = cols[i], 1 << i # invariant: G(b) = a + for p in list(piv): + pa, pb = piv[p] + if (a >> p) & 1: + a ^= pa + b ^= pb + if a == 0: + return None + lead = a.bit_length() - 1 + for p in list(piv): + pa, pb = piv[p] + if (pa >> lead) & 1: + piv[p] = (pa ^ a, pb ^ b) + piv[lead] = (a, b) + inv = [0] * h + for p, (a, b) in piv.items(): + if a != (1 << p): + return None + inv[p] = b + return inv + + +def mat_transpose(cols, h): + return [sum(((cols[r] >> j) & 1) << r for r in range(h)) for j in range(h)] + + +def lagrangian(sub, h): + """L_W = {(u, u+p): u in W, p in W^perp} encoded as x | z << h.""" + return span([u | (u << h) for u in sub] + [p << h for p in perp(sub, h)]) + + +def symp(a, b, h): + mask = (1 << h) - 1 + return parity((a & mask) & (b >> h)) ^ parity((a >> h) & (b & mask)) + + +# ---------------------------------------------------------------------------- +# Parsing (borrow word and canonical word) into one internal program shape +# ---------------------------------------------------------------------------- + +def is_int(x): + return isinstance(x, int) and not isinstance(x, bool) + + +def dyadic(q): + return q.denominator & (q.denominator - 1) == 0 + + +def unit(q): + a = abs(q.numerator) + return a > 0 and a & (a - 1) == 0 and dyadic(q) + + +def regs_of(item): + if item[0] == 'add': + return (item[1], item[2]) + return (item[1],) + + +def conv_gate(g, frame_of, where, allow_warp=False): + need(isinstance(g, list) and g, 'format', 'gate is not a list at %s' % where) + op = g[0] + if op == 'add': + need(len(g) == 6 and all(is_int(x) for x in g[1:5]), 'format', 'bad add at %s' % where) + need(g[4] > 0 and g[3] != 0, 'format', 'bad add coefficient at %s' % where) + q = Fraction(g[3], g[4]) + need(dyadic(q), 'format', 'non-dyadic coefficient at %s' % where) + need(g[1] != g[2], 'format', 'self add at %s' % where) + return ('add', g[1], g[2], q, frame_of(g[5])) + if op == 'scale': + need(len(g) == 5 and all(is_int(x) for x in g[1:4]), 'format', 'bad scale at %s' % where) + need(g[3] != 0 and g[2] != 0, 'format', 'zero scale at %s' % where) + q = Fraction(g[2], g[3]) + need(unit(q), 'format', 'scale is not a dyadic unit at %s' % where) + return ('scale', g[1], q, frame_of(g[4])) + if op == 'warp' and allow_warp: + need(len(g) == 4 and is_int(g[1]) and is_int(g[2]) and g[2] != 0, 'format', 'bad warp item at %s' % where) + return ('warp', g[1], g[2], frame_of(g[3])) + raise Reject('format', 'unknown primitive %r at %s' % (op, where)) + + +def parse_correction(t, j): + need(isinstance(t, dict) and set(t) == {'target', 'source', 'operator_word', 'coefficient'}, 'format', + 'initial correction %d: fields' % j) + need(is_int(t['target']) and is_int(t['source']), 'format', 'initial correction %d: registers' % j) + ow = t['operator_word'] + need(isinstance(ow, list) and len(ow) == 1 and is_int(ow[0]) and ow[0] > 0, 'anticipatory', + 'initial correction %d: operator word must be a single forward warp id (scope of this checker)' % j) + need(isinstance(t['coefficient'], str), 'format', 'initial correction %d: coefficient must be a string' % j) + try: + q = Fraction(t['coefficient']) + except (ValueError, ZeroDivisionError): + raise Reject('format', 'initial correction %d: coefficient %r' % (j, t['coefficient'])) + need(q != 0 and dyadic(q), 'anticipatory', 'initial correction %d: coefficient is not a non-zero dyadic' % j) + return dict(target=t['target'], source=t['source'], op=ow[0], coef=q) + + +def check_corrections(P): + """Structure of the anticipatory terms (PR2226 PROOF section 3): t += c K_G z for the pair lent by z.""" + v = P['v'] + by_op = dict((wr['op'], wr) for wr in P['warps']) + live = set(P['live']) + for j, t in enumerate(P['corr']): + need(v <= t['target'] < 2 * v, 'anticipatory', 'correction %d writes a non-target %d' % (j, t['target'])) + need(t['source'] in live and not (v <= t['source'] < 2 * v), 'anticipatory', + 'correction %d source %d is not a live non-target register' % (j, t['source'])) + need(t['op'] in by_op, 'anticipatory', 'correction %d names a missing warp %d' % (j, t['op'])) + need(by_op[t['op']]['lender'] == t['source'], 'anticipatory', + 'correction %d: operator %d is not the reference change of the pair lent by source %d' % ( + j, t['op'], t['source'])) + return dict(terms=len(P['corr']), operators=len(set(t['op'] for t in P['corr'])), + sources=len(set(t['source'] for t in P['corr']))) + + +def parse_borrow(w): + need(w.get('kind') == 'BORROW-WORD', 'format', 'not a BORROW-WORD') + rep = w['report'] + v, h, R = rep['v'], rep['h'], rep['R'] + need((v, h, R) == (112, 9, 480), 'format', 'unexpected geometry') + n = 2 * v + R + full = span([1 << i for i in range(h)]) + + def frame_lit(F): + if F is None: + return None + need(isinstance(F, list) and all(is_int(x) and 0 < x < (1 << h) for x in F), 'format', 'bad frame literal') + return span(F) + + ports = w['ports'] + need(len(ports) == v and all(is_int(p) and 0 < p < (1 << h) for p in ports), 'format', 'ports') + removed = w['removed'] + need(len(set(removed)) == len(removed) and all(2 * v <= r < n for r in removed), 'format', 'removed helpers') + removed = set(removed) + live = [r for r in range(n) if r not in removed] + start, end = {}, {} + for i in range(v): + start[i] = span([ports[i]]) + end[i] = full + start[v + i] = () + end[v + i] = perp(span([ports[i]]), h) + for r in live: + if r >= 2 * v: + start[r] = () + end[r] = full + for k, F in w['start_extra'].items(): + r = int(k) + need(r in start and r >= 2 * v, 'format', 'start_extra names a non-live/non-helper register %s' % k) + start[r] = frame_lit(F) + restored = set() + for k, F in w['helper_final'].items(): + r = int(k) + need(r in end and r >= 2 * v, 'format', 'helper_final names a non-live/non-helper register %s' % k) + end[r] = frame_lit(F) + restored.add(r) + need(isinstance(w.get('initial_corrections'), list), 'format', 'initial_corrections missing') + corr = [parse_correction(t, j) for j, t in enumerate(w['initial_corrections'])] + sec = {} + for name in ('precondition', 'compensation', 'A', 'cut', 'B', 'restore'): + sec[name] = [conv_gate(g, frame_lit, '%s[%d]' % (name, i)) for i, g in enumerate(w[name])] + cleanup = [conv_gate(g, frame_lit, 'cleanup[%d]' % i, allow_warp=True) for i, g in enumerate(w['cleanup'])] + warps = [] + for k, rec in enumerate(w['warps'], 1): + need(isinstance(rec, list) and len(rec) == 5, 'format', 'warp record %d shape' % k) + pos, L, cols, U, E = rec + need(is_int(pos) and 0 <= pos <= len(sec['B']), 'format', 'warp %d position' % k) + need(is_int(L), 'format', 'warp %d lender' % k) + need(isinstance(cols, list) and len(cols) == h and all(is_int(c) and 0 <= c < (1 << h) for c in cols), + 'format', 'warp %d G columns' % k) + need(isinstance(U, list) and isinstance(E, list) and all(is_int(x) and 0 < x < (1 << h) for x in U + E), + 'format', 'warp %d frames' % k) + warps.append(dict(op=k, pos=pos, lender=L, G=list(cols), U_list=list(U), E_list=list(E), + U=span(U), E=span(E))) + by_pos = {} + for wr in warps: + by_pos.setdefault(wr['pos'], []).append(wr) + items = [] + for p in range(len(sec['B']) + 1): + for wr in by_pos.get(p, []): + items.append(('warp', wr['lender'], wr['op'], wr['U'], wr['E'])) + if p < len(sec['B']): + items.append(sec['B'][p]) + P = dict(kind='borrow', v=v, h=h, R=R, n=n, full=full, ports=ports, live=live, removed=removed, + start=start, end=end, restored=restored, buffers=set(r + n for r in restored), + centers=list(w['centers']), center_frames=[frame_lit(F) for F in w['center_frames']], + target_levels={int(k): frame_lit(F) for k, F in w['target_levels'].items()}, + corr=corr, pre=sec['precondition'] + sec['compensation'], n_pre=len(sec['precondition']), + A=sec['A'], cut=sec['cut'], B_items=items, post=sec['restore'], cleanup=cleanup, + warps=warps, sections=sec, + claimed_profile={int(k): c for k, c in rep['local_profile'].items()}, + claimed_inventory={int(k): c for k, c in rep['width_inventory'].items()}) + check_corrections(P) + return P + + +def parse_canonical(c): + v, h, R = c['v'], c['h'], c['R'] + need((v, h, R) == (112, 9, 480), 'format', 'unexpected canonical geometry') + n = 2 * v + R + full = span([1 << i for i in range(h)]) + frames = [] + for F in c['frames']: + need(isinstance(F, list) and all(is_int(x) and 0 < x < (1 << h) for x in F), 'format', 'canonical frame') + need(len(span(F)) == len(F), 'format', 'canonical frame basis is dependent') + frames.append(span(F)) + + def frame_idx(F): + if F is None: + return None + need(is_int(F) and 0 <= F < len(frames), 'format', 'canonical frame index') + return frames[F] + + ports = c['ports'] + need(len(c['start']) == n and len(c['final']) == n, 'format', 'canonical start/final length') + start = {r: frames[c['start'][r]] for r in range(n)} + end = {r: frames[c['final'][r]] for r in range(n)} + for i in range(v): + need(start[i] == span([ports[i]]), 'format', 'canonical X start is not its port line') + need(end[i] == full, 'format', 'canonical X end is not FULL') + need(start[v + i] == (), 'format', 'canonical Y start is not 0') + need(end[v + i] == perp(span([ports[i]]), h), 'format', 'canonical Y end is not port-perp') + sec = {} + for name in ('precondition', 'compensation', 'A', 'cut', 'B', 'tail', 'cleanup'): + sec[name] = [conv_gate(g, frame_idx, 'canon %s[%d]' % (name, i)) for i, g in enumerate(c[name])] + return dict(kind='canonical', v=v, h=h, R=R, n=n, full=full, ports=ports, live=list(range(n)), + removed=set(), start=start, end=end, restored=set(), buffers=set(), + centers=list(c['centers']), center_frames=[frames[i] for i in c['center_frames']], + target_levels={int(k): frame_idx(F) for k, F in c['target_levels'].items()}, + corr=[], pre=sec['precondition'] + sec['compensation'], n_pre=len(sec['precondition']), + A=sec['A'], cut=sec['cut'], B_items=list(sec['B']), post=sec['tail'], cleanup=sec['cleanup'], + warps=[], sections=sec, frames=frames, + claimed_profile={int(k): x for k, x in c['local_profile'].items()}, claimed_inventory=None) + + +# ---------------------------------------------------------------------------- +# Check 1: warp algebra +# ---------------------------------------------------------------------------- + +def check_warp(wr, h, live, v): + k = wr['op'] + cols = wr['G'] + inv = mat_inverse(cols, h) + need(inv is not None, 'warp', 'warp %d: G is singular over GF(2)' % k) + need(all(mat_apply(cols, inv[t]) == 1 << t and mat_apply(inv, cols[t]) == 1 << t for t in range(h)), + 'warp', 'warp %d: inverse witness' % k) + U, E = wr['U'], wr['E'] + need(len(U) == len(wr['U_list']) and len(E) == len(wr['E_list']), 'warp', + 'warp %d: U or E list is linearly dependent' % k) + need(len(U) == len(E), 'warp', 'warp %d: dim U != dim E' % k) + need(span([mat_apply(cols, u) for u in U]) == E, 'warp', 'warp %d: G span U != span E' % k) + git = mat_transpose(inv, h) # G^{-T} + mask = (1 << h) - 1 + + def M(vec): + x, z = vec & mask, vec >> h + gx = mat_apply(cols, x) + return gx | ((gx ^ mat_apply(git, x) ^ mat_apply(git, z)) << h) + + gens = [1 << i for i in range(2 * h)] + imgs = [M(g) for g in gens] + need(len(span(imgs)) == 2 * h, 'warp', 'warp %d: K_G singular' % k) + for a in range(2 * h): + for b in range(a + 1, 2 * h): + need(symp(imgs[a], imgs[b], h) == symp(gens[a], gens[b], h), 'warp', 'warp %d: K_G not symplectic' % k) + full = span([1 << i for i in range(h)]) + L0, LF, LU, LE = lagrangian((), h), lagrangian(full, h), lagrangian(U, h), lagrangian(E, h) + need(len(L0) == len(LF) == len(LU) == len(LE) == h, 'warp', 'warp %d: Lagrangian dimension' % k) + need(span([M(x) for x in L0]) == L0, 'warp', 'warp %d: K_G does not fix L_0' % k) + need(span([M(x) for x in LF]) == LF, 'warp', 'warp %d: K_G does not fix L_FULL' % k) + MLU = span([M(x) for x in LU]) + rank_in = h - (len(LE) + len(MLU) - dim_sum(LE, MLU)) + need(MLU == LE and rank_in == 0, 'warp', 'warp %d: K_G L_U != L_E (Fourier rank %d)' % (k, rank_in)) + need(span([mat_apply(git, p) for p in perp(U, h)]) == perp(E, h), 'warp', 'warp %d: G^-T U^perp != E^perp' % k) + need(wr['lender'] in live and not (v <= wr['lender'] < 2 * v), 'warp', + 'warp %d: lender must be a live non-target register' % k) + plain = h - (2 * h - dim_sum(LU, LE)) + by_formula = len(U) + len(E) - 2 * (len(U) + len(E) - dim_sum(U, E)) + need(plain == by_formula, 'warp', 'warp %d: Lagrangian distance lemma inconsistency' % k) + return dict(op=k, pos=wr['pos'], lender=wr['lender'], dim=len(U), plain_fourier_distance=plain, + U_eq_E=(U == E), U_in_E=contains(U, E)) + + +def check_all_warps(P): + out = [check_warp(wr, P['h'], set(P['live']), P['v']) for wr in P['warps']] + lenders = [wr['lender'] for wr in P['warps']] + need(len(set(lenders)) == len(lenders), 'warp', 'a register lends twice') + return out + + +# ---------------------------------------------------------------------------- +# Check 2: frame legality and paid-profile recount +# ---------------------------------------------------------------------------- + +def frame_check(P, charge_warps=False, warp_as_climb=()): + v, full = P['v'], P['full'] + cur = {r: P['start'][r] for r in P['live']} + paid, climbs, copies, warp_charge = Counter(), Counter(), Counter(), Counter() + per_reg = Counter() + istarget = lambda r: v <= r < 2 * v + + def climb(r, F, where): + need(r in cur, 'frame', 'register %d is not live (%s)' % (r, where)) + old = cur[r] + need(contains(old, F), 'frame', 'non-nested climb of %d at %s: %r -> %r' % (r, where, old, F)) + d = len(F) - len(old) + if d: + paid[d] += 1 + climbs[d] += 1 + per_reg[r] += d + cur[r] = F + + # anticipatory initial corrections: before the preconditioner, both ends at frame 0, K_k rank zero there + for j, t in enumerate(P['corr']): + for role in ('target', 'source'): + r = t[role] + need(r in cur, 'frame', 'initial correction %d: %s %d is not live' % (j, role, r)) + need(cur[r] == (), 'frame', 'initial correction %d: %s %d is not at frame 0 (frame %r)' % ( + j, role, r, cur[r])) + for i, g in enumerate(P['pre']): + need(g[-1] == (), 'frame', 'precondition/compensation gate %d not at frame 0' % i) + need(istarget(g[1]), 'frame', 'precondition/compensation gate %d writes a non-target' % i) + for r in regs_of(g): + climb(r, (), 'pre[%d]' % i) + for i, g in enumerate(list(P['A']) + [it for it in P['B_items'] if it[0] != 'warp'] + list(P['post'])): + need(not (g[0] == 'add' and not istarget(g[1]) and istarget(g[2])), 'frame', + 'a non-target register reads a target (item %d of A+B+post)' % i) + for i, g in enumerate(P['A']): + need(g[-1] is not None, 'frame', 'unframed gate in A') + for r in regs_of(g): + climb(r, g[-1], 'A[%d]' % i) + for t in range(v): + need(cur[v + t] == P['target_levels'].get(t, ()), 'frame', 'target %d not at its level after A' % t) + need(len(set(P['centers'])) == len(P['centers']) == len(P['center_frames']), 'frame', 'centres') + for q, U in zip(P['centers'], P['center_frames']): + need(q in cur and cur[q] == U, 'frame', 'centre %d not at its centre frame after A' % q) + served = dict((q, set()) for q in P['centers']) + for i, g in enumerate(P['cut']): + need(g[0] == 'add' and g[-1] is None, 'frame', 'cut[%d] is not an unframed add' % i) + t, s = g[1], g[2] + need(istarget(t) and s in served, 'frame', 'cut[%d] must add a centre into a target' % i) + need(cur[t] == P['target_levels'].get(t - v, ()), 'frame', 'cut[%d] target off its level' % i) + served[s].add(cur[t]) + for q, U in zip(P['centers'], P['center_frames']): + prev = U + for T in sorted(served[q], key=lambda S: (-len(S), S)): + need(contains(T, prev), 'frame', 'centre %d copy levels not nested' % q) + if T != prev: + paid[len(prev) - len(T)] += 1 + copies[len(prev) - len(T)] += 1 + prev = T + for i, it in enumerate(P['B_items']): + if it[0] == 'warp': + _, L, k, U, E = it + need(L in cur and not istarget(L), 'frame', 'warp %d lender %d not a live non-target' % (k, L)) + if k in warp_as_climb: + climb(L, E, 'warp %d treated as an ordinary climb' % k) + continue + need(cur[L] == U, 'frame', 'warp %d: lender %d frame %r != U %r' % (k, L, cur[L], U)) + if charge_warps: + d = len(U) + len(E) - 2 * (len(U) + len(E) - dim_sum(U, E)) + if d: + paid[d] += 1 + warp_charge[d] += 1 + cur[L] = E + else: + need(it[-1] is not None, 'frame', 'unframed gate in B') + for r in regs_of(it): + climb(r, it[-1], 'B item %d' % i) + for i, g in enumerate(P['post']): + need(g[-1] is not None, 'frame', 'unframed gate after B') + for r in regs_of(g): + climb(r, g[-1], 'post-B[%d]' % i) + for r in P['live']: + climb(r, P['end'][r], 'end frame') + for i, it in enumerate(P['cleanup']): + need(it[-1] == full, 'frame', 'cleanup item %d not at FULL' % i) + rr = (it[1],) if it[0] == 'warp' else regs_of(it) + for r in rr: + if r in P['buffers']: + continue + need(r in cur and cur[r] == full, 'frame', + 'cleanup item %d touches register %d whose frame is not FULL' % (i, r)) + for r in P['live']: + need(per_reg[r] == len(P['end'][r]) - len(P['start'][r]), 'frame', 'per-register charge != width for %d' % r) + helpers = [r for r in P['live'] if r >= 2 * v] + inventory = Counter(len(P['end'][r]) - len(P['start'][r]) for r in helpers) + return dict(paid=paid, climbs=climbs, copies=copies, warp_charge=warp_charge, inventory=inventory, + helpers=len(helpers), widths=[len(P['end'][r]) - len(P['start'][r]) for r in sorted(helpers)], + helper_width_sum=sum(inventory[k] * k for k in inventory), + mass=sum(k * c for k, c in paid.items())) + + +# ---------------------------------------------------------------------------- +# Check 3: exact replay over the free-group algebra Q +# ---------------------------------------------------------------------------- + +ONE = Fraction(1) + + +def left_mult(letter, word): + inverse = (letter[0], letter[1], -letter[2]) + return word[1:] if (word and word[0] == inverse) else (letter,) + word + + +def replay(P, dual=False): + v = P['v'] + rows = {} + for r in P['live']: + rows[r] = {(r, ()): ONE} + for b in P['buffers']: + rows[b] = {} + istarget = lambda r: v <= r < 2 * v + low_ops = set(t['op'] for t in P['corr']) + + def row(r): + need(r in rows, 'replay', 'unknown register %d' % r) + return rows[r] + + def axpy(dst, src, c, letter=None): + for (var, word), val in list(src.items()): + key = (var, word if letter is None else left_mult(letter, word)) + nv = dst.get(key, 0) + c * val + if nv: + dst[key] = nv + else: + del dst[key] + + def do(it): + kind = it[0] + if kind == 'add': + t, s, c = it[1], it[2], it[3] + if dual: + t, s, c = s, t, -c + need(t != s, 'replay', 'self add') + axpy(row(t), row(s), c) + elif kind == 'scale': + t, c = it[1], it[2] + if dual: + c = 1 / c + rr = row(t) + for key in rr: + rr[key] = rr[key] * c + elif kind == 'warp': + reg, k = it[1], it[2] + letter = (abs(k), 1 if dual else 0, 1 if k > 0 else -1) + rows[reg] = dict(((var, left_mult(letter, word)), val) for (var, word), val in row(reg).items()) + else: + raise Reject('replay', 'unknown item') + + # 0. anticipatory initial corrections: t += c K_k s (dual: s -= c K_k^T t, K_k^T = (K_k^{-T})^{-1}) + for t in P['corr']: + if not dual: + axpy(row(t['target']), row(t['source']), t['coef'], (t['op'], 0, 1)) + else: + axpy(row(t['source']), row(t['target']), -t['coef'], (t['op'], 1, -1)) + for it in list(P['pre']) + list(P['A']) + list(P['cut']): + do(it) + exact_lenders = 0 + for it in P['B_items']: + if it[0] == 'warp': + if not dual and it[2] in low_ops: + need(row(it[1]) == {(it[1], ()): ONE}, 'lender', + 'low lender %d is not exactly its own input at the handoff of warp %d' % (it[1], it[2])) + exact_lenders += 1 + do(('warp', it[1], it[2])) + else: + do(it) + for it in P['post']: + do(it) + diag = {} + need(all(not rows[b] for b in P['buffers']), 'replay', 'a buffer is non-zero before cleanup') + if not dual: + diag['low_lenders_exact_at_handoff'] = exact_lenders + for t in range(v): + need(rows[v + t] == {(v + t, ()): ONE, (t, ()): ONE}, 'replay', 'target %d not final before cleanup' % t) + for r in P['restored']: + need(rows[r] == {(r, ()): ONE}, 'replay', 'restored cold register %d is not its own input' % r) + readers = [r for r in P['live'] if r not in P['restored'] and not istarget(r) + and any(var in P['restored'] for var, _ in rows[r])] + need(not readers, 'replay', 'restored inputs still read by %r' % readers[:5]) + diag['rows_with_operator_words_before_cleanup'] = sum( + 1 for r in P['live'] if any(word for _, word in rows[r])) + peak = 0 + first_live = last_live = None + span_of = {} + noop_buffer_reads = 0 + for i, it in enumerate(P['cleanup']): + if it[0] == 'add': + src = it[2] if not dual else it[1] + if src in P['buffers'] and not rows[src]: + noop_buffer_reads += 1 + do(it) + live_buffers = 0 + for b in P['buffers']: + if rows[b]: + live_buffers += 1 + lo, hi = span_of.get(b, (i, i)) + span_of[b] = (min(lo, i), i) + if live_buffers: + first_live = i if first_live is None else first_live + last_live = i + peak = max(peak, live_buffers) + events = sorted([(lo, 1) for lo, hi in span_of.values()] + [(hi + 1, -1) for lo, hi in span_of.values()]) + overlap = best = 0 + for _, d in events: + overlap += d + best = max(best, overlap) + diag['buffers_ever_nonzero'] = len(span_of) + diag['max_overlap_of_buffer_lifetimes'] = best + diag['cleanup_adds_reading_a_zero_buffer'] = noop_buffer_reads + for r in P['live']: + if dual: + exp = {(r, ()): ONE, (r + v, ()): -ONE} if r < v else {(r, ()): ONE} + else: + exp = {(r, ()): ONE, (r - v, ()): ONE} if istarget(r) else {(r, ()): ONE} + need(rows[r] == exp, 'replay', 'final map wrong on register %d (%s)' % (r, 'dual' if dual else 'forward')) + need(all(not rows[b] for b in P['buffers']), 'replay', 'a zero buffer is not returned to zero') + # backstop after the algebraic checks: every low operator must have had its forward warp (and exactness test) + need(dual or exact_lenders == len(low_ops), 'lender', 'a low operator has no forward warp in B') + diag.update(peak_nonzero_buffers=peak, buffer_nonzero_window=[first_live, last_live], + buffers=len(P['buffers']), independent_inputs=len(P['live']), corrections=len(P['corr'])) + return diag + + +# ---------------------------------------------------------------------------- +# Links: canonical base, block certificate, witness, PR2226 terms, PR2269 43-word, 566 predecessor +# ---------------------------------------------------------------------------- + +def coef(g): + return g[3] if g[0] == 'add' else g[2] + + +def norm(g): + return (g[0],) + tuple(regs_of(g)) + (coef(g), g[-1]) + + +def block_maps(blocks): + high, low, block_of = set(), set(), {} + for bl in blocks['sources'][0]['blocks']: + high |= set(bl['high']) + low |= set(bl['low']) + for r in bl['helpers']: + need(r not in block_of, 'link', 'helper %d in two blocks' % r) + block_of[r] = bl + need(not (high & low), 'link', 'a helper is both high and low') + return high, low, block_of + + +def prefix_analysis(C, pairs, block_of, low, v): + """Derive, from the canonical B alone, what aliasing each helper requires before its handoff. + + For each aliased helper h with handoff index H (= its block's first input): every canonical B event on h + before H is either a helper-only correction inside h's block (deferred; kept) or, for a LOW helper only, + an echo t += c h (t a target; deleted) or a temporary h += a ext (ext outside the block, not a target; + deleted). Temporaries must have zero net change per source; an echo reading the current temporary part + sum a*ext becomes direct reads t += c*a ext at the echo's frame (the derived rewrites).""" + CB = C['sections']['B'] + istarget = lambda r: v <= r < 2 * v + events = {} + for i, g in enumerate(CB): + for r in set(regs_of(g)): + events.setdefault(r, []).append(i) + deleted, rewrites, info = set(), [], {} + for pr in pairs: + h = pr['register'] + bl = block_of[h] + H = pr['handoff_B'] + need(H == bl['first_input'], 'prefix', 'helper %d: handoff %r != block first input %r' % (h, H, bl['first_input'])) + helpers = set(bl['helpers']) + pre = [i for i in events.get(h, []) if i < H] + kept = [i for i in pre if all(r in helpers for r in regs_of(CB[i]))] + others = [i for i in pre if i not in kept] + if h not in low: + need(not others, 'prefix', 'high helper %d has a pre-handoff event outside helper-only corrections' % h) + need(not pr.get('deleted_prefix_indices') and not pr.get('deleted_echo_indices'), 'prefix', + 'high helper %d witness deletes gates' % h) + info[h] = dict(kind='high', deferred_helper_only=len(kept)) + continue + need(sorted(others) == sorted(pr.get('deleted_prefix_indices', [])), 'prefix', + 'low helper %d: witness deleted prefix %r != derived %r' % (h, pr.get('deleted_prefix_indices'), others)) + temp = {} + mine, echoes, temps = [], 0, 0 + for i in sorted(others): + g = CB[i] + need(g[0] == 'add', 'prefix', 'low helper %d: pre-handoff scale at B[%d]' % (h, i)) + if g[1] == h and g[2] not in helpers and not istarget(g[2]): + temp[g[2]] = temp.get(g[2], 0) + g[3] + temps += 1 + elif g[2] == h and istarget(g[1]): + echoes += 1 + for ext in sorted(temp): + if temp[ext]: + mine.append(('add', g[1], ext, g[3] * temp[ext], g[-1])) + else: + raise Reject('prefix', 'low helper %d: B[%d] %r is neither an echo nor a temporary' % (h, i, g)) + need(all(a == 0 for a in temp.values()), 'prefix', 'low helper %d: temporaries are not net zero' % h) + echo_idx = sorted(i for i in others if CB[i][2] == h) + need(echo_idx == sorted(pr.get('deleted_echo_indices', [])), 'prefix', 'low helper %d: echo indices' % h) + wit_rw = Counter() + for idx, lst in pr.get('early_prefix_rewrites', {}).items(): + need(int(idx) in others, 'prefix', 'low helper %d: rewrite keyed by a non-deleted index' % h) + for g in lst: + wit_rw[(g[1], g[2], Fraction(g[3], g[4]), C['frames'][g[5]])] += 1 + need(wit_rw == Counter((g[1], g[2], g[3], g[4]) for g in mine), 'prefix', + 'low helper %d: witness rewrites != derived rewrites' % h) + deleted |= set(others) + rewrites += mine + info[h] = dict(kind='low', deferred_helper_only=len(kept), echoes=echoes, temporaries=temps, rewrites=len(mine)) + return deleted, rewrites, info + + +def link_checks(tag, P, C, wit, blocks, w_raw): + out = {} + v, n, h = P['v'], P['n'], P['h'] + need(P['ports'] == C['ports'] and P['centers'] == C['centers'], 'link', 'ports/centres differ from canonical') + need(P['center_frames'] == C['center_frames'], 'link', 'centre frames differ from canonical') + removed = P['removed'] + high, low, block_of = block_maps(blocks) + need(removed <= (high | low), 'link', 'a removed helper is neither high nor low') + rh, rl = removed & high, removed & low + out['removed_high'], out['removed_low'] = len(rh), len(rl) + touches = lambda g: any(r in removed for r in regs_of(g)) + need(not any(touches(g) for g in C['sections']['compensation'] if any(r in rh for r in regs_of(g))), 'link', + 'canonical compensation reads a removed HIGH helper (a high helper must have zero response)') + for name in ('precondition', 'compensation', 'A', 'cut'): + kept = [norm(g) for g in C['sections'][name] if not touches(g)] + need([norm(g) for g in P['sections'][name]] == kept, 'link', 'section %s != canonical minus removed' % name) + out['canonical_%s_gates_dropped' % name] = len(C['sections'][name]) - len(kept) + for r in P['live']: + if r >= 2 * v: + need(P['start'][r] == C['start'][r], 'link', 'start frame of %d differs from canonical' % r) + for r in P['restored']: + need(P['end'][r] == C['end'][r], 'link', 'cold end frame of %d differs from canonical' % r) + canon_cold = [r for r in range(2 * v, n) if len(C['end'][r]) < h] + out['canonical_cold_helpers'] = len(canon_cold) + cold_full = sorted(r for r in canon_cold if r not in removed and r not in P['restored']) + out['canonical_cold_helpers_ending_FULL_after_borrowing'] = cold_full + grown = sum(len(P['end'][r]) - len(C['end'][r]) for r in cold_full) + removed_widths = sum(len(C['end'][r]) - len(C['start'][r]) for r in removed) + need(all(P['start'][r] == C['start'][r] and P['end'][r] == C['end'][r] for r in P['live'] if r not in cold_full), + 'link', 'some other register changed its start/end frame') + out['mass_identity'] = dict(removed_widths=removed_widths, width_added_to_cold_now_FULL=grown, + predicted_saving=removed_widths - grown) + out['removed_old_widths'] = dict(sorted(Counter(len(C['end'][r]) - len(C['start'][r]) for r in removed).items())) + # witness <-> word + pairs = wit['pairs'] + need(len(pairs) == len(P['warps']), 'link', 'witness pair count') + need(wit['initial_corrections'] == w_raw['initial_corrections'], 'link', 'witness corrections != word corrections') + gauss = dict((g['operator'], g['G_columns']) for g in wit['gaussian']['records']) + low_ops, low_lenders = set(), set() + for wr, pr in zip(P['warps'], pairs): + k = wr['op'] + need(pr['borrow_from'] == wr['lender'], 'link', 'warp %d lender != witness borrow_from' % k) + need(gauss.get(k) == wr['G'], 'link', 'warp %d G != witness Gaussian record' % k) + need(span(pr['retirement_basis']) == wr['U'], 'link', 'warp %d U != witness retirement basis' % k) + need(span(pr['handoff_basis']) == wr['E'], 'link', 'warp %d E != witness handoff basis' % k) + is_low = pr['register'] in low + need(pr['low'] is is_low and pr['anticipate'] is is_low and pr['handoff_paid_rank'] == 0, 'link', + 'warp %d witness flags (low/anticipate/handoff_paid_rank)' % k) + if is_low: + low_ops.add(k) + low_lenders.add(wr['lender']) + need(set(p['register'] for p in pairs) == removed, 'link', 'witness registers != removed set') + need(set(t['op'] for t in P['corr']) == low_ops, 'link', 'correction operators != the low pairs\' warps') + need(set(t['source'] for t in P['corr']) == low_lenders, 'link', 'correction sources != low lenders') + out['low_ops'] = sorted(low_ops) + out['low_lenders'] = sorted(low_lenders) + out['low_lenders_entrance_frame_dims'] = sorted(set(len(P['start'][L]) for L in low_lenders)) + out['low_lenders_canonical_final_dims'] = dict(sorted(Counter(len(C['end'][L]) for L in low_lenders).items())) + # B: canonical B + moved tail, renamed, minus derived deleted prefix, plus derived rewrites + deleted, rewrites, pinfo = prefix_analysis(C, pairs, block_of, low, v) + rename = dict((p['register'], p['borrow_from']) for p in pairs) + + def ren(g): + if g[0] == 'add': + return ('add', rename.get(g[1], g[1]), rename.get(g[2], g[2]), g[3], g[4]) + return ('scale', rename.get(g[1], g[1]), g[2], g[3]) + CB = C['sections']['B'] + moved = [C['sections']['tail'][e['old_tail_index']] for e in wit['early_tail_events']] + lhs = Counter(norm(ren(g)) for i, g in enumerate(CB) if i not in deleted) + lhs.update(norm(ren(g)) for g in moved) + lhs.update(norm(ren(g)) for g in rewrites) + rhs = Counter(norm(it) for it in P['B_items'] if it[0] != 'warp') + need(lhs == rhs, 'link', 'B multiset != canonical B - deleted prefix + moved tail + derived rewrites (renamed)') + out['B_multiset_ok'] = True + out['moved_tail_gates'] = len(moved) + out['deleted_prefix_gates'] = len(deleted) + out['derived_rewrites'] = sorted([[g[1], g[2], str(g[3]), list(g[4])] for g in rewrites]) + out['low_prefix'] = dict( + echoes=sum(x.get('echoes', 0) for x in pinfo.values()), + temporaries=sum(x.get('temporaries', 0) for x in pinfo.values()), + deferred_helper_only_low=sum(x['deferred_helper_only'] for x in pinfo.values() if x['kind'] == 'low'), + deferred_helper_only_high=sum(x['deferred_helper_only'] for x in pinfo.values() if x['kind'] == 'high')) + return out + + +def link_pr2226(P, wit, w2226, wit43): + """The 64 terms are PR2226's 64 T8 terms up to operator ids; low pairs are PR2226's; 43 highs are PR2269's.""" + out = {} + reg_of_op = dict((k, p['register']) for k, p in enumerate(wit['pairs'], 1)) + reg_of_op_2226 = dict((k, p['register']) for k, p in enumerate(w2226['pairs'], 1)) + ours = Counter((t['target'], t['source'], t['coef'], reg_of_op[t['op']]) for t in P['corr']) + theirs = Counter() + for j, t in enumerate(w2226['initial_corrections']): + q = parse_correction(t, j) + theirs[(q['target'], q['source'], q['coef'], reg_of_op_2226[q['op']])] += 1 + need(ours == theirs, 'link2226', '(target, source, coefficient, aliased register) multiset != PR2226 T8 terms') + out['terms_equal_pr2226'] = sum(ours.values()) + lp = lambda pp: set((p['register'], p['borrow_from']) for p in pp if p.get('low')) + need(lp(wit['pairs']) == lp(w2226['pairs']), 'link2226', 'low (register, lender) pairs != PR2226 low pairs') + out['low_pairs_equal_pr2226'] = len(lp(w2226['pairs'])) + hp = lambda pp: set((p['register'], p['borrow_from']) for p in pp if not p.get('low')) + ours_h, w43_h, t_h = hp(wit['pairs']), hp(wit43['pairs']), hp(w2226['pairs']) + need(w43_h <= ours_h, 'link2226', 'a PR2269 high pair is missing or changed') + new = sorted(ours_h - w43_h) + out['high_pairs_from_pr2269'] = len(w43_h) + out['new_high_pairs'] = [list(x) for x in new] + out['new_high_pr2226_lenders'] = sorted([list(x) for x in t_h if x[0] in set(r for r, _ in new)]) + out['high_pairs_equal_pr2226'] = len(ours_h & t_h) + return out + + +def link_566(C, o): + """Canonical word == predecessor 566 word up to a register permutation and a linear frame map.""" + h = C['h'] + pi = {} + pairs = {} + + def lit(F): + return None if F is None else span(F) + + def add_pair(a, b, where): + need((a is None) == (b is None), 'link566', 'frame presence differs at %s' % where) + if a is not None: + need(pairs.setdefault(a, b) == b, 'link566', 'inconsistent frame pair at %s' % where) + + def align(cg, og, where): + need(cg[0] == og[0], 'link566', 'op differs at %s' % where) + oc = conv_gate(og, lit, where) + need(coef(cg) == coef(oc), 'link566', 'coefficient differs at %s' % where) + for x, y in zip(regs_of(cg), regs_of(oc)): + need(pi.setdefault(x, y) == y, 'link566', 'register map conflict at %s' % where) + add_pair(cg[-1], oc[-1], where) + + for name in ('precondition', 'A', 'cut', 'B'): + need(len(C['sections'][name]) == len(o[name]), 'link566', 'length of %s' % name) + for i, (cg, og) in enumerate(zip(C['sections'][name], o[name])): + align(cg, og, '%s[%d]' % (name, i)) + early = o['early_cleanup'] + eidx = [e[0] for e in early] + need(len(set(eidx)) == len(eidx) == len(C['sections']['tail']), 'link566', 'early cleanup count') + rest = [g for i, g in enumerate(o['cleanup']) if i not in set(eidx)] + need(len(rest) == len(C['sections']['cleanup']), 'link566', 'cleanup length') + for i, (cg, og) in enumerate(zip(C['sections']['cleanup'], rest)): + align(cg, og, 'cleanup[%d]' % i) + for i, (cg, (j, F)) in enumerate(zip(C['sections']['tail'], early)): + og = list(o['cleanup'][j][:-1]) + [F] + align(cg, og, 'tail[%d]' % i) + need(len(pi) == C['n'] and len(set(pi.values())) == C['n'], 'link566', 'register map is not a bijection') + v = C['v'] + need(all((x < v) == (y < v) and (x < 2 * v) == (y < 2 * v) for x, y in pi.items()), 'link566', 'roles not preserved') + need(all(x == y for x, y in pi.items() if x >= 2 * v), 'link566', 'helpers renumbered') + ones = [(a[0], b[0]) for a, b in pairs.items() if len(a) == 1 and b is not None and len(b) == 1] + piv = {} + for a, b in ones: + x, y = a, b + for p in list(piv): + pa, pb = piv[p] + if (x >> p) & 1: + x ^= pa + y ^= pb + if x: + lead = x.bit_length() - 1 + for p in list(piv): + pa, pb = piv[p] + if (pa >> lead) & 1: + piv[p] = (pa ^ x, pb ^ y) + piv[lead] = (x, y) + need(len(piv) == h, 'link566', 'one-dimensional frame pairs do not span F_2^h') + tau = [0] * h + for p, (a, b) in piv.items(): + need(a == 1 << p, 'link566', 'tau construction') + tau[p] = b + need(mat_inverse(tau, h) is not None, 'link566', 'tau singular') + tmap = lambda S: span([mat_apply(tau, x) for x in S]) + for a, b in pairs.items(): + need(tmap(a) == b, 'link566', 'frame pair not induced by the linear map tau') + for i in range(v): + need(mat_apply(tau, C['ports'][i]) == o['ports'][pi[i]], 'link566', 'port %d' % i) + need([pi[q] for q in C['centers']] == o['centers'], 'link566', 'centres') + need([tmap(F) for F in C['center_frames']] == [span(F) for F in o['center_frames']], 'link566', 'centre frames') + full = C['full'] + for r in range(2 * v, C['n']): + os_ = span(o['start_extra'][str(r)]) if str(r) in o['start_extra'] else () + oe = span(o['helper_final'][str(r)]) if str(r) in o['helper_final'] else full + need(tmap(C['start'][r]) == os_, 'link566', 'helper start %d' % r) + need(tmap(C['end'][r]) == oe, 'link566', 'helper end %d' % r) + need(dict((int(k), c) for k, c in o['report']['local_profile'].items()) == C['claimed_profile'], 'link566', + 'canonical local_profile != 566 report local_profile') + return dict(register_permutation_nonidentity=sum(1 for x, y in pi.items() if x != y), + aligned_frame_pairs=len(pairs)) + + +# ---------------------------------------------------------------------------- +# Controls +# ---------------------------------------------------------------------------- + +def dsort(c): + return dict((str(k), c[k]) for k in sorted(c)) + + +def expect_reject(name, target, fn, results, also=None): + """Run fn (which must raise Reject from check family `target`).""" + entry = dict(control=name, target_check=target) + try: + fn() + entry.update(rejected=False) + except Reject as e: + entry.update(rejected=True, by=e.check, reason=e.msg[:200]) + entry['ok'] = bool(entry['rejected'] and entry.get('by') == target) + if also is not None: + info = {} + for label, g in also: + try: + g() + info[label] = 'accepted' + except Reject as e: + info[label] = 'rejected[%s]' % e.check + entry['other_checks'] = info + results.append(entry) + print(' control %-66s target=%-12s %s' % (name, target, 'REJECTED-OK' if entry['ok'] else 'NOT-OK ' + str(entry)), + flush=True) + return entry['ok'] + + +def mutate_P(P): + Q = dict(P) + for key in ('pre', 'A', 'cut', 'B_items', 'post', 'cleanup'): + Q[key] = list(P[key]) + Q['warps'] = [dict(w) for w in P['warps']] + Q['corr'] = [dict(t) for t in P['corr']] + return Q + + +def profile_check(P, fr, claim): + need(dict(fr['paid']) == P['claimed_profile'], 'profile', + 'recount %r != word report %r' % (dsort(fr['paid']), P['claimed_profile'])) + need(dict(fr['paid']) == claim, 'profile', 'recount != claimed profile') + + +def controls_low(P, results): + """Controls specific to LOW pairs and anticipatory initial corrections.""" + ok = True + corr = P['corr'] + low_ops = sorted(set(t['op'] for t in corr)) + by_op = dict((w['op'], w) for w in P['warps']) + t0 = corr[0] + # 1. drop one anticipatory term + Q = mutate_P(P) + del Q['corr'][0] + ok &= expect_reject('anticipatory: drop term 0 (%d += %s K_%d %d)' % (t0['target'], t0['coef'], t0['op'], + t0['source']), 'replay', + lambda: replay(Q), results, also=[('frame', lambda: frame_check(Q))]) + # 2. perturb one term (x2), 3. flip its sign + for label, f in (('x2', lambda c: 2 * c), ('sign flip', lambda c: -c)): + Q = mutate_P(P) + Q['corr'][0]['coef'] = f(t0['coef']) + ok &= expect_reject('anticipatory: term 0 coefficient %s' % label, 'replay', lambda: replay(Q), results, + also=[('dual replay', lambda: replay(Q, dual=True))]) + # 4. drop all terms + Q = mutate_P(P) + Q['corr'] = [] + ok &= expect_reject('anticipatory: drop all %d terms' % len(corr), 'replay', lambda: replay(Q), results) + # 5. retarget one term to another target + Q = mutate_P(P) + Q['corr'][0]['target'] = P['v'] + ((t0['target'] - P['v'] + 1) % P['v']) + ok &= expect_reject('anticipatory: term 0 written into target %d' % Q['corr'][0]['target'], 'replay', + lambda: replay(Q), results) + # 6. structurally valid redirection to another low pair (source and operator consistent) + other = next(k for k in low_ops if by_op[k]['lender'] != t0['source']) + Q = mutate_P(P) + Q['corr'][0]['op'], Q['corr'][0]['source'] = other, by_op[other]['lender'] + ok &= expect_reject('anticipatory: term 0 redirected to pair K_%d / lender %d' % (other, by_op[other]['lender']), + 'replay', lambda: replay(Q), results, also=[('structure', lambda: check_corrections(Q))]) + # 7. operator not owned by the source + Q = mutate_P(P) + Q['corr'][0]['op'] = other + ok &= expect_reject('anticipatory: term 0 uses K_%d of another lender' % other, 'anticipatory', + lambda: check_corrections(Q), results) + # 8. a term reading an X register (structurally consistent: X lender with its own warp) + xw = next(w for w in P['warps'] if w['lender'] < P['v']) + Q = mutate_P(P) + Q['corr'][0]['op'], Q['corr'][0]['source'] = xw['op'], xw['lender'] + ok &= expect_reject('anticipatory: term 0 reads X register %d through K_%d' % (xw['lender'], xw['op']), 'frame', + lambda: frame_check(Q), results, also=[('structure', lambda: check_corrections(Q))]) + # 9. drop one low warp entirely (forward in B and inverse in cleanup), corrections kept + k = low_ops[0] + Q = mutate_P(P) + Q['B_items'] = [it for it in P['B_items'] if not (it[0] == 'warp' and it[2] == k)] + Q['cleanup'] = [it for it in P['cleanup'] if not (it[0] == 'warp' and it[2] == -k)] + ok &= expect_reject('low warp %d (lender %d) dropped from B and cleanup' % (k, by_op[k]['lender']), 'replay', + lambda: replay(Q), results, also=[('frame', lambda: frame_check(Q))]) + # 10. drop only the forward low warp + Q = mutate_P(P) + Q['B_items'] = [it for it in P['B_items'] if not (it[0] == 'warp' and it[2] == k)] + ok &= expect_reject('low warp %d dropped from B only' % k, 'replay', lambda: replay(Q), results) + # 11. low lender disturbed before its handoff (lender += X_0 just before the warp): exactness check + L = by_op[k]['lender'] + j = next(i for i, it in enumerate(P['B_items']) if it[0] == 'warp' and it[2] == k) + Q = mutate_P(P) + Q['B_items'].insert(j, ('add', L, 0, ONE, P['full'])) + ok &= expect_reject('low lender %d += X_0 just before its handoff' % L, 'lender', lambda: replay(Q), results) + # 12. low warp treated as an ordinary climb + kc = next(kk for kk in low_ops if by_op[kk]['U'] != by_op[kk]['E']) + ok &= expect_reject('low warp %d as an ordinary climb U->E' % kc, 'frame', + lambda: frame_check(P, warp_as_climb=(kc,)), results) + return ok + + +def controls_generic(P, claim, results): + """Iteration-3 controls, applied to a low warp where a warp is chosen.""" + ok = True + v = P['v'] + warps = P['warps'] + low_ops = set(t['op'] for t in P['corr']) + k0 = next((w['op'] for w in warps if w['U'] != w['E'] and w['op'] in low_ops), + next(w['op'] for w in warps if w['U'] != w['E'])) + Q2 = mutate_P(P) + j = next(i for i, it in enumerate(P['cleanup']) if it[0] == 'warp' and it[2] == -k0) + del Q2['cleanup'][j] + ok &= expect_reject('drop inverse warp %d in cleanup' % k0, 'replay', lambda: replay(Q2), results, + also=[('frame', lambda: frame_check(Q2))]) + lender = next(w['lender'] for w in warps if w['op'] == k0) + wi = next(i for i, it in enumerate(P['B_items']) if it[0] == 'warp' and it[2] == k0) + bi = next(i for i in range(wi + 1, len(P['B_items'])) + if P['B_items'][i][0] == 'add' and lender in regs_of(P['B_items'][i])) + for label, key, idx in (('B item %d (lender %d after its warp)' % (bi, lender), 'B_items', bi), + ('compensation gate 0', 'pre', P['n_pre']), + ('first cleanup add between live registers', 'cleanup', + next(i for i, it in enumerate(P['cleanup']) + if it[0] == 'add' and it[1] not in P['buffers'] and it[2] not in P['buffers']))): + Q3 = mutate_P(P) + g = list(Q3[key][idx]) + g[3] = g[3] * 2 + Q3[key][idx] = tuple(g) + ok &= expect_reject('perturb coefficient x2: %s' % label, 'replay', lambda: replay(Q3), results, + also=[('frame', lambda: frame_check(Q3))]) + + def charged(): + fr = frame_check(P, charge_warps=True) + profile_check(P, fr, claim) + ok &= expect_reject('charge every warp as a climb of rank d(L_U,L_E)', 'profile', charged, results) + pair = None + for a in warps: + for b in warps: + if a['op'] < b['op'] and a['pos'] == b['pos'] and a['U'] != b['U']: + pair = (a['op'], b['op']) + break + if pair: + break + need(pair is not None, 'control', 'no swappable warp pair') + la = next(w['lender'] for w in warps if w['op'] == pair[0]) + lb = next(w['lender'] for w in warps if w['op'] == pair[1]) + Q5 = mutate_P(P) + Q5['B_items'] = [(it[0], lb if it[1] == la else la, it[2], it[3], it[4]) + if it[0] == 'warp' and it[2] in pair else it for it in P['B_items']] + ok &= expect_reject('swap lenders of warps %d,%d' % pair, 'frame', lambda: frame_check(Q5), results, + also=[('replay', lambda: replay(Q5))]) + + def warp_mut(fn): + wr = dict(warps[0]) + fn(wr) + return lambda: check_warp(wr, P['h'], set(P['live']), v) + + def singular(wr): + wr['G'] = list(wr['G']) + wr['G'][1] = wr['G'][0] + ok &= expect_reject('warp 1: singular G', 'warp', warp_mut(singular), results) + + def wrong_image(wr): + h = P['h'] + for jj in range(h): + for i in range(h): + if i == jj: + continue + G = list(wr['G']) + G[jj] ^= G[i] + if mat_inverse(G, h) is not None and span([mat_apply(G, u) for u in wr['U']]) != wr['E']: + wr['G'] = G + return + raise Reject('control', 'no wrong-image G found') + ok &= expect_reject('warp 1: invertible G with G span U != span E', 'warp', warp_mut(wrong_image), results) + + def dim_drop(wr): + wr['E_list'] = wr['E_list'][:-1] + wr['E'] = span(wr['E_list']) + ok &= expect_reject('warp 1: dim E != dim U', 'warp', warp_mut(dim_drop), results) + Q7 = mutate_P(P) + j = next(i for i, it in enumerate(P['cleanup']) if it[0] == 'add' and (it[1] in P['buffers'] or it[2] in P['buffers'])) + it = list(P['cleanup'][j]) + if it[1] in P['buffers']: + it[1] -= P['n'] + else: + it[2] -= P['n'] + Q7['cleanup'][j] = tuple(it) + ok &= expect_reject('cleanup item %d uses the restored register, not its buffer' % j, 'frame', + lambda: frame_check(Q7), results) + Q8 = mutate_P(P) + del Q8['post'][0] + ok &= expect_reject('delete restore gate 0', 'replay', lambda: replay(Q8), results) + Q9 = mutate_P(P) + del Q9['pre'][P['n_pre']] + ok &= expect_reject('delete compensation gate 0', 'replay', lambda: replay(Q9), results) + Q10 = mutate_P(P) + written, keep = set(), [] + for it in P['cleanup']: + if it[0] == 'add' and it[2] in P['buffers'] and it[2] not in written: + continue + if it[0] == 'add' and it[1] in P['buffers']: + written.add(it[1]) + keep.append(it) + Q10['cleanup'] = keep + ok &= expect_reject('drop %d forward-no-op cleanup adds (dual replay)' % (len(P['cleanup']) - len(keep)), 'replay', + lambda: replay(Q10, dual=True), results, also=[('forward replay', lambda: replay(Q10))]) + ok &= results[-1]['other_checks']['forward replay'] == 'accepted' + # positive mutation: re-express U and E of every warp in another basis of the same span + Qp = mutate_P(P) + rebased = [] + for wr in warps: + w2 = dict(wr) + if len(w2['U_list']) > 1: + w2['U_list'] = [w2['U_list'][0] ^ w2['U_list'][1]] + w2['U_list'][1:] + w2['E_list'] = w2['E_list'][1:] + [w2['E_list'][0] ^ w2['E_list'][-1]] + w2['U'], w2['E'] = span(w2['U_list']), span(w2['E_list']) + rebased.append(w2) + entry = dict(control='positive: rebased warp U/E lists (same spans) accepted', target_check='warp+frame') + try: + for w2 in rebased: + check_warp(w2, P['h'], set(P['live']), v) + Qp['warps'] = rebased + profile_check(Qp, frame_check(Qp), claim) + entry.update(accepted=True, ok=True) + except Reject as e: + entry.update(accepted=False, ok=False, reason=str(e)) + print(' control %-66s %s' % (entry['control'], 'ACCEPTED-OK' if entry['ok'] else 'NOT-OK'), flush=True) + results.append(entry) + ok &= entry['ok'] + return ok + + +# ---------------------------------------------------------------------------- +# Driver +# ---------------------------------------------------------------------------- + +def check_word(label, w, claim, common, results_controls=None): + """Warps, structure, frames/profile recount and both replays of one BORROW-WORD.""" + P = parse_borrow(w) + res = dict(base_tag=w.get('base')) + need(w.get('base') == claim['base_tag'], 'link', 'base tag') + wres = check_all_warps(P) + need(len(wres) == common['warps'], 'warp', 'warp count %d' % len(wres)) + need(len(P['corr']) == common['corrections'], 'anticipatory', 'correction count %d' % len(P['corr'])) + low_ops = set(t['op'] for t in P['corr']) + need(len(low_ops) == common['low'], 'anticipatory', 'low operator count %d' % len(low_ops)) + res['warps'] = dict(count=len(wres), dims=dsort(Counter(x['dim'] for x in wres)), + low_ops=sorted(low_ops), lenders=[x['lender'] for x in wres], + lenders_that_are_X=[x['lender'] for x in wres if x['lender'] < P['v']], + U_equal_E=sum(1 for x in wres if x['U_eq_E']), + plain_fourier_distance=dsort(Counter(x['plain_fourier_distance'] for x in wres)), + anticipatory_terms=len(P['corr']), anticipatory_structure=check_corrections(P)) + fr = frame_check(P) + profile_check(P, fr, claim['profile']) + need(dict(fr['inventory']) == common['width_inventory'] == P['claimed_inventory'], 'profile', 'width inventory') + need(fr['helpers'] == common['helpers'] == P['R'] - len(P['removed']), 'profile', 'helper count') + need(fr['mass'] == common['mass'], 'profile', 'local mass %d' % fr['mass']) + need(fr['mass'] == 1856 + fr['helper_width_sum'], 'profile', 'mass != 1856 + helper widths') + frc = frame_check(P, charge_warps=True) + res['frames'] = dict(paid_profile=dsort(fr['paid']), climbs=dsort(fr['climbs']), copy_charges=dsort(fr['copies']), + local_mass=fr['mass'], width_inventory=dsort(fr['inventory']), helpers=fr['helpers'], + helper_width_sum=fr['helper_width_sum'], + if_warps_charged_profile=dsort(frc['paid']), if_warps_charged_mass=frc['mass']) + print(' [%s] warps %d PASS (dims %s, %d low, %d corrections); frames PASS: paid %s mass %d helpers %d ' + 'inventory %s' % (label, len(wres), res['warps']['dims'], len(low_ops), len(P['corr']), + res['frames']['paid_profile'], fr['mass'], fr['helpers'], res['frames']['width_inventory']), + flush=True) + t0 = time.time() + rf = replay(P) + rd = replay(P, dual=True) + need(rf['independent_inputs'] == common['inputs'] and rf['buffers'] == common['buffers'], 'replay', + 'input/buffer count %d/%d' % (rf['independent_inputs'], rf['buffers'])) + res['replay'] = dict(forward=rf, dual=rd) + print(' [%s] replay forward+dual PASS over %d inputs, %d buffers, %d low lenders exact at handoff (%.1f s)' % ( + label, rf['independent_inputs'], rf['buffers'], rf.get('low_lenders_exact_at_handoff', 0), time.time() - t0), + flush=True) + return P, fr, res + + +def main(): + ap = argparse.ArgumentParser(description='Independent check of BORROW-WORD-80{base,extra} (low aliases)') + ap.add_argument('--repo', default=DEFAULT_REPO, help='git checkout containing the PR2269 and PR2226 heads') + ap.add_argument('--out', action='store_true', help='write %s next to this script' % RECEIPT) + ap.add_argument('--skip-controls', action='store_true', help='skip negative controls (not a PASS run)') + ap.add_argument('--skip-predecessor', action='store_true', help='skip the PR2269 43-word positive control') + args = ap.parse_args() + t0 = time.time() + receipt = dict(checker='check_ext.py', python=sys.version.split()[0], + scope='BORROW-WORD-80{base,extra} + witness_80_*: warps, anticipatory structure, frames, ' + 'profiles, exact replay; links to PR2269 canonical/blocks/43-word and PR2226 terms', + adapted_from='fork commit 4a2f20ea339e30348448096ca789d0efe55df9bb ' + 'research/t74-borrow43-independent-check/words_check.py (own code)') + ok = True + try: + js, pins, raw = load_inputs(args.repo) + receipt['pins'] = pins + print('pins: %d inputs verified (sha256 + git blob id)' % len(pins), flush=True) + words = {} + for tag in ('base', 'extra'): + print('== word 80%s' % tag, flush=True) + w = js['word80_' + tag] + claim = CLAIMS['ext80'][tag] + P, fr, res = check_word('80' + tag, w, claim, CLAIMS['ext80']) + C = parse_canonical(js['canon_' + tag]) + res['links'] = link_checks(tag, P, C, js['witness80_' + tag], js['blocks'], w) + L = res['links'] + need(L['removed_low'] == CLAIMS['ext80']['low'] and L['removed_high'] == CLAIMS['ext80']['high'], 'link', + 'low/high split %d/%d' % (L['removed_low'], L['removed_high'])) + need(len(L['derived_rewrites']) == CLAIMS['ext80']['rewrites'], 'link', 'rewrite count') + print(' links PASS: %d high + %d low removed; B = canonical B - %d deleted prefix + %d moved tail + %d ' + 'derived rewrites (renamed); low lenders entrance dims %s, canonical final dims %s' % ( + L['removed_high'], L['removed_low'], L['deleted_prefix_gates'], L['moved_tail_gates'], + len(L['derived_rewrites']), L['low_lenders_entrance_frame_dims'], + L['low_lenders_canonical_final_dims']), flush=True) + res['pr2226'] = link_pr2226(P, js['witness80_' + tag], js['pr2226_witness'], js['witness43_' + tag]) + need(sorted(l for _, l in res['pr2226']['new_high_pairs']) == CLAIMS['ext80']['new_high_X_lenders'], + 'link2226', 'new high lenders') + print(' PR2226 link PASS: 64 terms = PR2226 T8 terms (target, source, coefficient, aliased register); ' + '%d low pairs = PR2226; %d PR2269 high pairs kept; new high pairs %s (PR2226 lenders %s)' % ( + res['pr2226']['low_pairs_equal_pr2226'], res['pr2226']['high_pairs_from_pr2269'], + res['pr2226']['new_high_pairs'], res['pr2226']['new_high_pr2226_lenders']), flush=True) + # canonical positive control + 566 link + mass bookkeeping + frC = frame_check(C) + need(dict(frC['paid']) == C['claimed_profile'] == CLAIMS['canonical'][tag], 'canonical', + 'canonical profile not reproduced: %r' % dsort(frC['paid'])) + rC = replay(C) + l566 = link_566(C, js['word566_' + tag]) + res['canonical'] = dict(paid_profile=dsort(frC['paid']), local_mass=frC['mass'], helpers=frC['helpers'], + replay=rC, link_566=l566) + need(frC['mass'] - fr['mass'] == L['mass_identity']['predicted_saving'] and frC['copies'] == fr['copies'], + 'profile', 'saving does not match the width bookkeeping') + res['saving_vs_canonical'] = frC['mass'] - fr['mass'] + print(' canonical positive control: profile %s mass %d, replay PASS, 566-link PASS; saving %d = removed ' + 'widths %d - widths added %d' % (res['canonical']['paid_profile'], frC['mass'], + res['saving_vs_canonical'], L['mass_identity']['removed_widths'], + L['mass_identity']['width_added_to_cold_now_FULL']), flush=True) + if not args.skip_predecessor: + print(' -- positive control: PR2269 BORROW-WORD-43%s through the same checker' % tag, flush=True) + P43, fr43, r43 = check_word('43' + tag, js['word43_' + tag], CLAIMS['b43'][tag], CLAIMS['b43']) + l43 = link_checks(tag, P43, C, js['witness43_' + tag], js['blocks'], js['word43_' + tag]) + need(l43['removed_low'] == 0 and l43['removed_high'] == 43, 'link', '43-word split') + res['predecessor_43'] = dict(paid_profile=r43['frames']['paid_profile'], + local_mass=r43['frames']['local_mass'], replay=r43['replay'], + links=dict((k, l43[k]) for k in ('removed_high', 'removed_low', + 'deleted_prefix_gates', 'moved_tail_gates'))) + res['delta_vs_pr2269'] = dict((str(r), fr['paid'].get(r, 0) - fr43['paid'].get(r, 0)) + for r in sorted(set(fr['paid']) | set(fr43['paid']))) + res['mass_delta_vs_pr2269'] = fr['mass'] - fr43['mass'] + print(' delta vs PR2269 43-word: %s, mass %+d' % (res['delta_vs_pr2269'], res['mass_delta_vs_pr2269']), + flush=True) + if not args.skip_controls: + results = [] + print(' -- negative controls (low pairs / anticipatory terms)', flush=True) + cok = controls_low(P, results) + print(' -- negative controls (iteration-3 set, on a low warp)', flush=True) + cok &= controls_generic(P, claim['profile'], results) + bad = bytearray(raw['word80_' + tag]) + bad[len(bad) // 2] ^= 1 + rel, blob, sha = LOCAL_PINS['word80_' + tag] + cok &= expect_reject('pin: one flipped bit in the word file', 'pin', + lambda: verify_bytes(rel, bytes(bad), blob, sha), results) + wbad = copy.deepcopy(js['witness80_' + tag]) + pr0 = next(p for p in wbad['pairs'] if p['low'] and p['deleted_prefix_indices']) + pr0['deleted_prefix_indices'] = pr0['deleted_prefix_indices'][:-1] + cok &= expect_reject('witness: one deleted prefix gate of helper %d kept' % pr0['register'], 'prefix', + lambda: link_checks(tag, P, C, wbad, js['blocks'], w), results) + res['controls'] = results + res['controls_ok'] = bool(cok) + print(' controls: %d/%d as required' % (sum(1 for e in results if e['ok']), len(results)), flush=True) + ok &= bool(cok) + words[tag] = res + receipt['words'] = words + receipt['recounted'] = dict( + (('gauge44' if tag == 'base' else 'extra'), + dict(profile=words[tag]['frames']['paid_profile'], helpers=words[tag]['frames']['helpers'], + helper_width_sum=words[tag]['frames']['helper_width_sum'], + local_mass=words[tag]['frames']['local_mass'])) for tag in ('base', 'extra')) + fb = words['base'] + receipt['findings'] = [ + 'Both 80-alias words: 80 warps pass the GF(2) checks (rank-zero K_G handoffs); 64 anticipatory terms ' + 'c K_k z_L read 32 frame-zero low lenders before the preconditioner, each with the warp of its own pair.', + 'Paid profiles recounted from the words alone: base %s, extra %s; mass %d each = 1856 + helper widths %d; ' + '%d helpers; inventory %s.' % (words['base']['frames']['paid_profile'], + words['extra']['frames']['paid_profile'], fb['frames']['local_mass'], + fb['frames']['helper_width_sum'], fb['frames']['helpers'], + fb['frames']['width_inventory']), + 'Exact replay over Q in both orientations on %d independent dirty inputs: Y += X, every other live ' + 'register restored, %d buffers zero; each of the 32 low lenders is exactly its own input at its handoff.' % ( + fb['replay']['forward']['independent_inputs'], fb['replay']['forward']['buffers']), + 'B equals canonical B minus %d pre-handoff low-helper gates (echoes/net-zero temporaries), plus 48 moved ' + 'tail gates and %d direct-read rewrites derived here independently, with helpers renamed to lenders.' % ( + fb['links']['deleted_prefix_gates'], len(fb['links']['derived_rewrites'])), + ] + receipt['not_checked'] = [ + 'Exact Clifford (Gaussian, phase) lifts of K_G and their native lowering in either orientation.', + 'Hosting of the 64 frame-zero correction reads and of the X-register lenders (1,4,6,12,31,73) in a whole-call ' + 'owner map; private cleanup buffers; owner fill at 400 helpers; global profile; kappa.', + ] + except Reject as e: + ok = False + receipt['failure'] = str(e) + print('FAILED: %s' % e, flush=True) + receipt['skip_controls'] = bool(args.skip_controls) + receipt['result'] = PASS_LINE if (ok and not args.skip_controls) else FAIL_LINE + receipt['model'] = __doc__.split('MODEL (stated precisely; see also the receipt field "model").')[1].strip() + receipt['elapsed_s'] = round(time.time() - t0, 1) + print('elapsed %.1f s' % (time.time() - t0)) + if args.out: + with open(os.path.join(HERE, RECEIPT), 'w') as fh: + json.dump(receipt, fh, indent=1, sort_keys=True, default=str) + fh.write('\n') + print('receipt written: %s' % os.path.join(HERE, RECEIPT)) + print(receipt['result']) + return 0 if receipt['result'] == PASS_LINE else 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/research/t74-low-alias-borrowing/check_ext.receipt.json b/research/t74-low-alias-borrowing/check_ext.receipt.json new file mode 100644 index 0000000000..350d078d66 --- /dev/null +++ b/research/t74-low-alias-borrowing/check_ext.receipt.json @@ -0,0 +1,1736 @@ +{ + "adapted_from": "fork commit 4a2f20ea339e30348448096ca789d0efe55df9bb research/t74-borrow43-independent-check/words_check.py (own code)", + "checker": "check_ext.py", + "elapsed_s": 15.7, + "findings": [ + "Both 80-alias words: 80 warps pass the GF(2) checks (rank-zero K_G handoffs); 64 anticipatory terms c K_k z_L read 32 frame-zero low lenders before the preconditioner, each with the warp of its own pair.", + "Paid profiles recounted from the words alone: base {'1': 2303, '2': 527, '3': 386, '4': 125, '5': 37, '8': 8}, extra {'1': 2287, '2': 535, '3': 386, '4': 125, '5': 37, '8': 8}; mass 5264 each = 1856 + helper widths 3408; 400 helpers; inventory {'4': 4, '5': 4, '7': 36, '8': 84, '9': 272}.", + "Exact replay over Q in both orientations on 624 independent dirty inputs: Y += X, every other live register restored, 44 buffers zero; each of the 32 low lenders is exactly its own input at its handoff.", + "B equals canonical B minus 136 pre-handoff low-helper gates (echoes/net-zero temporaries), plus 48 moved tail gates and 5 direct-read rewrites derived here independently, with helpers renamed to lenders." + ], + "model": "* Registers 0..v-1 are X (sources), v..2v-1 are Y (targets), 2v..2v+R-1 helpers; n = 2v+R. Removed helpers\n do not exist. A buffer register b = r+n exists only for r in helper_final (restored cold helpers) and only\n in cleanup.\n * Frame = GF(2)-subspace of F_2^h (h = 9), compared as spans. Start: X_i = span(port_i), Y = 0, helper =\n start_extra[r] or 0. End: X = FULL, Y_i = port_i^perp, helper = helper_final[r] or FULL.\n * Initial (anticipatory) corrections {target t, source s, operator_word [k], coefficient c} run FIRST, before\n the preconditioner (PR2226 PROOF section 3): t += c K_k s. Structure: t is a Y register, s a live\n non-target register, c a non-zero dyadic rational, k an existing forward warp whose lender is s (each term is\n c K_G z for the pair lent by s), operator words have length one. Frames: t and s must both be at frame 0\n when the term runs (s's entrance frame is 0); K_k fixes L_0 (checked for every warp), so applying K_k to s,\n reading it into t and inverting it is rank zero and pays nothing.\n * Every framed gate (add t s c F | scale t c F) climbs each incident register from its current frame S to F;\n legal only if S <= F; a strict climb pays one child of rank dim F - dim S. precondition/compensation are at\n frame 0 and write targets only.\n * After A every target sits at its level and every centre at its centre frame; cut gates add c*centre into a\n target at its level; each centre pays one COPY child of rank dim(centre frame) - dim(level) per distinct\n served level (nested chain).\n * warp [pos, L, G, U, E] is inserted before B[pos] (list order inside a position): requires cur[L] == span U,\n sets cur[L] = span E, pays nothing (rank-zero reference change K_G); logically L <- K_G L.\n * After B and restore every live register climbs to its end frame (paid). cleanup items must all be at FULL,\n may touch only live registers at FULL or buffers; they pay nothing.\n * Logic: exact replay over Q (rationals x free group on K_1..K_80). Every live register starts as an\n independent symbol (arbitrary dirty content); buffers start at 0. add t += c s, scale t *= c, warp\n left-multiplies by K_k^{+-1} with free-group cancellation, a correction adds c K_k (row of s) to t. LOW-lender\n exactness (PR2226 PROOF section 3): immediately before every warp whose operator occurs in a correction, the\n lender's row must be exactly its own input symbol. Accept iff after cleanup Y_i = Y_i + X_i, every other\n live register is its own input and every buffer is 0. The dual orientation replays g^{-T} for every item\n (add -> s -= c t, scale -> 1/c, K -> K^{-T} as new free letters, correction -> s -= c K_k^T t with\n K_k^T = (K_k^{-T})^{-1}) and expects X_i = X_i - Y_i.\n * Warp algebra over GF(2): G invertible, dim U = dim E, G span U = span E, M = [[G,0],[G+G^-T,G^-T]]\n symplectic, M L_0 = L_0, M L_FULL = L_FULL, M L_U = L_E (Fourier rank 0), G^-T U^perp = E^perp. Exact\n Clifford phases / Gaussian lifts are NOT checked here.\n * Links (witness/canonical/block certificate): the B section is the canonical B plus the 48 moved tail gates,\n each removed helper renamed to its lender, minus the low helpers' pre-handoff echo/temporary gates, plus\n the direct-read rewrites that this checker DERIVES from those deleted gates (temporaries must be net zero;\n an echo t += c h reading a temporary part a*ext becomes t += c*a ext at the echo's frame). Every other\n pre-handoff event of an aliased helper must be a helper-only correction inside its block.", + "not_checked": [ + "Exact Clifford (Gaussian, phase) lifts of K_G and their native lowering in either orientation.", + "Hosting of the 64 frame-zero correction reads and of the X-register lenders (1,4,6,12,31,73) in a whole-call owner map; private cleanup buffers; owner fill at 400 helpers; global profile; kappa." + ], + "pins": { + "blocks": { + "bytes": 50270, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "c683574b3861678081fd5c5944dbd7a47309f6fd", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/blocks.json", + "sha256": "ddfac1dae1fe7cc0a91e7c7205c6d9d0c07c682880aa34eed83bf4ad7384da9f" + }, + "canon_base": { + "bytes": 87678, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "4abb6e28f02c95b41ed345d4e4401d16d58ae791", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/gauge44.canonical.json.gz", + "sha256": "65c6d17ffee2eacf27bff438f37fc549c9ed0c909cbc7a52976cc75cf2d15b91" + }, + "canon_extra": { + "bytes": 87680, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "e0d670d4351229ce6921ecfbecf180070b17616b", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/extra.canonical.json.gz", + "sha256": "d7e48dcbafa236a2e1e41f7958244211506f7c7630fe6a2d43d2bdf17b7ae015" + }, + "pr2226_witness": { + "bytes": 69305, + "commit": "dacaf3d81f1936bb55b8454b1244e5d014272754", + "git_blob": "62edbcce166f7cf388231078c2cd7f75939b97e2", + "path": "research/anticipatory-dirty-borrowing/WITNESS.json", + "sha256": "86392adde6992a08ae90f7a69c58cace1b52d942f4d2c96e82ca79e5d1e15235" + }, + "witness43_base": { + "bytes": 45301, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "9f4b93f3bc52d4f4ffaa128cfd7ae574fd36c462", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/witness_43_base.json", + "sha256": "67ffb66d94067f6e53aee9118fe90e14a57f497fc8b3f708b6dac3de2e58ff28" + }, + "witness43_extra": { + "bytes": 45306, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "864ba533f50c2f1f639a6a3559b185bd321b923a", + "path": "research/gmx-t74-borrow43/new/borrow/inputs/witness_43_extra.json", + "sha256": "d46449c6dbf4477f260cf5baea9bbb570a66ee0b6db81f4a220b9e3086ae9e46" + }, + "witness80_base": { + "bytes": 114840, + "git_blob": "cdcd39ff1beb577b975e48633d05ee629caa1362", + "local": "witness/witness_80_base.json", + "sha256": "9380f74c032b0616d5b13e8ef94b6d9f80cac36239e329357e7d5fcab5283ad0" + }, + "witness80_extra": { + "bytes": 114837, + "git_blob": "6b87d35600c44d053bf5ce03e34fc315d5a2af4a", + "local": "witness/witness_80_extra.json", + "sha256": "6737072dcca47c6e6526bd62a41585dd09026549550c9e62eb53e64b265a6709" + }, + "word43_base": { + "bytes": 69989, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "448dd795adba29392a90b34aa3f1b1b796c7e0bd", + "path": "research/gmx-t74-borrow43/new/borrow/words/BORROW-WORD-43base.json.gz", + "sha256": "9492a5537fb87d9ca98dffcd0230f7625b3789744fa94e2f18acf23d91d998b5" + }, + "word43_extra": { + "bytes": 69991, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "2b51ba96256283bbc5578f99b694c50edd8a0e35", + "path": "research/gmx-t74-borrow43/new/borrow/words/BORROW-WORD-43extra.json.gz", + "sha256": "87d51f5298101d5947f45c43ee02f0ec45d6acbddabb808d0d02db1eaf063734" + }, + "word566_base": { + "bytes": 57438, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "76c01583a0286cddb0f71e0cb13077e4317104f6", + "path": "research/gmx-t74-borrow43/new/gauge44-word-566.json.gz", + "sha256": "eeb6a236ed0ea8873b8800947d0cd19c36a6fcfdf857fc42913cb45cd984f219" + }, + "word566_extra": { + "bytes": 57440, + "commit": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "git_blob": "e86142b352466f54a3da38c96a6e1484145c3b5c", + "path": "research/gmx-t74-borrow43/new/extra-word-566.json.gz", + "sha256": "cd417b904408c221d9840d08faff8af040cc4207f9804284f2f5375d21298a62" + }, + "word80_base": { + "bytes": 70131, + "git_blob": "c5953dfdb0ee9ac0c2c73eb29e320582b4569d2b", + "local": "words/BORROW-WORD-80base.json.gz", + "sha256": "61290abffd8c8225e0abb3958c1506674e256de688fc4cdf358bbe7c981df493" + }, + "word80_extra": { + "bytes": 70135, + "git_blob": "852868543ed36efa799b3ed6dd76a0442b0d6ff1", + "local": "words/BORROW-WORD-80extra.json.gz", + "sha256": "1dd2d6f2ae5b5a27b5f89fb830203f0cca7a78d0323a7845e85e1e80f8f6d1a5" + } + }, + "python": "3.14.4", + "recounted": { + "extra": { + "helper_width_sum": 3408, + "helpers": 400, + "local_mass": 5264, + "profile": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + } + }, + "gauge44": { + "helper_width_sum": 3408, + "helpers": 400, + "local_mass": 5264, + "profile": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + } + } + }, + "result": "PASS_T74_LOW_ALIAS_WORDS_INDEPENDENT", + "scope": "BORROW-WORD-80{base,extra} + witness_80_*: warps, anticipatory structure, frames, profiles, exact replay; links to PR2269 canonical/blocks/43-word and PR2226 terms", + "skip_controls": false, + "words": { + "base": { + "base_tag": "eeb6a236", + "canonical": { + "helpers": 480, + "link_566": { + "aligned_frame_pairs": 1008, + "register_permutation_nonidentity": 220 + }, + "local_mass": 5590, + "paid_profile": { + "1": 2348, + "2": 500, + "3": 416, + "4": 130, + "5": 82, + "8": 8 + }, + "replay": { + "buffer_nonzero_window": [ + null, + null + ], + "buffers": 0, + "buffers_ever_nonzero": 0, + "cleanup_adds_reading_a_zero_buffer": 0, + "corrections": 0, + "independent_inputs": 704, + "low_lenders_exact_at_handoff": 0, + "max_overlap_of_buffer_lifetimes": 0, + "peak_nonzero_buffers": 0, + "rows_with_operator_words_before_cleanup": 0 + } + }, + "controls": [ + { + "by": "replay", + "control": "anticipatory: drop term 0 (114 += 1/2 K_62 339)", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: term 0 coefficient x2", + "ok": true, + "other_checks": { + "dual replay": "rejected[replay]" + }, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: term 0 coefficient sign flip", + "ok": true, + "other_checks": { + "dual replay": "rejected[replay]" + }, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: drop all 64 terms", + "ok": true, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: term 0 written into target 115", + "ok": true, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: term 0 redirected to pair K_44 / lender 277", + "ok": true, + "other_checks": { + "structure": "accepted" + }, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "anticipatory", + "control": "anticipatory: term 0 uses K_44 of another lender", + "ok": true, + "reason": "correction 0: operator 44 is not the reference change of the pair lent by source 339", + "rejected": true, + "target_check": "anticipatory" + }, + { + "by": "frame", + "control": "anticipatory: term 0 reads X register 73 through K_30", + "ok": true, + "other_checks": { + "structure": "accepted" + }, + "reason": "initial correction 0: source 73 is not at frame 0 (frame (224,))", + "rejected": true, + "target_check": "frame" + }, + { + "by": "replay", + "control": "low warp 44 (lender 277) dropped from B and cleanup", + "ok": true, + "other_checks": { + "frame": "rejected[frame]" + }, + "reason": "target 43 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "low warp 44 dropped from B only", + "ok": true, + "reason": "target 43 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "lender", + "control": "low lender 277 += X_0 just before its handoff", + "ok": true, + "reason": "low lender 277 is not exactly its own input at the handoff of warp 44", + "rejected": true, + "target_check": "lender" + }, + { + "by": "frame", + "control": "low warp 44 as an ordinary climb U->E", + "ok": true, + "reason": "non-nested climb of 277 at warp 44 treated as an ordinary climb: (388, 75, 41, 26) -> (258, 130, 85, 45)", + "rejected": true, + "target_check": "frame" + }, + { + "by": "replay", + "control": "drop inverse warp 44 in cleanup", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "final map wrong on register 277 (forward)", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "perturb coefficient x2: B item 1123 (lender 277 after its warp)", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "target 43 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "perturb coefficient x2: compensation gate 0", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "target 1 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "perturb coefficient x2: first cleanup add between live registers", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "a zero buffer is not returned to zero", + "rejected": true, + "target_check": "replay" + }, + { + "by": "profile", + "control": "charge every warp as a climb of rank d(L_U,L_E)", + "ok": true, + "reason": "recount {'1': 2303, '2': 528, '3': 386, '4': 181, '5': 37, '6': 23, '8': 8} != word report {1: 2303, 2: 527, 3: 386, 4: 125, 5: 37, 8: 8}", + "rejected": true, + "target_check": "profile" + }, + { + "by": "frame", + "control": "swap lenders of warps 1,14", + "ok": true, + "other_checks": { + "replay": "rejected[replay]" + }, + "reason": "warp 1: lender 349 frame (416, 70, 19, 13) != U (261, 133, 85, 45)", + "rejected": true, + "target_check": "frame" + }, + { + "by": "warp", + "control": "warp 1: singular G", + "ok": true, + "reason": "warp 1: G is singular over GF(2)", + "rejected": true, + "target_check": "warp" + }, + { + "by": "warp", + "control": "warp 1: invertible G with G span U != span E", + "ok": true, + "reason": "warp 1: G span U != span E", + "rejected": true, + "target_check": "warp" + }, + { + "by": "warp", + "control": "warp 1: dim E != dim U", + "ok": true, + "reason": "warp 1: dim U != dim E", + "rejected": true, + "target_check": "warp" + }, + { + "by": "frame", + "control": "cleanup item 0 uses the restored register, not its buffer", + "ok": true, + "reason": "cleanup item 0 touches register 591 whose frame is not FULL", + "rejected": true, + "target_check": "frame" + }, + { + "by": "replay", + "control": "delete restore gate 0", + "ok": true, + "reason": "restored cold register 572 is not its own input", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "delete compensation gate 0", + "ok": true, + "reason": "target 1 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "drop 18 forward-no-op cleanup adds (dual replay)", + "ok": true, + "other_checks": { + "forward replay": "accepted" + }, + "reason": "a zero buffer is not returned to zero", + "rejected": true, + "target_check": "replay" + }, + { + "accepted": true, + "control": "positive: rebased warp U/E lists (same spans) accepted", + "ok": true, + "target_check": "warp+frame" + }, + { + "by": "pin", + "control": "pin: one flipped bit in the word file", + "ok": true, + "reason": "git blob id mismatch for words/BORROW-WORD-80base.json.gz", + "rejected": true, + "target_check": "pin" + }, + { + "by": "prefix", + "control": "witness: one deleted prefix gate of helper 689 kept", + "ok": true, + "reason": "low helper 689: witness deleted prefix [269, 270, 271] != derived [269, 270, 271, 272]", + "rejected": true, + "target_check": "prefix" + } + ], + "controls_ok": true, + "delta_vs_pr2269": { + "1": -48, + "2": 26, + "3": -28, + "4": -4, + "5": -5, + "8": 0 + }, + "frames": { + "climbs": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 37 + }, + "copy_charges": { + "8": 8 + }, + "helper_width_sum": 3408, + "helpers": 400, + "if_warps_charged_mass": 5628, + "if_warps_charged_profile": { + "1": 2303, + "2": 528, + "3": 386, + "4": 181, + "5": 37, + "6": 23, + "8": 8 + }, + "local_mass": 5264, + "paid_profile": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "width_inventory": { + "4": 4, + "5": 4, + "7": 36, + "8": 84, + "9": 272 + } + }, + "links": { + "B_multiset_ok": true, + "canonical_A_gates_dropped": 0, + "canonical_cold_helpers": 78, + "canonical_cold_helpers_ending_FULL_after_borrowing": [ + 273, + 275, + 277, + 282, + 289, + 291, + 293, + 298, + 305, + 307, + 309, + 314, + 321, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394, + 533, + 554 + ], + "canonical_compensation_gates_dropped": 0, + "canonical_cut_gates_dropped": 0, + "canonical_precondition_gates_dropped": 0, + "deleted_prefix_gates": 136, + "derived_rewrites": [ + [ + 117, + 566, + "1", + [ + 51 + ] + ], + [ + 151, + 567, + "1", + [ + 51 + ] + ], + [ + 181, + 566, + "-1", + [ + 51 + ] + ], + [ + 181, + 566, + "1", + [ + 51 + ] + ], + [ + 214, + 566, + "-1", + [ + 51 + ] + ] + ], + "low_lenders": [ + 273, + 275, + 277, + 282, + 289, + 291, + 293, + 298, + 305, + 307, + 309, + 314, + 321, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394 + ], + "low_lenders_canonical_final_dims": { + "4": 32 + }, + "low_lenders_entrance_frame_dims": [ + 0 + ], + "low_ops": [ + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75 + ], + "low_prefix": { + "deferred_helper_only_high": 144, + "deferred_helper_only_low": 96, + "echoes": 128, + "temporaries": 8 + }, + "mass_identity": { + "predicted_saving": 326, + "removed_widths": 488, + "width_added_to_cold_now_FULL": 162 + }, + "moved_tail_gates": 48, + "removed_high": 48, + "removed_low": 32, + "removed_old_widths": { + "4": 8, + "5": 40, + "8": 32 + } + }, + "mass_delta_vs_pr2269": -121, + "pr2226": { + "high_pairs_equal_pr2226": 43, + "high_pairs_from_pr2269": 43, + "low_pairs_equal_pr2226": 32, + "new_high_pairs": [ + [ + 606, + 12 + ], + [ + 635, + 6 + ], + [ + 637, + 31 + ], + [ + 638, + 4 + ], + [ + 639, + 1 + ] + ], + "new_high_pr2226_lenders": [ + [ + 606, + 395 + ], + [ + 635, + 363 + ], + [ + 637, + 530 + ], + [ + 638, + 331 + ], + [ + 639, + 299 + ] + ], + "terms_equal_pr2226": 64 + }, + "predecessor_43": { + "links": { + "deleted_prefix_gates": 0, + "moved_tail_gates": 48, + "removed_high": 43, + "removed_low": 0 + }, + "local_mass": 5385, + "paid_profile": { + "1": 2351, + "2": 501, + "3": 414, + "4": 129, + "5": 42, + "8": 8 + }, + "replay": { + "dual": { + "buffer_nonzero_window": [ + 0, + 4498 + ], + "buffers": 76, + "buffers_ever_nonzero": 58, + "cleanup_adds_reading_a_zero_buffer": 355, + "corrections": 0, + "independent_inputs": 661, + "max_overlap_of_buffer_lifetimes": 48, + "peak_nonzero_buffers": 48 + }, + "forward": { + "buffer_nonzero_window": [ + 1, + 4470 + ], + "buffers": 76, + "buffers_ever_nonzero": 76, + "cleanup_adds_reading_a_zero_buffer": 110, + "corrections": 0, + "independent_inputs": 661, + "low_lenders_exact_at_handoff": 0, + "max_overlap_of_buffer_lifetimes": 44, + "peak_nonzero_buffers": 44, + "rows_with_operator_words_before_cleanup": 88 + } + } + }, + "replay": { + "dual": { + "buffer_nonzero_window": [ + 0, + 4527 + ], + "buffers": 44, + "buffers_ever_nonzero": 26, + "cleanup_adds_reading_a_zero_buffer": 84, + "corrections": 64, + "independent_inputs": 624, + "max_overlap_of_buffer_lifetimes": 22, + "peak_nonzero_buffers": 22 + }, + "forward": { + "buffer_nonzero_window": [ + 1, + 4499 + ], + "buffers": 44, + "buffers_ever_nonzero": 44, + "cleanup_adds_reading_a_zero_buffer": 87, + "corrections": 64, + "independent_inputs": 624, + "low_lenders_exact_at_handoff": 32, + "max_overlap_of_buffer_lifetimes": 44, + "peak_nonzero_buffers": 44, + "rows_with_operator_words_before_cleanup": 96 + } + }, + "saving_vs_canonical": 326, + "warps": { + "U_equal_E": 0, + "anticipatory_structure": { + "operators": 32, + "sources": 32, + "terms": 64 + }, + "anticipatory_terms": 64, + "count": 80, + "dims": { + "4": 77, + "5": 3 + }, + "lenders": [ + 243, + 250, + 266, + 259, + 333, + 317, + 554, + 285, + 281, + 301, + 297, + 313, + 329, + 349, + 345, + 365, + 361, + 381, + 377, + 397, + 393, + 225, + 227, + 229, + 234, + 241, + 245, + 257, + 261, + 73, + 401, + 403, + 405, + 410, + 417, + 419, + 421, + 426, + 433, + 435, + 437, + 442, + 542, + 277, + 282, + 275, + 273, + 293, + 298, + 291, + 289, + 309, + 314, + 307, + 305, + 325, + 330, + 323, + 321, + 341, + 346, + 339, + 337, + 357, + 362, + 355, + 353, + 373, + 378, + 371, + 369, + 389, + 394, + 387, + 385, + 1, + 4, + 6, + 12, + 31 + ], + "lenders_that_are_X": [ + 73, + 1, + 4, + 6, + 12, + 31 + ], + "low_ops": [ + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75 + ], + "plain_fourier_distance": { + "2": 1, + "4": 56, + "6": 23 + } + } + }, + "extra": { + "base_tag": "cd417b90", + "canonical": { + "helpers": 480, + "link_566": { + "aligned_frame_pairs": 1008, + "register_permutation_nonidentity": 220 + }, + "local_mass": 5594, + "paid_profile": { + "1": 2340, + "2": 508, + "3": 420, + "4": 126, + "5": 82, + "8": 8 + }, + "replay": { + "buffer_nonzero_window": [ + null, + null + ], + "buffers": 0, + "buffers_ever_nonzero": 0, + "cleanup_adds_reading_a_zero_buffer": 0, + "corrections": 0, + "independent_inputs": 704, + "low_lenders_exact_at_handoff": 0, + "max_overlap_of_buffer_lifetimes": 0, + "peak_nonzero_buffers": 0, + "rows_with_operator_words_before_cleanup": 0 + } + }, + "controls": [ + { + "by": "replay", + "control": "anticipatory: drop term 0 (114 += 1/2 K_62 339)", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: term 0 coefficient x2", + "ok": true, + "other_checks": { + "dual replay": "rejected[replay]" + }, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: term 0 coefficient sign flip", + "ok": true, + "other_checks": { + "dual replay": "rejected[replay]" + }, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: drop all 64 terms", + "ok": true, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: term 0 written into target 115", + "ok": true, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "anticipatory: term 0 redirected to pair K_44 / lender 277", + "ok": true, + "other_checks": { + "structure": "accepted" + }, + "reason": "target 2 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "anticipatory", + "control": "anticipatory: term 0 uses K_44 of another lender", + "ok": true, + "reason": "correction 0: operator 44 is not the reference change of the pair lent by source 339", + "rejected": true, + "target_check": "anticipatory" + }, + { + "by": "frame", + "control": "anticipatory: term 0 reads X register 73 through K_30", + "ok": true, + "other_checks": { + "structure": "accepted" + }, + "reason": "initial correction 0: source 73 is not at frame 0 (frame (224,))", + "rejected": true, + "target_check": "frame" + }, + { + "by": "replay", + "control": "low warp 44 (lender 277) dropped from B and cleanup", + "ok": true, + "other_checks": { + "frame": "rejected[frame]" + }, + "reason": "target 43 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "low warp 44 dropped from B only", + "ok": true, + "reason": "target 43 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "lender", + "control": "low lender 277 += X_0 just before its handoff", + "ok": true, + "reason": "low lender 277 is not exactly its own input at the handoff of warp 44", + "rejected": true, + "target_check": "lender" + }, + { + "by": "frame", + "control": "low warp 44 as an ordinary climb U->E", + "ok": true, + "reason": "non-nested climb of 277 at warp 44 treated as an ordinary climb: (388, 75, 41, 26) -> (258, 130, 85, 45)", + "rejected": true, + "target_check": "frame" + }, + { + "by": "replay", + "control": "drop inverse warp 44 in cleanup", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "final map wrong on register 277 (forward)", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "perturb coefficient x2: B item 1123 (lender 277 after its warp)", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "target 43 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "perturb coefficient x2: compensation gate 0", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "target 1 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "perturb coefficient x2: first cleanup add between live registers", + "ok": true, + "other_checks": { + "frame": "accepted" + }, + "reason": "a zero buffer is not returned to zero", + "rejected": true, + "target_check": "replay" + }, + { + "by": "profile", + "control": "charge every warp as a climb of rank d(L_U,L_E)", + "ok": true, + "reason": "recount {'1': 2287, '2': 536, '3': 386, '4': 181, '5': 37, '6': 23, '8': 8} != word report {1: 2287, 2: 535, 3: 386, 4: 125, 5: 37, 8: 8}", + "rejected": true, + "target_check": "profile" + }, + { + "by": "frame", + "control": "swap lenders of warps 1,14", + "ok": true, + "other_checks": { + "replay": "rejected[replay]" + }, + "reason": "warp 1: lender 349 frame (416, 70, 19, 13) != U (261, 133, 85, 45)", + "rejected": true, + "target_check": "frame" + }, + { + "by": "warp", + "control": "warp 1: singular G", + "ok": true, + "reason": "warp 1: G is singular over GF(2)", + "rejected": true, + "target_check": "warp" + }, + { + "by": "warp", + "control": "warp 1: invertible G with G span U != span E", + "ok": true, + "reason": "warp 1: G span U != span E", + "rejected": true, + "target_check": "warp" + }, + { + "by": "warp", + "control": "warp 1: dim E != dim U", + "ok": true, + "reason": "warp 1: dim U != dim E", + "rejected": true, + "target_check": "warp" + }, + { + "by": "frame", + "control": "cleanup item 0 uses the restored register, not its buffer", + "ok": true, + "reason": "cleanup item 0 touches register 591 whose frame is not FULL", + "rejected": true, + "target_check": "frame" + }, + { + "by": "replay", + "control": "delete restore gate 0", + "ok": true, + "reason": "restored cold register 572 is not its own input", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "delete compensation gate 0", + "ok": true, + "reason": "target 1 not final before cleanup", + "rejected": true, + "target_check": "replay" + }, + { + "by": "replay", + "control": "drop 18 forward-no-op cleanup adds (dual replay)", + "ok": true, + "other_checks": { + "forward replay": "accepted" + }, + "reason": "a zero buffer is not returned to zero", + "rejected": true, + "target_check": "replay" + }, + { + "accepted": true, + "control": "positive: rebased warp U/E lists (same spans) accepted", + "ok": true, + "target_check": "warp+frame" + }, + { + "by": "pin", + "control": "pin: one flipped bit in the word file", + "ok": true, + "reason": "git blob id mismatch for words/BORROW-WORD-80extra.json.gz", + "rejected": true, + "target_check": "pin" + }, + { + "by": "prefix", + "control": "witness: one deleted prefix gate of helper 689 kept", + "ok": true, + "reason": "low helper 689: witness deleted prefix [269, 270, 271] != derived [269, 270, 271, 272]", + "rejected": true, + "target_check": "prefix" + } + ], + "controls_ok": true, + "delta_vs_pr2269": { + "1": -52, + "2": 26, + "3": -32, + "4": 0, + "5": -5, + "8": 0 + }, + "frames": { + "climbs": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 37 + }, + "copy_charges": { + "8": 8 + }, + "helper_width_sum": 3408, + "helpers": 400, + "if_warps_charged_mass": 5628, + "if_warps_charged_profile": { + "1": 2287, + "2": 536, + "3": 386, + "4": 181, + "5": 37, + "6": 23, + "8": 8 + }, + "local_mass": 5264, + "paid_profile": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "width_inventory": { + "4": 4, + "5": 4, + "7": 36, + "8": 84, + "9": 272 + } + }, + "links": { + "B_multiset_ok": true, + "canonical_A_gates_dropped": 0, + "canonical_cold_helpers": 78, + "canonical_cold_helpers_ending_FULL_after_borrowing": [ + 273, + 275, + 277, + 282, + 289, + 291, + 293, + 298, + 305, + 307, + 309, + 314, + 321, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394, + 533, + 554 + ], + "canonical_compensation_gates_dropped": 0, + "canonical_cut_gates_dropped": 0, + "canonical_precondition_gates_dropped": 0, + "deleted_prefix_gates": 136, + "derived_rewrites": [ + [ + 117, + 566, + "1", + [ + 51 + ] + ], + [ + 151, + 567, + "1", + [ + 51 + ] + ], + [ + 181, + 566, + "-1", + [ + 51 + ] + ], + [ + 181, + 566, + "1", + [ + 51 + ] + ], + [ + 214, + 566, + "-1", + [ + 51 + ] + ] + ], + "low_lenders": [ + 273, + 275, + 277, + 282, + 289, + 291, + 293, + 298, + 305, + 307, + 309, + 314, + 321, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394 + ], + "low_lenders_canonical_final_dims": { + "4": 32 + }, + "low_lenders_entrance_frame_dims": [ + 0 + ], + "low_ops": [ + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75 + ], + "low_prefix": { + "deferred_helper_only_high": 144, + "deferred_helper_only_low": 96, + "echoes": 128, + "temporaries": 8 + }, + "mass_identity": { + "predicted_saving": 330, + "removed_widths": 492, + "width_added_to_cold_now_FULL": 162 + }, + "moved_tail_gates": 48, + "removed_high": 48, + "removed_low": 32, + "removed_old_widths": { + "4": 4, + "5": 44, + "8": 32 + } + }, + "mass_delta_vs_pr2269": -121, + "pr2226": { + "high_pairs_equal_pr2226": 43, + "high_pairs_from_pr2269": 43, + "low_pairs_equal_pr2226": 32, + "new_high_pairs": [ + [ + 606, + 12 + ], + [ + 635, + 6 + ], + [ + 637, + 31 + ], + [ + 638, + 4 + ], + [ + 639, + 1 + ] + ], + "new_high_pr2226_lenders": [ + [ + 606, + 395 + ], + [ + 635, + 363 + ], + [ + 637, + 530 + ], + [ + 638, + 331 + ], + [ + 639, + 299 + ] + ], + "terms_equal_pr2226": 64 + }, + "predecessor_43": { + "links": { + "deleted_prefix_gates": 0, + "moved_tail_gates": 48, + "removed_high": 43, + "removed_low": 0 + }, + "local_mass": 5385, + "paid_profile": { + "1": 2339, + "2": 509, + "3": 418, + "4": 125, + "5": 42, + "8": 8 + }, + "replay": { + "dual": { + "buffer_nonzero_window": [ + 0, + 4498 + ], + "buffers": 76, + "buffers_ever_nonzero": 58, + "cleanup_adds_reading_a_zero_buffer": 355, + "corrections": 0, + "independent_inputs": 661, + "max_overlap_of_buffer_lifetimes": 48, + "peak_nonzero_buffers": 48 + }, + "forward": { + "buffer_nonzero_window": [ + 1, + 4470 + ], + "buffers": 76, + "buffers_ever_nonzero": 76, + "cleanup_adds_reading_a_zero_buffer": 110, + "corrections": 0, + "independent_inputs": 661, + "low_lenders_exact_at_handoff": 0, + "max_overlap_of_buffer_lifetimes": 44, + "peak_nonzero_buffers": 44, + "rows_with_operator_words_before_cleanup": 88 + } + } + }, + "replay": { + "dual": { + "buffer_nonzero_window": [ + 0, + 4527 + ], + "buffers": 44, + "buffers_ever_nonzero": 26, + "cleanup_adds_reading_a_zero_buffer": 84, + "corrections": 64, + "independent_inputs": 624, + "max_overlap_of_buffer_lifetimes": 22, + "peak_nonzero_buffers": 22 + }, + "forward": { + "buffer_nonzero_window": [ + 1, + 4499 + ], + "buffers": 44, + "buffers_ever_nonzero": 44, + "cleanup_adds_reading_a_zero_buffer": 87, + "corrections": 64, + "independent_inputs": 624, + "low_lenders_exact_at_handoff": 32, + "max_overlap_of_buffer_lifetimes": 44, + "peak_nonzero_buffers": 44, + "rows_with_operator_words_before_cleanup": 96 + } + }, + "saving_vs_canonical": 330, + "warps": { + "U_equal_E": 0, + "anticipatory_structure": { + "operators": 32, + "sources": 32, + "terms": 64 + }, + "anticipatory_terms": 64, + "count": 80, + "dims": { + "4": 77, + "5": 3 + }, + "lenders": [ + 243, + 250, + 266, + 259, + 333, + 317, + 554, + 285, + 281, + 301, + 297, + 313, + 329, + 349, + 345, + 365, + 361, + 381, + 377, + 397, + 393, + 225, + 227, + 229, + 234, + 241, + 245, + 257, + 261, + 73, + 401, + 403, + 405, + 410, + 417, + 419, + 421, + 426, + 433, + 435, + 437, + 442, + 542, + 277, + 282, + 275, + 273, + 293, + 298, + 291, + 289, + 309, + 314, + 307, + 305, + 325, + 330, + 323, + 321, + 341, + 346, + 339, + 337, + 357, + 362, + 355, + 353, + 373, + 378, + 371, + 369, + 389, + 394, + 387, + 385, + 1, + 4, + 6, + 12, + 31 + ], + "lenders_that_are_X": [ + 73, + 1, + 4, + 6, + 12, + 31 + ], + "low_ops": [ + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75 + ], + "plain_fourier_distance": { + "2": 1, + "4": 56, + "6": 23 + } + } + } + } +} diff --git a/research/t74-low-alias-borrowing/demo-t8-delta-proxy.json b/research/t74-low-alias-borrowing/demo-t8-delta-proxy.json new file mode 100644 index 0000000000..e9bb97b353 --- /dev/null +++ b/research/t74-low-alias-borrowing/demo-t8-delta-proxy.json @@ -0,0 +1,14 @@ +{ + "delta": { + "1": -42, + "2": 27, + "3": -23, + "4": -13 + }, + "family": "T74", + "helpers": { + "extra": 401, + "gauge44": 401 + }, + "label": "PROXY: T8 transfer delta (PR2226 80-alias word minus PR2260 44-high word) applied to both PR2269 T74 words; not a constructed word" +} diff --git a/research/t74-low-alias-borrowing/inputs/PR2226-WITNESS.json b/research/t74-low-alias-borrowing/inputs/PR2226-WITNESS.json new file mode 100644 index 0000000000..62edbcce16 --- /dev/null +++ b/research/t74-low-alias-borrowing/inputs/PR2226-WITNESS.json @@ -0,0 +1,3926 @@ +{ + "pairs": [ + { + "register": 597, + "base": 592, + "common_basis": [ + 320, + 192, + 45, + 30 + ], + "dimension": 4, + "deadline": 1054, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 243, + "retirement_B_event": -1, + "retirement_frame": 66, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1054, + "handoff_basis": [ + 320, + 192, + 45, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 643, + "base": 640, + "common_basis": [ + 423, + 65, + 20, + 10 + ], + "dimension": 4, + "deadline": 1102, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 250, + "retirement_B_event": -1, + "retirement_frame": 66, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1102, + "handoff_basis": [ + 423, + 65, + 20, + 10 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 645, + "base": 640, + "common_basis": [ + 423, + 65, + 20, + 10 + ], + "dimension": 4, + "deadline": 1102, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 266, + "retirement_B_event": -1, + "retirement_frame": 95, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1102, + "handoff_basis": [ + 423, + 65, + 20, + 10 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 646, + "base": 640, + "common_basis": [ + 423, + 65, + 20, + 10 + ], + "dimension": 4, + "deadline": 1102, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 259, + "retirement_B_event": -1, + "retirement_frame": 95, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1102, + "handoff_basis": [ + 423, + 65, + 20, + 10 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 659, + "base": 656, + "common_basis": [ + 427, + 96, + 24, + 6 + ], + "dimension": 4, + "deadline": 1118, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 333, + "retirement_B_event": 780, + "retirement_frame": 211, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1118, + "handoff_basis": [ + 427, + 96, + 24, + 6 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 661, + "base": 656, + "common_basis": [ + 427, + 96, + 24, + 6 + ], + "dimension": 4, + "deadline": 1118, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 317, + "retirement_B_event": 760, + "retirement_frame": 182, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1118, + "handoff_basis": [ + 427, + 96, + 24, + 6 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 651, + "base": 648, + "common_basis": [ + 288, + 160, + 75, + 25, + 7 + ], + "dimension": 5, + "deadline": 1110, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 554, + "retirement_B_event": 1046, + "retirement_frame": 734, + "retirement_dimension": 5, + "old_final_dimension": 8, + "handoff_B": 1110, + "handoff_basis": [ + 288, + 160, + 75, + 25, + 7 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 683, + "base": 680, + "common_basis": [ + 407, + 66, + 36, + 9 + ], + "dimension": 4, + "deadline": 1142, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 285, + "retirement_B_event": 721, + "retirement_frame": 124, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1142, + "handoff_basis": [ + 407, + 66, + 36, + 9 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 686, + "base": 680, + "common_basis": [ + 407, + 66, + 36, + 9 + ], + "dimension": 4, + "deadline": 1142, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 281, + "retirement_B_event": 719, + "retirement_frame": 124, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1142, + "handoff_basis": [ + 407, + 66, + 36, + 9 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 689, + "base": 688, + "common_basis": [ + 258, + 130, + 85, + 45 + ], + "dimension": 4, + "deadline": 1150, + "deleted_echo_indices": [ + 255, + 256, + 257, + 258 + ], + "low": true, + "deleted_prefix_indices": [ + 255, + 256, + 257, + 258 + ], + "early_prefix_rewrites": { + "255": [], + "256": [], + "257": [], + "258": [] + }, + "borrow_from": 277, + "retirement_B_event": 719, + "retirement_frame": 124, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1150, + "handoff_basis": [ + 258, + 130, + 85, + 45 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 690, + "base": 688, + "common_basis": [ + 258, + 130, + 85, + 45 + ], + "dimension": 4, + "deadline": 1150, + "deleted_echo_indices": [ + 259, + 260, + 261, + 262 + ], + "low": true, + "deleted_prefix_indices": [ + 259, + 260, + 261, + 262 + ], + "early_prefix_rewrites": { + "259": [], + "260": [], + "261": [], + "262": [] + }, + "borrow_from": 282, + "retirement_B_event": 721, + "retirement_frame": 124, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1150, + "handoff_basis": [ + 258, + 130, + 85, + 45 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 696, + "base": 696, + "common_basis": [ + 455, + 33, + 18, + 12 + ], + "dimension": 4, + "deadline": 1158, + "deleted_echo_indices": [ + 267, + 268, + 269, + 270 + ], + "low": true, + "deleted_prefix_indices": [ + 267, + 268, + 269, + 270 + ], + "early_prefix_rewrites": { + "267": [], + "268": [], + "269": [], + "270": [] + }, + "borrow_from": 275, + "retirement_B_event": 722, + "retirement_frame": 124, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1158, + "handoff_basis": [ + 455, + 33, + 18, + 12 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 697, + "base": 696, + "common_basis": [ + 455, + 33, + 18, + 12 + ], + "dimension": 4, + "deadline": 1158, + "deleted_echo_indices": [ + 271, + 272, + 273, + 274 + ], + "low": true, + "deleted_prefix_indices": [ + 271, + 272, + 273, + 274 + ], + "early_prefix_rewrites": { + "271": [], + "272": [], + "273": [], + "274": [] + }, + "borrow_from": 273, + "retirement_B_event": 720, + "retirement_frame": 124, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1158, + "handoff_basis": [ + 455, + 33, + 18, + 12 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 699, + "base": 696, + "common_basis": [ + 455, + 33, + 18, + 12 + ], + "dimension": 4, + "deadline": 1158, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 301, + "retirement_B_event": 740, + "retirement_frame": 153, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1158, + "handoff_basis": [ + 455, + 33, + 18, + 12 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 639, + "base": 632, + "common_basis": [ + 257, + 129, + 76, + 42, + 30 + ], + "dimension": 5, + "deadline": 1094, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 299, + "retirement_B_event": 942, + "retirement_frame": 630, + "retirement_dimension": 5, + "old_final_dimension": 9, + "handoff_B": 1094, + "handoff_basis": [ + 257, + 129, + 76, + 42, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 702, + "base": 696, + "common_basis": [ + 455, + 33, + 18, + 12 + ], + "dimension": 4, + "deadline": 1158, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 297, + "retirement_B_event": 738, + "retirement_frame": 153, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1158, + "handoff_basis": [ + 455, + 33, + 18, + 12 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 700, + "base": 696, + "common_basis": [ + 455, + 33, + 18, + 12 + ], + "dimension": 4, + "deadline": 1158, + "deleted_echo_indices": [ + 279, + 280, + 281, + 282 + ], + "low": true, + "deleted_prefix_indices": [ + 279, + 280, + 281, + 282 + ], + "early_prefix_rewrites": { + "279": [], + "280": [], + "281": [], + "282": [] + }, + "borrow_from": 293, + "retirement_B_event": 738, + "retirement_frame": 153, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1158, + "handoff_basis": [ + 455, + 33, + 18, + 12 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 592, + "base": 592, + "common_basis": [ + 320, + 192, + 45, + 30 + ], + "dimension": 4, + "deadline": 1054, + "deleted_echo_indices": [ + 51, + 52, + 53, + 54 + ], + "low": true, + "deleted_prefix_indices": [ + 51, + 52, + 53, + 54 + ], + "early_prefix_rewrites": { + "51": [], + "52": [], + "53": [], + "54": [] + }, + "borrow_from": 298, + "retirement_B_event": 740, + "retirement_frame": 153, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1054, + "handoff_basis": [ + 320, + 192, + 45, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 593, + "base": 592, + "common_basis": [ + 320, + 192, + 45, + 30 + ], + "dimension": 4, + "deadline": 1054, + "deleted_echo_indices": [ + 55, + 56, + 57, + 58 + ], + "low": true, + "deleted_prefix_indices": [ + 55, + 56, + 57, + 58 + ], + "early_prefix_rewrites": { + "55": [], + "56": [], + "57": [], + "58": [] + }, + "borrow_from": 291, + "retirement_B_event": 741, + "retirement_frame": 153, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1054, + "handoff_basis": [ + 320, + 192, + 45, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 594, + "base": 592, + "common_basis": [ + 320, + 192, + 45, + 30 + ], + "dimension": 4, + "deadline": 1054, + "deleted_echo_indices": [ + 59, + 60, + 61, + 62 + ], + "low": true, + "deleted_prefix_indices": [ + 59, + 60, + 61, + 62 + ], + "early_prefix_rewrites": { + "59": [], + "60": [], + "61": [], + "62": [] + }, + "borrow_from": 289, + "retirement_B_event": 739, + "retirement_frame": 153, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1054, + "handoff_basis": [ + 320, + 192, + 45, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 703, + "base": 696, + "common_basis": [ + 455, + 33, + 18, + 12 + ], + "dimension": 4, + "deadline": 1158, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 313, + "retirement_B_event": 758, + "retirement_frame": 182, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1158, + "handoff_basis": [ + 455, + 33, + 18, + 12 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 698, + "base": 696, + "common_basis": [ + 455, + 33, + 18, + 12 + ], + "dimension": 4, + "deadline": 1158, + "deleted_echo_indices": [ + 275, + 276, + 277, + 278 + ], + "low": true, + "deleted_prefix_indices": [ + 275, + 276, + 277, + 278 + ], + "early_prefix_rewrites": { + "275": [], + "276": [], + "277": [], + "278": [] + }, + "borrow_from": 309, + "retirement_B_event": 758, + "retirement_frame": 182, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1158, + "handoff_basis": [ + 455, + 33, + 18, + 12 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 596, + "base": 592, + "common_basis": [ + 320, + 192, + 45, + 30 + ], + "dimension": 4, + "deadline": 1054, + "deleted_echo_indices": [ + 63, + 64, + 65, + 66 + ], + "low": true, + "deleted_prefix_indices": [ + 63, + 64, + 65, + 66 + ], + "early_prefix_rewrites": { + "63": [], + "64": [], + "65": [], + "66": [] + }, + "borrow_from": 314, + "retirement_B_event": 760, + "retirement_frame": 182, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1054, + "handoff_basis": [ + 320, + 192, + 45, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 692, + "base": 688, + "common_basis": [ + 258, + 130, + 85, + 45 + ], + "dimension": 4, + "deadline": 1150, + "deleted_echo_indices": [ + 263, + 264, + 265, + 266 + ], + "low": true, + "deleted_prefix_indices": [ + 263, + 264, + 265, + 266 + ], + "early_prefix_rewrites": { + "263": [], + "264": [], + "265": [], + "266": [] + }, + "borrow_from": 307, + "retirement_B_event": 761, + "retirement_frame": 182, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1150, + "handoff_basis": [ + 258, + 130, + 85, + 45 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 600, + "base": 600, + "common_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "dimension": 5, + "deadline": 1062, + "deleted_echo_indices": [ + 67, + 68, + 69, + 70 + ], + "low": true, + "deleted_prefix_indices": [ + 67, + 68, + 69, + 70 + ], + "early_prefix_rewrites": { + "67": [], + "68": [], + "69": [], + "70": [] + }, + "borrow_from": 305, + "retirement_B_event": 759, + "retirement_frame": 182, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1062, + "handoff_basis": [ + 409, + 80, + 40, + 5 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 638, + "base": 632, + "common_basis": [ + 257, + 129, + 76, + 42, + 30 + ], + "dimension": 5, + "deadline": 1094, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 331, + "retirement_B_event": 944, + "retirement_frame": 632, + "retirement_dimension": 5, + "old_final_dimension": 9, + "handoff_B": 1094, + "handoff_basis": [ + 257, + 129, + 76, + 42, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 701, + "base": 696, + "common_basis": [ + 455, + 33, + 18, + 12 + ], + "dimension": 4, + "deadline": 1158, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 329, + "retirement_B_event": 778, + "retirement_frame": 211, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1158, + "handoff_basis": [ + 455, + 33, + 18, + 12 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 601, + "base": 600, + "common_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "dimension": 5, + "deadline": 1062, + "deleted_echo_indices": [ + 71, + 72, + 73, + 74 + ], + "low": true, + "deleted_prefix_indices": [ + 71, + 72, + 73, + 74 + ], + "early_prefix_rewrites": { + "71": [], + "72": [], + "73": [], + "74": [] + }, + "borrow_from": 325, + "retirement_B_event": 778, + "retirement_frame": 211, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1062, + "handoff_basis": [ + 409, + 80, + 40, + 5 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 602, + "base": 600, + "common_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "dimension": 5, + "deadline": 1062, + "deleted_echo_indices": [ + 75, + 76, + 77, + 78 + ], + "low": true, + "deleted_prefix_indices": [ + 75, + 76, + 77, + 78 + ], + "early_prefix_rewrites": { + "75": [], + "76": [], + "77": [], + "78": [] + }, + "borrow_from": 330, + "retirement_B_event": 780, + "retirement_frame": 211, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1062, + "handoff_basis": [ + 409, + 80, + 40, + 5 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 604, + "base": 600, + "common_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "dimension": 5, + "deadline": 1062, + "deleted_echo_indices": [ + 79, + 80, + 81, + 82 + ], + "low": true, + "deleted_prefix_indices": [ + 79, + 80, + 81, + 82 + ], + "early_prefix_rewrites": { + "79": [], + "80": [], + "81": [], + "82": [] + }, + "borrow_from": 323, + "retirement_B_event": 781, + "retirement_frame": 211, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1062, + "handoff_basis": [ + 409, + 80, + 40, + 5 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 688, + "base": 688, + "common_basis": [ + 258, + 130, + 85, + 45 + ], + "dimension": 4, + "deadline": 1150, + "deleted_echo_indices": [ + 251, + 252, + 253, + 254 + ], + "low": true, + "deleted_prefix_indices": [ + 251, + 252, + 253, + 254 + ], + "early_prefix_rewrites": { + "251": [], + "252": [], + "253": [], + "254": [] + }, + "borrow_from": 321, + "retirement_B_event": 779, + "retirement_frame": 211, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1150, + "handoff_basis": [ + 258, + 130, + 85, + 45 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 595, + "base": 592, + "common_basis": [ + 320, + 192, + 45, + 30 + ], + "dimension": 4, + "deadline": 1054, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 349, + "retirement_B_event": 800, + "retirement_frame": 240, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1054, + "handoff_basis": [ + 320, + 192, + 45, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 695, + "base": 688, + "common_basis": [ + 258, + 130, + 85, + 45 + ], + "dimension": 4, + "deadline": 1150, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 345, + "retirement_B_event": 798, + "retirement_frame": 240, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1150, + "handoff_basis": [ + 258, + 130, + 85, + 45 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 684, + "base": 680, + "common_basis": [ + 407, + 66, + 36, + 9 + ], + "dimension": 4, + "deadline": 1142, + "deleted_echo_indices": [ + 247, + 248, + 249, + 250 + ], + "low": true, + "deleted_prefix_indices": [ + 247, + 248, + 249, + 250 + ], + "early_prefix_rewrites": { + "247": [], + "248": [], + "249": [], + "250": [] + }, + "borrow_from": 341, + "retirement_B_event": 798, + "retirement_frame": 240, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1142, + "handoff_basis": [ + 407, + 66, + 36, + 9 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 608, + "base": 608, + "common_basis": [ + 272, + 144, + 75, + 42, + 7 + ], + "dimension": 5, + "deadline": 1070, + "deleted_echo_indices": [ + 83, + 84, + 85, + 86 + ], + "low": true, + "deleted_prefix_indices": [ + 83, + 84, + 85, + 86 + ], + "early_prefix_rewrites": { + "83": [], + "84": [], + "85": [], + "86": [] + }, + "borrow_from": 346, + "retirement_B_event": 800, + "retirement_frame": 240, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1070, + "handoff_basis": [ + 272, + 144, + 75, + 42 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 609, + "base": 608, + "common_basis": [ + 272, + 144, + 75, + 42, + 7 + ], + "dimension": 5, + "deadline": 1070, + "deleted_echo_indices": [ + 87, + 88, + 89, + 90 + ], + "low": true, + "deleted_prefix_indices": [ + 87, + 88, + 89, + 90 + ], + "early_prefix_rewrites": { + "87": [], + "88": [], + "89": [], + "90": [] + }, + "borrow_from": 339, + "retirement_B_event": 801, + "retirement_frame": 240, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1070, + "handoff_basis": [ + 272, + 144, + 75, + 42 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 610, + "base": 608, + "common_basis": [ + 272, + 144, + 75, + 42, + 7 + ], + "dimension": 5, + "deadline": 1070, + "deleted_echo_indices": [ + 91, + 92, + 93, + 94 + ], + "low": true, + "deleted_prefix_indices": [ + 91, + 92, + 93, + 94 + ], + "early_prefix_rewrites": { + "91": [], + "92": [], + "93": [], + "94": [] + }, + "borrow_from": 337, + "retirement_B_event": 799, + "retirement_frame": 240, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1070, + "handoff_basis": [ + 272, + 144, + 75, + 42 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 598, + "base": 592, + "common_basis": [ + 320, + 192, + 45, + 30 + ], + "dimension": 4, + "deadline": 1054, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 365, + "retirement_B_event": 818, + "retirement_frame": 269, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1054, + "handoff_basis": [ + 320, + 192, + 45, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 635, + "base": 632, + "common_basis": [ + 257, + 129, + 76, + 42, + 30 + ], + "dimension": 5, + "deadline": 1094, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 363, + "retirement_B_event": 946, + "retirement_frame": 634, + "retirement_dimension": 5, + "old_final_dimension": 9, + "handoff_B": 1094, + "handoff_basis": [ + 257, + 129, + 76, + 42, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 599, + "base": 592, + "common_basis": [ + 320, + 192, + 45, + 30 + ], + "dimension": 4, + "deadline": 1054, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 361, + "retirement_B_event": 816, + "retirement_frame": 269, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1054, + "handoff_basis": [ + 320, + 192, + 45, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 682, + "base": 680, + "common_basis": [ + 407, + 66, + 36, + 9 + ], + "dimension": 4, + "deadline": 1142, + "deleted_echo_indices": [ + 243, + 244, + 245, + 246 + ], + "low": true, + "deleted_prefix_indices": [ + 243, + 244, + 245, + 246 + ], + "early_prefix_rewrites": { + "243": [], + "244": [], + "245": [], + "246": [] + }, + "borrow_from": 357, + "retirement_B_event": 816, + "retirement_frame": 269, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1142, + "handoff_basis": [ + 407, + 66, + 36, + 9 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 612, + "base": 608, + "common_basis": [ + 272, + 144, + 75, + 42, + 7 + ], + "dimension": 5, + "deadline": 1070, + "deleted_echo_indices": [ + 95, + 96, + 97, + 98 + ], + "low": true, + "deleted_prefix_indices": [ + 95, + 96, + 97, + 98 + ], + "early_prefix_rewrites": { + "95": [], + "96": [], + "97": [], + "98": [] + }, + "borrow_from": 362, + "retirement_B_event": 818, + "retirement_frame": 269, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1070, + "handoff_basis": [ + 272, + 144, + 75, + 42 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 681, + "base": 680, + "common_basis": [ + 407, + 66, + 36, + 9 + ], + "dimension": 4, + "deadline": 1142, + "deleted_echo_indices": [ + 239, + 240, + 241, + 242 + ], + "low": true, + "deleted_prefix_indices": [ + 239, + 240, + 241, + 242 + ], + "early_prefix_rewrites": { + "239": [], + "240": [], + "241": [], + "242": [] + }, + "borrow_from": 355, + "retirement_B_event": 819, + "retirement_frame": 269, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1142, + "handoff_basis": [ + 407, + 66, + 36, + 9 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 680, + "base": 680, + "common_basis": [ + 407, + 66, + 36, + 9 + ], + "dimension": 4, + "deadline": 1142, + "deleted_echo_indices": [ + 235, + 236, + 237, + 238 + ], + "low": true, + "deleted_prefix_indices": [ + 235, + 236, + 237, + 238 + ], + "early_prefix_rewrites": { + "235": [], + "236": [], + "237": [], + "238": [] + }, + "borrow_from": 353, + "retirement_B_event": 817, + "retirement_frame": 269, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1142, + "handoff_basis": [ + 407, + 66, + 36, + 9 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 694, + "base": 688, + "common_basis": [ + 258, + 130, + 85, + 45 + ], + "dimension": 4, + "deadline": 1150, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 381, + "retirement_B_event": 836, + "retirement_frame": 298, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1150, + "handoff_basis": [ + 258, + 130, + 85, + 45 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 693, + "base": 688, + "common_basis": [ + 258, + 130, + 85, + 45 + ], + "dimension": 4, + "deadline": 1150, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 377, + "retirement_B_event": 834, + "retirement_frame": 298, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1150, + "handoff_basis": [ + 258, + 130, + 85, + 45 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 676, + "base": 672, + "common_basis": [ + 413, + 72, + 48, + 3 + ], + "dimension": 4, + "deadline": 1134, + "deleted_echo_indices": [ + 229, + 231, + 233, + 234 + ], + "low": true, + "deleted_prefix_indices": [ + 229, + 230, + 231, + 232, + 233, + 234 + ], + "early_prefix_rewrites": { + "229": [], + "231": [ + [ + "add", + 181, + 566, + 1, + 1, + 3 + ] + ], + "233": [], + "234": [] + }, + "borrow_from": 373, + "retirement_B_event": 834, + "retirement_frame": 298, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1134, + "handoff_basis": [ + 413, + 72, + 48, + 3 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 624, + "base": 624, + "common_basis": [ + 391, + 68, + 34, + 17, + 8 + ], + "dimension": 5, + "deadline": 1086, + "deleted_echo_indices": [ + 115, + 116, + 117, + 118 + ], + "low": true, + "deleted_prefix_indices": [ + 115, + 116, + 117, + 118 + ], + "early_prefix_rewrites": { + "115": [], + "116": [], + "117": [], + "118": [] + }, + "borrow_from": 378, + "retirement_B_event": 836, + "retirement_frame": 298, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1086, + "handoff_basis": [ + 391, + 68, + 34, + 17 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 625, + "base": 624, + "common_basis": [ + 391, + 68, + 34, + 17, + 8 + ], + "dimension": 5, + "deadline": 1086, + "deleted_echo_indices": [ + 119, + 120, + 121, + 122 + ], + "low": true, + "deleted_prefix_indices": [ + 119, + 120, + 121, + 122 + ], + "early_prefix_rewrites": { + "119": [], + "120": [], + "121": [], + "122": [] + }, + "borrow_from": 371, + "retirement_B_event": 837, + "retirement_frame": 298, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1086, + "handoff_basis": [ + 391, + 68, + 34, + 17 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 626, + "base": 624, + "common_basis": [ + 391, + 68, + 34, + 17, + 8 + ], + "dimension": 5, + "deadline": 1086, + "deleted_echo_indices": [ + 123, + 124, + 125, + 126 + ], + "low": true, + "deleted_prefix_indices": [ + 123, + 124, + 125, + 126 + ], + "early_prefix_rewrites": { + "123": [], + "124": [], + "125": [], + "126": [] + }, + "borrow_from": 369, + "retirement_B_event": 835, + "retirement_frame": 298, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1086, + "handoff_basis": [ + 391, + 68, + 34, + 17 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 691, + "base": 688, + "common_basis": [ + 258, + 130, + 85, + 45 + ], + "dimension": 4, + "deadline": 1150, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 397, + "retirement_B_event": 854, + "retirement_frame": 327, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1150, + "handoff_basis": [ + 258, + 130, + 85, + 45 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 606, + "base": 600, + "common_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "dimension": 5, + "deadline": 1062, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 395, + "retirement_B_event": 948, + "retirement_frame": 636, + "retirement_dimension": 5, + "old_final_dimension": 9, + "handoff_B": 1062, + "handoff_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 687, + "base": 680, + "common_basis": [ + 407, + 66, + 36, + 9 + ], + "dimension": 4, + "deadline": 1142, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 393, + "retirement_B_event": 852, + "retirement_frame": 327, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1142, + "handoff_basis": [ + 407, + 66, + 36, + 9 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 674, + "base": 672, + "common_basis": [ + 413, + 72, + 48, + 3 + ], + "dimension": 4, + "deadline": 1134, + "deleted_echo_indices": [ + 225, + 226, + 227, + 228 + ], + "low": true, + "deleted_prefix_indices": [ + 225, + 226, + 227, + 228 + ], + "early_prefix_rewrites": { + "225": [], + "226": [], + "227": [], + "228": [] + }, + "borrow_from": 389, + "retirement_B_event": 852, + "retirement_frame": 327, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1134, + "handoff_basis": [ + 413, + 72, + 48, + 3 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 628, + "base": 624, + "common_basis": [ + 391, + 68, + 34, + 17, + 8 + ], + "dimension": 5, + "deadline": 1086, + "deleted_echo_indices": [ + 127, + 129, + 131, + 132 + ], + "low": true, + "deleted_prefix_indices": [ + 127, + 128, + 129, + 130, + 131, + 132 + ], + "early_prefix_rewrites": { + "127": [], + "129": [ + [ + "add", + 214, + 566, + -1, + 1, + 3 + ] + ], + "131": [], + "132": [] + }, + "borrow_from": 394, + "retirement_B_event": 854, + "retirement_frame": 327, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1086, + "handoff_basis": [ + 391, + 68, + 34, + 17 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 673, + "base": 672, + "common_basis": [ + 413, + 72, + 48, + 3 + ], + "dimension": 4, + "deadline": 1134, + "deleted_echo_indices": [ + 221, + 222, + 223, + 224 + ], + "low": true, + "deleted_prefix_indices": [ + 221, + 222, + 223, + 224 + ], + "early_prefix_rewrites": { + "221": [], + "222": [], + "223": [], + "224": [] + }, + "borrow_from": 387, + "retirement_B_event": 855, + "retirement_frame": 327, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1134, + "handoff_basis": [ + 413, + 72, + 48, + 3 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 672, + "base": 672, + "common_basis": [ + 413, + 72, + 48, + 3 + ], + "dimension": 4, + "deadline": 1134, + "deleted_echo_indices": [ + 217, + 218, + 219, + 220 + ], + "low": true, + "deleted_prefix_indices": [ + 217, + 218, + 219, + 220 + ], + "early_prefix_rewrites": { + "217": [], + "218": [], + "219": [], + "220": [] + }, + "borrow_from": 385, + "retirement_B_event": 853, + "retirement_frame": 327, + "retirement_dimension": 4, + "old_final_dimension": 4, + "handoff_B": 1134, + "handoff_basis": [ + 413, + 72, + 48, + 3 + ], + "handoff_paid_rank": 0, + "anticipate": true + }, + { + "register": 685, + "base": 680, + "common_basis": [ + 407, + 66, + 36, + 9 + ], + "dimension": 4, + "deadline": 1142, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 225, + "retirement_B_event": -1, + "retirement_frame": 37, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1142, + "handoff_basis": [ + 407, + 66, + 36, + 9 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 679, + "base": 672, + "common_basis": [ + 413, + 72, + 48, + 3 + ], + "dimension": 4, + "deadline": 1134, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 227, + "retirement_B_event": -1, + "retirement_frame": 37, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1134, + "handoff_basis": [ + 413, + 72, + 48, + 3 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 678, + "base": 672, + "common_basis": [ + 413, + 72, + 48, + 3 + ], + "dimension": 4, + "deadline": 1134, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 229, + "retirement_B_event": -1, + "retirement_frame": 37, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1134, + "handoff_basis": [ + 413, + 72, + 48, + 3 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 677, + "base": 672, + "common_basis": [ + 413, + 72, + 48, + 3 + ], + "dimension": 4, + "deadline": 1134, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 234, + "retirement_B_event": -1, + "retirement_frame": 37, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1134, + "handoff_basis": [ + 413, + 72, + 48, + 3 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 675, + "base": 672, + "common_basis": [ + 413, + 72, + 48, + 3 + ], + "dimension": 4, + "deadline": 1134, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 241, + "retirement_B_event": -1, + "retirement_frame": 66, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1134, + "handoff_basis": [ + 413, + 72, + 48, + 3 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 663, + "base": 656, + "common_basis": [ + 427, + 96, + 24, + 6 + ], + "dimension": 4, + "deadline": 1118, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 245, + "retirement_B_event": -1, + "retirement_frame": 66, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1118, + "handoff_basis": [ + 427, + 96, + 24, + 6 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 662, + "base": 656, + "common_basis": [ + 427, + 96, + 24, + 6 + ], + "dimension": 4, + "deadline": 1118, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 257, + "retirement_B_event": -1, + "retirement_frame": 95, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1118, + "handoff_basis": [ + 427, + 96, + 24, + 6 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 647, + "base": 640, + "common_basis": [ + 423, + 65, + 20, + 10 + ], + "dimension": 4, + "deadline": 1102, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 261, + "retirement_B_event": -1, + "retirement_frame": 95, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1102, + "handoff_basis": [ + 423, + 65, + 20, + 10 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 653, + "base": 648, + "common_basis": [ + 288, + 160, + 75, + 25, + 7 + ], + "dimension": 5, + "deadline": 1110, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 73, + "retirement_B_event": 947, + "retirement_frame": 635, + "retirement_dimension": 5, + "old_final_dimension": 9, + "handoff_B": 1110, + "handoff_basis": [ + 288, + 160, + 75, + 25, + 7 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 603, + "base": 600, + "common_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "dimension": 5, + "deadline": 1062, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 401, + "retirement_B_event": -1, + "retirement_frame": 356, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1062, + "handoff_basis": [ + 409, + 80, + 40, + 5 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 605, + "base": 600, + "common_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "dimension": 5, + "deadline": 1062, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 403, + "retirement_B_event": -1, + "retirement_frame": 356, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1062, + "handoff_basis": [ + 409, + 80, + 40, + 5 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 607, + "base": 600, + "common_basis": [ + 409, + 80, + 40, + 5, + 2 + ], + "dimension": 5, + "deadline": 1062, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 405, + "retirement_B_event": -1, + "retirement_frame": 356, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1062, + "handoff_basis": [ + 409, + 80, + 40, + 5 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 611, + "base": 608, + "common_basis": [ + 272, + 144, + 75, + 42, + 7 + ], + "dimension": 5, + "deadline": 1070, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 410, + "retirement_B_event": -1, + "retirement_frame": 356, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1070, + "handoff_basis": [ + 272, + 144, + 75, + 42 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 613, + "base": 608, + "common_basis": [ + 272, + 144, + 75, + 42, + 7 + ], + "dimension": 5, + "deadline": 1070, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 417, + "retirement_B_event": -1, + "retirement_frame": 385, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1070, + "handoff_basis": [ + 272, + 144, + 75, + 42 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 614, + "base": 608, + "common_basis": [ + 272, + 144, + 75, + 42, + 7 + ], + "dimension": 5, + "deadline": 1070, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 419, + "retirement_B_event": -1, + "retirement_frame": 385, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1070, + "handoff_basis": [ + 272, + 144, + 75, + 42 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 615, + "base": 608, + "common_basis": [ + 272, + 144, + 75, + 42, + 7 + ], + "dimension": 5, + "deadline": 1070, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 421, + "retirement_B_event": -1, + "retirement_frame": 385, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1070, + "handoff_basis": [ + 272, + 144, + 75, + 42 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 627, + "base": 624, + "common_basis": [ + 391, + 68, + 34, + 17, + 8 + ], + "dimension": 5, + "deadline": 1086, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 426, + "retirement_B_event": -1, + "retirement_frame": 385, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1086, + "handoff_basis": [ + 391, + 68, + 34, + 17 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 629, + "base": 624, + "common_basis": [ + 391, + 68, + 34, + 17, + 8 + ], + "dimension": 5, + "deadline": 1086, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 433, + "retirement_B_event": -1, + "retirement_frame": 414, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1086, + "handoff_basis": [ + 391, + 68, + 34, + 17 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 630, + "base": 624, + "common_basis": [ + 391, + 68, + 34, + 17, + 8 + ], + "dimension": 5, + "deadline": 1086, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 435, + "retirement_B_event": -1, + "retirement_frame": 414, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1086, + "handoff_basis": [ + 391, + 68, + 34, + 17 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 631, + "base": 624, + "common_basis": [ + 391, + 68, + 34, + 17, + 8 + ], + "dimension": 5, + "deadline": 1086, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 437, + "retirement_B_event": -1, + "retirement_frame": 414, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1086, + "handoff_basis": [ + 391, + 68, + 34, + 17 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 655, + "base": 648, + "common_basis": [ + 288, + 160, + 75, + 25, + 7 + ], + "dimension": 5, + "deadline": 1110, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 442, + "retirement_B_event": -1, + "retirement_frame": 414, + "retirement_dimension": 4, + "old_final_dimension": 9, + "handoff_B": 1110, + "handoff_basis": [ + 288, + 160, + 75, + 25 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 637, + "base": 632, + "common_basis": [ + 257, + 129, + 76, + 42, + 30 + ], + "dimension": 5, + "deadline": 1094, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 530, + "retirement_B_event": 1048, + "retirement_frame": 736, + "retirement_dimension": 5, + "old_final_dimension": 9, + "handoff_B": 1094, + "handoff_basis": [ + 257, + 129, + 76, + 42, + 30 + ], + "handoff_paid_rank": 0, + "anticipate": false + }, + { + "register": 654, + "base": 648, + "common_basis": [ + 288, + 160, + 75, + 25, + 7 + ], + "dimension": 5, + "deadline": 1110, + "deleted_echo_indices": [], + "low": false, + "borrow_from": 542, + "retirement_B_event": 1050, + "retirement_frame": 738, + "retirement_dimension": 5, + "old_final_dimension": 9, + "handoff_B": 1110, + "handoff_basis": [ + 288, + 160, + 75, + 25, + 7 + ], + "handoff_paid_rank": 0, + "anticipate": false + } + ], + "early_tail_events": [ + { + "old_tail_index": 35, + "before_B": 722, + "gate": [ + "add", + 282, + 285, + -1, + 1, + 124 + ] + }, + { + "old_tail_index": 36, + "before_B": 722, + "gate": [ + "scale", + 282, + 1, + -1, + 124 + ] + }, + { + "old_tail_index": 37, + "before_B": 720, + "gate": [ + "add", + 277, + 281, + -1, + 1, + 124 + ] + }, + { + "old_tail_index": 38, + "before_B": 720, + "gate": [ + "scale", + 277, + 1, + -1, + 124 + ] + }, + { + "old_tail_index": 39, + "before_B": 723, + "gate": [ + "add", + 275, + 31, + -1, + 1, + 124 + ] + }, + { + "old_tail_index": 40, + "before_B": 721, + "gate": [ + "add", + 273, + 12, + -1, + 1, + 124 + ] + }, + { + "old_tail_index": 41, + "before_B": 741, + "gate": [ + "add", + 298, + 301, + -1, + 1, + 153 + ] + }, + { + "old_tail_index": 42, + "before_B": 741, + "gate": [ + "scale", + 298, + 1, + -1, + 153 + ] + }, + { + "old_tail_index": 43, + "before_B": 739, + "gate": [ + "add", + 293, + 297, + -1, + 1, + 153 + ] + }, + { + "old_tail_index": 44, + "before_B": 739, + "gate": [ + "scale", + 293, + 1, + -1, + 153 + ] + }, + { + "old_tail_index": 45, + "before_B": 742, + "gate": [ + "add", + 291, + 55, + -1, + 1, + 153 + ] + }, + { + "old_tail_index": 46, + "before_B": 740, + "gate": [ + "add", + 289, + 101, + -1, + 1, + 153 + ] + }, + { + "old_tail_index": 47, + "before_B": 761, + "gate": [ + "add", + 314, + 317, + -1, + 1, + 182 + ] + }, + { + "old_tail_index": 48, + "before_B": 761, + "gate": [ + "scale", + 314, + 1, + -1, + 182 + ] + }, + { + "old_tail_index": 49, + "before_B": 759, + "gate": [ + "add", + 309, + 313, + -1, + 1, + 182 + ] + }, + { + "old_tail_index": 50, + "before_B": 759, + "gate": [ + "scale", + 309, + 1, + -1, + 182 + ] + }, + { + "old_tail_index": 51, + "before_B": 762, + "gate": [ + "add", + 307, + 85, + -1, + 1, + 182 + ] + }, + { + "old_tail_index": 52, + "before_B": 760, + "gate": [ + "add", + 305, + 98, + -1, + 1, + 182 + ] + }, + { + "old_tail_index": 53, + "before_B": 781, + "gate": [ + "add", + 330, + 333, + -1, + 1, + 211 + ] + }, + { + "old_tail_index": 54, + "before_B": 781, + "gate": [ + "scale", + 330, + 1, + -1, + 211 + ] + }, + { + "old_tail_index": 55, + "before_B": 779, + "gate": [ + "add", + 325, + 329, + -1, + 1, + 211 + ] + }, + { + "old_tail_index": 56, + "before_B": 779, + "gate": [ + "scale", + 325, + 1, + -1, + 211 + ] + }, + { + "old_tail_index": 57, + "before_B": 782, + "gate": [ + "add", + 323, + 33, + -1, + 1, + 211 + ] + }, + { + "old_tail_index": 58, + "before_B": 780, + "gate": [ + "add", + 321, + 49, + -1, + 1, + 211 + ] + }, + { + "old_tail_index": 59, + "before_B": 801, + "gate": [ + "add", + 346, + 349, + -1, + 1, + 240 + ] + }, + { + "old_tail_index": 60, + "before_B": 801, + "gate": [ + "scale", + 346, + 1, + -1, + 240 + ] + }, + { + "old_tail_index": 61, + "before_B": 799, + "gate": [ + "add", + 341, + 345, + -1, + 1, + 240 + ] + }, + { + "old_tail_index": 62, + "before_B": 799, + "gate": [ + "scale", + 341, + 1, + -1, + 240 + ] + }, + { + "old_tail_index": 63, + "before_B": 802, + "gate": [ + "add", + 339, + 1, + -1, + 1, + 240 + ] + }, + { + "old_tail_index": 64, + "before_B": 800, + "gate": [ + "add", + 337, + 6, + -1, + 1, + 240 + ] + }, + { + "old_tail_index": 65, + "before_B": 819, + "gate": [ + "add", + 362, + 365, + -1, + 1, + 269 + ] + }, + { + "old_tail_index": 66, + "before_B": 819, + "gate": [ + "scale", + 362, + 1, + -1, + 269 + ] + }, + { + "old_tail_index": 67, + "before_B": 817, + "gate": [ + "add", + 357, + 361, + -1, + 1, + 269 + ] + }, + { + "old_tail_index": 68, + "before_B": 817, + "gate": [ + "scale", + 357, + 1, + -1, + 269 + ] + }, + { + "old_tail_index": 69, + "before_B": 820, + "gate": [ + "add", + 355, + 74, + -1, + 1, + 269 + ] + }, + { + "old_tail_index": 70, + "before_B": 818, + "gate": [ + "add", + 353, + 83, + -1, + 1, + 269 + ] + }, + { + "old_tail_index": 71, + "before_B": 837, + "gate": [ + "add", + 378, + 381, + -1, + 1, + 298 + ] + }, + { + "old_tail_index": 72, + "before_B": 837, + "gate": [ + "scale", + 378, + 1, + -1, + 298 + ] + }, + { + "old_tail_index": 73, + "before_B": 835, + "gate": [ + "add", + 373, + 377, + -1, + 1, + 298 + ] + }, + { + "old_tail_index": 74, + "before_B": 835, + "gate": [ + "scale", + 373, + 1, + -1, + 298 + ] + }, + { + "old_tail_index": 75, + "before_B": 838, + "gate": [ + "add", + 371, + 88, + -1, + 1, + 298 + ] + }, + { + "old_tail_index": 76, + "before_B": 836, + "gate": [ + "add", + 369, + 80, + -1, + 1, + 298 + ] + }, + { + "old_tail_index": 77, + "before_B": 855, + "gate": [ + "add", + 394, + 397, + -1, + 1, + 327 + ] + }, + { + "old_tail_index": 78, + "before_B": 855, + "gate": [ + "scale", + 394, + 1, + -1, + 327 + ] + }, + { + "old_tail_index": 79, + "before_B": 853, + "gate": [ + "add", + 389, + 393, + -1, + 1, + 327 + ] + }, + { + "old_tail_index": 80, + "before_B": 853, + "gate": [ + "scale", + 389, + 1, + -1, + 327 + ] + }, + { + "old_tail_index": 81, + "before_B": 856, + "gate": [ + "add", + 387, + 4, + -1, + 1, + 327 + ] + }, + { + "old_tail_index": 82, + "before_B": 854, + "gate": [ + "add", + 385, + 68, + -1, + 1, + 327 + ] + } + ], + "initial_corrections": [ + { + "target": 114, + "source": 339, + "operator_word": [ + 36 + ], + "coefficient": "1/2" + }, + { + "target": 114, + "source": 337, + "operator_word": [ + 37 + ], + "coefficient": "1/2" + }, + { + "target": 117, + "source": 387, + "operator_word": [ + 56 + ], + "coefficient": "-1" + }, + { + "target": 117, + "source": 389, + "operator_word": [ + 54 + ], + "coefficient": "-1" + }, + { + "target": 121, + "source": 346, + "operator_word": [ + 35 + ], + "coefficient": "1/2" + }, + { + "target": 121, + "source": 337, + "operator_word": [ + 37 + ], + "coefficient": "1/2" + }, + { + "target": 123, + "source": 305, + "operator_word": [ + 25 + ], + "coefficient": "1/2" + }, + { + "target": 123, + "source": 330, + "operator_word": [ + 29 + ], + "coefficient": "1/2" + }, + { + "target": 126, + "source": 355, + "operator_word": [ + 43 + ], + "coefficient": "-1" + }, + { + "target": 126, + "source": 357, + "operator_word": [ + 41 + ], + "coefficient": "-1" + }, + { + "target": 130, + "source": 371, + "operator_word": [ + 49 + ], + "coefficient": "1/2" + }, + { + "target": 130, + "source": 394, + "operator_word": [ + 55 + ], + "coefficient": "1" + }, + { + "target": 133, + "source": 273, + "operator_word": [ + 13 + ], + "coefficient": "-1" + }, + { + "target": 133, + "source": 309, + "operator_word": [ + 22 + ], + "coefficient": "-1" + }, + { + "target": 137, + "source": 346, + "operator_word": [ + 35 + ], + "coefficient": "1/2" + }, + { + "target": 137, + "source": 362, + "operator_word": [ + 42 + ], + "coefficient": "1/2" + }, + { + "target": 149, + "source": 273, + "operator_word": [ + 13 + ], + "coefficient": "-1" + }, + { + "target": 149, + "source": 293, + "operator_word": [ + 17 + ], + "coefficient": "1" + }, + { + "target": 151, + "source": 378, + "operator_word": [ + 48 + ], + "coefficient": "1/2" + }, + { + "target": 151, + "source": 369, + "operator_word": [ + 50 + ], + "coefficient": "1/2" + }, + { + "target": 153, + "source": 355, + "operator_word": [ + 43 + ], + "coefficient": "-1" + }, + { + "target": 153, + "source": 341, + "operator_word": [ + 34 + ], + "coefficient": "1" + }, + { + "target": 155, + "source": 277, + "operator_word": [ + 10 + ], + "coefficient": "-1" + }, + { + "target": 155, + "source": 307, + "operator_word": [ + 24 + ], + "coefficient": "1" + }, + { + "target": 159, + "source": 275, + "operator_word": [ + 12 + ], + "coefficient": "-1" + }, + { + "target": 159, + "source": 293, + "operator_word": [ + 17 + ], + "coefficient": "-1" + }, + { + "target": 164, + "source": 353, + "operator_word": [ + 44 + ], + "coefficient": "-1" + }, + { + "target": 164, + "source": 341, + "operator_word": [ + 34 + ], + "coefficient": "-1" + }, + { + "target": 166, + "source": 371, + "operator_word": [ + 49 + ], + "coefficient": "1/2" + }, + { + "target": 166, + "source": 369, + "operator_word": [ + 50 + ], + "coefficient": "1/2" + }, + { + "target": 173, + "source": 339, + "operator_word": [ + 36 + ], + "coefficient": "1/2" + }, + { + "target": 173, + "source": 362, + "operator_word": [ + 42 + ], + "coefficient": "-1/2" + }, + { + "target": 175, + "source": 325, + "operator_word": [ + 28 + ], + "coefficient": "1/2" + }, + { + "target": 175, + "source": 323, + "operator_word": [ + 30 + ], + "coefficient": "-1/2" + }, + { + "target": 177, + "source": 385, + "operator_word": [ + 57 + ], + "coefficient": "-1" + }, + { + "target": 177, + "source": 389, + "operator_word": [ + 54 + ], + "coefficient": "-1" + }, + { + "target": 181, + "source": 385, + "operator_word": [ + 57 + ], + "coefficient": "-1" + }, + { + "target": 181, + "source": 373, + "operator_word": [ + 47 + ], + "coefficient": "-1" + }, + { + "target": 183, + "source": 325, + "operator_word": [ + 28 + ], + "coefficient": "1/2" + }, + { + "target": 183, + "source": 330, + "operator_word": [ + 29 + ], + "coefficient": "1/2" + }, + { + "target": 188, + "source": 291, + "operator_word": [ + 19 + ], + "coefficient": "1/2" + }, + { + "target": 188, + "source": 289, + "operator_word": [ + 20 + ], + "coefficient": "1/2" + }, + { + "target": 190, + "source": 277, + "operator_word": [ + 10 + ], + "coefficient": "-1" + }, + { + "target": 190, + "source": 282, + "operator_word": [ + 11 + ], + "coefficient": "-1" + }, + { + "target": 193, + "source": 298, + "operator_word": [ + 18 + ], + "coefficient": "1/2" + }, + { + "target": 193, + "source": 289, + "operator_word": [ + 20 + ], + "coefficient": "1/2" + }, + { + "target": 199, + "source": 298, + "operator_word": [ + 18 + ], + "coefficient": "1/2" + }, + { + "target": 199, + "source": 314, + "operator_word": [ + 23 + ], + "coefficient": "1/2" + }, + { + "target": 202, + "source": 305, + "operator_word": [ + 25 + ], + "coefficient": "1/2" + }, + { + "target": 202, + "source": 323, + "operator_word": [ + 30 + ], + "coefficient": "1/2" + }, + { + "target": 204, + "source": 291, + "operator_word": [ + 19 + ], + "coefficient": "1/2" + }, + { + "target": 204, + "source": 314, + "operator_word": [ + 23 + ], + "coefficient": "-1/2" + }, + { + "target": 208, + "source": 387, + "operator_word": [ + 56 + ], + "coefficient": "-1" + }, + { + "target": 208, + "source": 373, + "operator_word": [ + 47 + ], + "coefficient": "1" + }, + { + "target": 211, + "source": 321, + "operator_word": [ + 31 + ], + "coefficient": "-1" + }, + { + "target": 211, + "source": 307, + "operator_word": [ + 24 + ], + "coefficient": "-1" + }, + { + "target": 214, + "source": 378, + "operator_word": [ + 48 + ], + "coefficient": "1/2" + }, + { + "target": 214, + "source": 394, + "operator_word": [ + 55 + ], + "coefficient": "-1" + }, + { + "target": 216, + "source": 321, + "operator_word": [ + 31 + ], + "coefficient": "-1" + }, + { + "target": 216, + "source": 282, + "operator_word": [ + 11 + ], + "coefficient": "-1" + }, + { + "target": 218, + "source": 353, + "operator_word": [ + 44 + ], + "coefficient": "-1" + }, + { + "target": 218, + "source": 357, + "operator_word": [ + 41 + ], + "coefficient": "-1" + }, + { + "target": 222, + "source": 275, + "operator_word": [ + 12 + ], + "coefficient": "-1" + }, + { + "target": 222, + "source": 309, + "operator_word": [ + 22 + ], + "coefficient": "-1" + } + ] +} diff --git a/research/t74-low-alias-borrowing/inputs/blocks.json b/research/t74-low-alias-borrowing/inputs/blocks.json new file mode 100644 index 0000000000..c683574b38 --- /dev/null +++ b/research/t74-low-alias-borrowing/inputs/blocks.json @@ -0,0 +1 @@ +{"sources": [{"blocks": [{"Q": [["0", "-1/2", "-1/2", "0", "0", "-1/2", "-1/2", "0"], ["-1/2", "0", "-1/2", "0", "0", "1/2", "0", "1/2"], ["-1/2", "0", "0", "-1/2", "-1/2", "0", "0", "-1/2"], ["0", "-1/2", "0", "-1/2", "1/2", "0", "1/2", "0"]], "R": [["0", "-1/2", "-1/2", "0"], ["-1/2", "0", "-1/2", "0"], ["-1/2", "0", "0", "-1/2"], ["0", "-1/2", "0", "1/2"]], "base": 592, "common_frame": [320, 192, 45, 30], "common_rank": 4, "first_correction": 433, "first_input": 1061, "helpers": [592, 593, 594, 595, 596, 597, 598, 599], "high": [595, 597, 598, 599], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1", "initial_scalar_columns": [1, 3, 8, 12, 17, 22, 28, 32, 592, 593, 594, 595, 596, 597, 598, 599], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [592, 593, 594, 595, 596, 597, 598, 599, 283, 100, 315, 48, 347, 82, 379, 67], "removed_correction_indices": [420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431], "scalar_prefix_length": 4669}, "input_arrays": [283, 100, 315, 48, 347, 82, 379, 67], "input_frames": [[271, 143, 79, 45, 30], [320, 192, 41, 26, 4], [320, 192, 44, 30, 1], [266, 138, 74, 45, 30], [262, 134, 70, 45, 30], [320, 192, 32, 19, 13], [320, 192, 37, 22, 8], [259, 131, 67, 45, 30]], "input_gate_indices": [1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [592, 593, 594, 596], "output_entry_indices": [1420, 1417, 1416, 1421], "output_gate_indices": [1416, 1417, 1420, 1421, 1424, 1425, 1428, 1429], "profile": {"1": 24, "2": 8, "3": 4}, "rank_seven_kernel_frames": [{"eligible_targets": [], "frame": [271, 143, 79, 45, 30, 4, 1], "indices": [0, 1, 2, 3]}, {"eligible_targets": [], "frame": [271, 143, 79, 45, 30, 9, 4], "indices": [0, 1, 4, 5]}, {"eligible_targets": [], "frame": [271, 143, 79, 45, 30, 9, 1], "indices": [0, 2, 4, 6]}, {"eligible_targets": [193], "frame": [271, 143, 79, 45, 30, 13, 1], "indices": [0, 2, 5, 7]}, {"eligible_targets": [199], "frame": [271, 143, 79, 45, 30, 9, 5], "indices": [0, 3, 4, 7]}, {"eligible_targets": [], "frame": [271, 143, 79, 45, 30, 13, 5], "indices": [0, 3, 5, 6]}, {"eligible_targets": [], "frame": [320, 192, 70, 41, 26, 4, 1], "indices": [1, 2, 4, 7]}, {"eligible_targets": [188], "frame": [320, 192, 41, 26, 9, 4, 1], "indices": [1, 2, 5, 6]}, {"eligible_targets": [204], "frame": [320, 192, 74, 41, 26, 12, 4], "indices": [1, 3, 4, 6]}, {"eligible_targets": [], "frame": [320, 192, 74, 41, 26, 9, 4], "indices": [1, 3, 5, 7]}, {"eligible_targets": [], "frame": [320, 192, 74, 44, 30, 9, 1], "indices": [2, 3, 6, 7]}, {"eligible_targets": [], "frame": [262, 134, 70, 45, 30, 13, 5], "indices": [4, 5, 6, 7]}], "subset_spectrum": [{"count": 8, "frame_rank": 5, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 6, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 7, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 7, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 7, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 8, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 8, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 8, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 8, "matrix_rank": 4, "size": 8}], "target_arrays": [188, 193, 199, 204], "target_caps": [[320, 192, 32, 16, 8, 4, 2, 1], [258, 130, 66, 32, 18, 10, 6, 1], [257, 129, 65, 33, 16, 9, 5, 2], [257, 129, 65, 33, 17, 8, 4, 3]], "target_entry_frames": [[320, 192, 33, 16, 9, 5, 2], [258, 130, 66, 33, 18, 11, 7], [320, 192, 33, 16, 9, 5, 2], [258, 130, 66, 33, 18, 11, 7]]}, {"Q": [["-1/2", "0", "-1/2", "0", "0", "1/2", "0", "1/2"], ["0", "-1/2", "0", "-1/2", "1/2", "0", "1/2", "0"], ["0", "-1/2", "-1/2", "0", "0", "-1/2", "-1/2", "0"], ["-1/2", "0", "0", "-1/2", "-1/2", "0", "0", "-1/2"]], "R": [["-1/2", "0", "-1/2", "0"], ["0", "-1/2", "0", "1/2"], ["0", "-1/2", "-1/2", "0"], ["-1/2", "0", "0", "-1/2"]], "base": 600, "common_frame": [409, 80, 40, 5, 2], "common_rank": 5, "first_correction": 409, "first_input": 1069, "helpers": [600, 601, 602, 603, 604, 605, 606, 607], "high": [603, 605, 606, 607], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1", "initial_scalar_columns": [1, 4, 5, 6, 12, 18, 19, 24, 600, 601, 602, 603, 604, 605, 606, 607], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [600, 601, 602, 603, 604, 605, 606, 607, 279, 274, 295, 290, 343, 338, 359, 354], "removed_correction_indices": [396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407], "scalar_prefix_length": 4677}, "input_arrays": [279, 274, 295, 290, 343, 338, 359, 354], "input_frames": [[385, 72, 40, 24, 5, 2], [408, 80, 40, 4, 2, 1], [273, 136, 80, 40, 5, 2], [264, 145, 80, 40, 5, 2], [392, 65, 40, 17, 5, 2], [401, 80, 32, 8, 5, 2], [280, 129, 80, 40, 5, 2], [257, 152, 80, 40, 5, 2]], "input_gate_indices": [1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [600, 601, 602, 604], "output_entry_indices": [1449, 1453, 1452, 1448], "output_gate_indices": [1448, 1449, 1452, 1453, 1456, 1457, 1460, 1461], "profile": {"1": 32, "4": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [123, 175, 183, 202], "target_caps": [[257, 128, 64, 32, 16, 8, 5, 2], [264, 128, 64, 40, 16, 4, 2, 1], [272, 128, 80, 32, 8, 4, 2, 1], [257, 128, 65, 33, 17, 9, 5, 2]], "target_entry_frames": [[265, 128, 64, 40, 16, 5, 2], [265, 128, 64, 40, 16, 5, 2], [272, 128, 80, 33, 9, 5, 2], [272, 128, 80, 33, 9, 5, 2]]}, {"Q": [["0", "-1/2", "-1/2", "0", "0", "-1/2", "-1/2", "0"], ["-1/2", "0", "-1/2", "0", "0", "1/2", "0", "1/2"], ["-1/2", "0", "0", "-1/2", "-1/2", "0", "0", "-1/2"], ["0", "-1/2", "0", "-1/2", "1/2", "0", "1/2", "0"]], "R": [["0", "-1/2", "-1/2", "0"], ["-1/2", "0", "-1/2", "0"], ["-1/2", "0", "0", "-1/2"], ["0", "-1/2", "0", "1/2"]], "base": 608, "common_frame": [272, 144, 75, 42, 7], "common_rank": 5, "first_correction": 421, "first_input": 1077, "helpers": [608, 609, 610, 611, 612, 613, 614, 615], "high": [611, 613, 614, 615], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "-1", "initial_scalar_columns": [1, 3, 6, 12, 17, 18, 26, 35, 608, 609, 610, 611, 612, 613, 614, 615], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [608, 609, 610, 611, 612, 613, 614, 615, 278, 276, 294, 292, 358, 356, 342, 340], "removed_correction_indices": [408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419], "scalar_prefix_length": 4685}, "input_arrays": [278, 276, 294, 292, 358, 356, 342, 340], "input_frames": [[266, 138, 75, 42, 26, 7], [272, 144, 72, 41, 4, 3], [264, 136, 75, 42, 24, 7], [272, 144, 74, 42, 6, 1], [257, 129, 75, 42, 17, 7], [272, 144, 67, 34, 8, 7], [259, 131, 75, 42, 19, 7], [272, 144, 65, 32, 10, 7]], "input_gate_indices": [1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [608, 609, 610, 612], "output_entry_indices": [1484, 1481, 1480, 1485], "output_gate_indices": [1480, 1481, 1484, 1485, 1488, 1489, 1492, 1493], "profile": {"1": 32, "4": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [114, 121, 137, 173], "target_caps": [[256, 128, 64, 33, 16, 8, 4, 3], [256, 128, 65, 32, 16, 8, 5, 2], [256, 128, 64, 32, 16, 10, 6, 1], [256, 128, 72, 40, 16, 4, 2, 1]], "target_entry_frames": [[256, 128, 64, 33, 16, 11, 7], [256, 128, 73, 40, 16, 5, 2], [256, 128, 64, 33, 16, 11, 7], [256, 128, 73, 40, 16, 5, 2]]}, {"Q": [["0", "-1/2", "0", "-1/2", "-1", "0", "-1", "0"], ["-1/2", "0", "-1/2", "0", "0", "-1", "0", "-1"], ["0", "-1/2", "-1/2", "0", "0", "1", "1", "0"], ["-1/2", "0", "0", "-1/2", "1", "0", "0", "1"]], "R": [["0", "-1/2", "0", "-1"], ["-1/2", "0", "-1/2", "0"], ["0", "-1/2", "-1/2", "0"], ["-1/2", "0", "0", "1"]], "base": 624, "common_frame": [391, 68, 34, 17, 8], "common_rank": 5, "first_correction": 397, "first_input": 1093, "helpers": [624, 625, 626, 627, 628, 629, 630, 631], "high": [627, 629, 630, 631], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1/16", "initial_scalar_columns": [1, 2, 6, 10, 11, 14, 15, 24, 624, 625, 626, 627, 628, 629, 630, 631], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [624, 625, 626, 627, 628, 629, 630, 631, 246, 244, 262, 260, 360, 60, 348, 350], "removed_correction_indices": [384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395], "scalar_prefix_length": 4701}, "input_arrays": [246, 244, 262, 260, 360, 60, 348, 350], "input_frames": [[261, 130, 68, 34, 17, 8], [258, 133, 68, 34, 17, 8], [390, 68, 34, 16, 8, 1], [385, 66, 34, 17, 8, 6], [262, 129, 68, 34, 17, 8], [257, 134, 68, 34, 17, 8], [389, 68, 32, 17, 8, 2], [386, 65, 34, 17, 8, 5]], "input_gate_indices": [1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [624, 625, 626, 628], "output_entry_indices": [1549, 1545, 1548, 1544], "output_gate_indices": [1544, 1545, 1548, 1549, 1552, 1553, 1556, 1557], "profile": {"1": 32, "4": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [130, 151, 166, 214], "target_caps": [[256, 129, 64, 32, 17, 8, 4, 2], [256, 130, 64, 34, 16, 8, 4, 1], [256, 132, 68, 32, 16, 8, 2, 1], [256, 129, 65, 33, 17, 8, 5, 3]], "target_entry_frames": [[256, 131, 64, 34, 17, 8, 4], [256, 131, 64, 34, 17, 8, 4], [256, 132, 68, 33, 17, 8, 3], [256, 132, 68, 33, 17, 8, 3]]}, {"Q": [["-1/2", "0", "0", "-1/2", "1", "0", "0", "1"], ["-1/2", "0", "-1/2", "0", "0", "-1", "0", "-1"], ["0", "-1/2", "0", "-1/2", "-1", "0", "-1", "0"], ["0", "-1/2", "-1/2", "0", "0", "1", "1", "0"]], "R": [["-1/2", "0", "0", "1"], ["-1/2", "0", "-1/2", "0"], ["0", "-1/2", "0", "-1"], ["0", "-1/2", "-1/2", "0"]], "base": 632, "common_frame": [257, 129, 76, 42, 30], "common_rank": 5, "first_correction": 385, "first_input": 1101, "helpers": [632, 633, 634, 635, 636, 637, 638, 639], "high": [635, 637, 638, 639], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1/16", "initial_scalar_columns": [2, 3, 4, 10, 12, 13, 14, 18, 632, 633, 634, 635, 636, 637, 638, 639], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [632, 633, 634, 635, 636, 637, 638, 639, 456, 457, 466, 467, 376, 66, 396, 398], "removed_correction_indices": [372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383], "scalar_prefix_length": 4709}, "input_arrays": [456, 457, 466, 467, 376, 66, 396, 398], "input_frames": [[257, 129, 72, 42, 26, 4], [257, 129, 76, 41, 29, 3], [257, 129, 69, 35, 23, 9], [257, 129, 66, 36, 16, 14], [257, 129, 67, 37, 17, 15], [257, 129, 68, 34, 22, 8], [257, 129, 76, 40, 28, 2], [257, 129, 73, 42, 27, 5]], "input_gate_indices": [1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [632, 633, 634, 636], "output_entry_indices": [1576, 1577, 1581, 1580], "output_gate_indices": [1576, 1577, 1580, 1581, 1584, 1585, 1588, 1589], "profile": {"1": 32, "4": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [144, 147, 157, 160], "target_caps": [[256, 128, 66, 32, 16, 10, 4, 1], [256, 128, 64, 34, 18, 8, 4, 1], [256, 128, 64, 36, 16, 12, 2, 1], [256, 128, 68, 32, 20, 8, 2, 1]], "target_entry_frames": [[256, 128, 70, 32, 20, 10, 1], [256, 128, 64, 38, 18, 12, 1], [256, 128, 64, 38, 18, 12, 1], [256, 128, 70, 32, 20, 10, 1]]}, {"Q": [["-1/2", "0", "-1/2", "0", "0", "-1", "0", "-1"], ["0", "-1/2", "-1/2", "0", "0", "1", "1", "0"], ["-1/2", "0", "0", "-1/2", "1", "0", "0", "1"], ["0", "-1/2", "0", "-1/2", "-1", "0", "-1", "0"]], "R": [["-1/2", "0", "-1/2", "0"], ["0", "-1/2", "-1/2", "0"], ["-1/2", "0", "0", "1"], ["0", "-1/2", "0", "-1"]], "base": 640, "common_frame": [423, 65, 20, 10], "common_rank": 4, "first_correction": 373, "first_input": 1109, "helpers": [640, 641, 642, 643, 644, 645, 646, 647], "high": [643, 645, 646, 647], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1/16", "initial_scalar_columns": [2, 3, 4, 5, 8, 9, 10, 11, 640, 641, 642, 643, 644, 645, 646, 647], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [640, 641, 642, 643, 644, 645, 646, 647, 458, 459, 464, 465, 392, 97, 380, 382], "removed_correction_indices": [360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371], "scalar_prefix_length": 4717}, "input_arrays": [458, 459, 464, 465, 392, 97, 380, 382], "input_frames": [[261, 130, 65, 32, 20, 10], [258, 133, 65, 32, 20, 10], [387, 65, 32, 16, 10, 4], [388, 65, 32, 20, 9, 3], [260, 131, 65, 32, 20, 10], [259, 132, 65, 32, 20, 10], [386, 65, 32, 17, 10, 5], [389, 65, 32, 20, 8, 2]], "input_gate_indices": [1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [640, 641, 642, 644], "output_entry_indices": [1609, 1612, 1608, 1613], "output_gate_indices": [1608, 1609, 1612, 1613, 1616, 1617, 1620, 1621], "profile": {"1": 24, "2": 8, "3": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [135, 146, 162, 220], "target_caps": [[257, 128, 65, 32, 16, 8, 4, 2], [258, 128, 64, 32, 16, 10, 4, 1], [260, 128, 64, 32, 20, 8, 2, 1], [257, 128, 65, 32, 17, 9, 5, 3]], "target_entry_frames": [[257, 128, 65, 32, 18, 10, 6], [262, 128, 64, 32, 20, 10, 1], [262, 128, 64, 32, 20, 10, 1], [257, 128, 65, 32, 18, 10, 6]]}, {"Q": [["1", "0", "0", "1", "1", "0", "0", "1"], ["0", "1", "1", "0", "0", "1", "1", "0"], ["1", "0", "1", "0", "0", "-1", "0", "-1"], ["0", "1", "0", "1", "-1", "0", "-1", "0"]], "R": [["1", "0", "0", "1"], ["0", "1", "1", "0"], ["1", "0", "1", "0"], ["0", "1", "0", "-1"]], "base": 648, "common_frame": [288, 160, 75, 25, 7], "common_rank": 5, "first_correction": 445, "first_input": 1117, "helpers": [648, 649, 650, 651, 652, 653, 654, 655], "high": [651, 653, 654, 655], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1/256", "initial_scalar_columns": [2, 3, 8, 9, 12, 13, 16, 17, 648, 649, 650, 651, 652, 653, 654, 655], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [648, 649, 650, 651, 652, 653, 654, 655, 248, 10, 268, 270, 280, 38, 300, 302], "removed_correction_indices": [432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443], "scalar_prefix_length": 4725}, "input_arrays": [248, 10, 268, 270, 280, 38, 300, 302], "input_frames": [[288, 160, 67, 17, 8, 7], [258, 130, 75, 34, 25, 7], [259, 131, 75, 35, 25, 7], [288, 160, 66, 16, 9, 7], [288, 160, 72, 25, 4, 3], [265, 137, 75, 41, 25, 7], [264, 136, 75, 40, 25, 7], [288, 160, 73, 25, 5, 2]], "input_gate_indices": [1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [648, 649, 650, 652], "output_entry_indices": [1640, 1644, 1641, 1645], "output_gate_indices": [1640, 1641, 1644, 1645, 1648, 1649, 1652, 1653], "profile": {"1": 32, "4": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [187, 194, 198, 205], "target_caps": [[288, 160, 64, 16, 8, 4, 2, 1], [258, 130, 64, 34, 18, 10, 6, 1], [257, 129, 65, 33, 17, 8, 5, 2], [257, 129, 65, 33, 16, 9, 4, 3]], "target_entry_frames": [[288, 160, 64, 18, 10, 6, 1], [288, 160, 64, 18, 10, 6, 1], [257, 129, 65, 33, 19, 10, 7], [257, 129, 65, 33, 19, 10, 7]]}, {"Q": [["1", "0", "1", "0", "0", "-1", "0", "-1"], ["0", "1", "0", "1", "-1", "0", "-1", "0"], ["0", "1", "1", "0", "0", "1", "1", "0"], ["1", "0", "0", "1", "1", "0", "0", "1"]], "R": [["1", "0", "1", "0"], ["0", "1", "0", "-1"], ["0", "1", "1", "0"], ["1", "0", "0", "1"]], "base": 656, "common_frame": [427, 96, 24, 6], "common_rank": 4, "first_correction": 361, "first_input": 1125, "helpers": [656, 657, 658, 659, 660, 661, 662, 663], "high": [659, 661, 662, 663], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "-1/256", "initial_scalar_columns": [2, 4, 5, 12, 14, 15, 25, 31, 656, 657, 658, 659, 660, 661, 662, 663], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [656, 657, 658, 659, 660, 661, 662, 663, 252, 254, 264, 79, 296, 19, 284, 286], "removed_correction_indices": [348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359], "scalar_prefix_length": 4733}, "input_arrays": [252, 254, 264, 79, 296, 19, 284, 286], "input_frames": [[296, 130, 96, 24, 6, 1], [258, 168, 96, 24, 6, 1], [418, 96, 16, 8, 6, 1], [392, 66, 34, 24, 6, 1], [290, 136, 96, 24, 6, 1], [264, 162, 96, 24, 6, 1], [424, 96, 24, 4, 2, 1], [386, 72, 40, 24, 6, 1]], "input_gate_indices": [1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [656, 657, 658, 660], "output_entry_indices": [1673, 1677, 1676, 1672], "output_gate_indices": [1672, 1673, 1676, 1677, 1680, 1681, 1684, 1685], "profile": {"1": 24, "2": 8, "3": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [141, 171, 185, 196], "target_caps": [[256, 130, 64, 32, 16, 8, 6, 1], [256, 136, 64, 32, 24, 4, 2, 1], [256, 160, 96, 16, 8, 4, 2, 1], [256, 130, 66, 34, 18, 10, 6, 1]], "target_entry_frames": [[256, 138, 64, 32, 24, 6, 1], [256, 138, 64, 32, 24, 6, 1], [256, 160, 96, 18, 10, 6, 1], [256, 160, 96, 18, 10, 6, 1]]}, {"Q": [["0", "1", "1", "0", "0", "1", "1", "0"], ["1", "0", "1", "0", "0", "-1", "0", "-1"], ["1", "0", "0", "1", "1", "0", "0", "1"], ["0", "1", "0", "1", "-1", "0", "-1", "0"]], "R": [["0", "1", "1", "0"], ["1", "0", "1", "0"], ["1", "0", "0", "1"], ["0", "1", "0", "-1"]], "base": 672, "common_frame": [413, 72, 48, 3], "common_rank": 4, "first_correction": 297, "first_input": 1141, "helpers": [672, 673, 674, 675, 676, 677, 678, 679], "high": [675, 677, 678, 679], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1/256", "initial_scalar_columns": [1, 6, 10, 11, 13, 14, 15, 24, 672, 673, 674, 675, 676, 677, 678, 679], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [672, 673, 674, 675, 676, 677, 678, 679, 462, 463, 470, 471, 328, 109, 316, 318], "removed_correction_indices": [283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294], "scalar_prefix_length": 4749}, "input_arrays": [462, 463, 470, 471, 328, 109, 316, 318], "input_frames": [[280, 129, 72, 48, 4, 3], [257, 152, 72, 48, 4, 3], [393, 72, 32, 16, 4, 3], [400, 65, 48, 9, 4, 3], [272, 137, 72, 48, 4, 3], [265, 144, 72, 48, 4, 3], [385, 72, 40, 24, 4, 3], [408, 72, 48, 4, 2, 1]], "input_gate_indices": [1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [672, 673, 674, 676], "output_entry_indices": [1740, 1737, 1736, 1741], "output_gate_indices": [1736, 1737, 1740, 1741, 1744, 1745, 1748, 1749], "profile": {"1": 24, "2": 8, "3": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [117, 177, 181, 208], "target_caps": [[257, 128, 64, 32, 16, 8, 4, 3], [264, 128, 72, 32, 16, 4, 2, 1], [272, 128, 64, 48, 8, 4, 2, 1], [257, 128, 65, 33, 17, 9, 4, 3]], "target_entry_frames": [[273, 128, 64, 48, 8, 4, 3], [264, 128, 72, 33, 17, 4, 3], [273, 128, 64, 48, 8, 4, 3], [264, 128, 72, 33, 17, 4, 3]]}, {"Q": [["0", "1", "1", "0", "0", "1", "1", "0"], ["0", "1", "0", "1", "-1", "0", "-1", "0"], ["1", "0", "0", "1", "1", "0", "0", "1"], ["1", "0", "1", "0", "0", "-1", "0", "-1"]], "R": [["0", "1", "1", "0"], ["0", "1", "0", "-1"], ["1", "0", "0", "1"], ["1", "0", "1", "0"]], "base": 680, "common_frame": [407, 66, 36, 9], "common_rank": 4, "first_correction": 309, "first_input": 1149, "helpers": [680, 681, 682, 683, 684, 685, 686, 687], "high": [683, 685, 686, 687], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1/256", "initial_scalar_columns": [1, 3, 4, 5, 6, 18, 19, 24, 680, 681, 682, 683, 684, 685, 686, 687], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [680, 681, 682, 683, 684, 685, 686, 687, 478, 479, 490, 491, 502, 503, 514, 515], "removed_correction_indices": [295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306], "scalar_prefix_length": 4757}, "input_arrays": [478, 479, 490, 491, 502, 503, 514, 515], "input_frames": [[388, 65, 36, 16, 9, 3], [387, 66, 32, 16, 9, 4], [262, 129, 66, 36, 16, 9], [257, 134, 66, 36, 16, 9], [390, 66, 36, 16, 8, 1], [385, 66, 34, 16, 9, 6], [260, 131, 66, 36, 16, 9], [259, 132, 66, 36, 16, 9]], "input_gate_indices": [1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [680, 681, 682, 684], "output_entry_indices": [1772, 1773, 1768, 1769], "output_gate_indices": [1768, 1769, 1772, 1773, 1776, 1777, 1780, 1781], "profile": {"1": 24, "2": 8, "3": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [126, 153, 164, 218], "target_caps": [[256, 129, 64, 32, 16, 9, 4, 2], [256, 130, 66, 32, 16, 8, 4, 1], [256, 132, 64, 36, 16, 8, 2, 1], [256, 129, 65, 33, 16, 9, 5, 3]], "target_entry_frames": [[256, 133, 64, 36, 16, 9, 2], [256, 130, 66, 33, 16, 9, 5], [256, 133, 64, 36, 16, 9, 2], [256, 130, 66, 33, 16, 9, 5]]}, {"Q": [["0", "1", "0", "1", "-1", "0", "-1", "0"], ["0", "1", "1", "0", "0", "1", "1", "0"], ["1", "0", "0", "1", "1", "0", "0", "1"], ["1", "0", "1", "0", "0", "-1", "0", "-1"]], "R": [["0", "1", "0", "-1"], ["0", "1", "1", "0"], ["1", "0", "0", "1"], ["1", "0", "1", "0"]], "base": 688, "common_frame": [258, 130, 85, 45], "common_rank": 4, "first_correction": 333, "first_input": 1157, "helpers": [688, 689, 690, 691, 692, 693, 694, 695], "high": [691, 693, 694, 695], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "1/256", "initial_scalar_columns": [1, 3, 4, 6, 8, 12, 31, 32, 688, 689, 690, 691, 692, 693, 694, 695], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [688, 689, 690, 691, 692, 693, 694, 695, 480, 481, 492, 493, 516, 517, 504, 505], "removed_correction_indices": [319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330], "scalar_prefix_length": 4765}, "input_arrays": [480, 481, 492, 493, 516, 517, 504, 505], "input_frames": [[257, 129, 76, 45, 25, 3], [258, 130, 72, 41, 25, 4], [258, 130, 70, 39, 19, 10], [258, 130, 65, 32, 20, 13], [258, 130, 68, 37, 17, 8], [258, 130, 67, 34, 22, 15], [258, 130, 76, 44, 24, 1], [258, 130, 74, 43, 25, 6]], "input_gate_indices": [1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [688, 689, 690, 692], "output_entry_indices": [1805, 1804, 1800, 1801], "output_gate_indices": [1800, 1801, 1804, 1805, 1808, 1809, 1812, 1813], "profile": {"1": 24, "2": 8, "3": 4}, "rank_seven_kernel_frames": [], "subset_spectrum": [{"count": 8, "frame_rank": 6, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 7, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 8, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 8, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 9, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 9, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 9, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 9, "matrix_rank": 4, "size": 8}], "target_arrays": [155, 190, 211, 216], "target_caps": [[258, 130, 64, 32, 16, 8, 4, 1], [258, 130, 66, 34, 18, 10, 4, 1], [257, 129, 65, 32, 17, 8, 5, 3], [257, 129, 64, 33, 16, 9, 5, 3]], "target_entry_frames": [[258, 130, 64, 33, 16, 9, 5], [258, 130, 66, 35, 18, 11, 5], [258, 130, 66, 35, 18, 11, 5], [258, 130, 64, 33, 16, 9, 5]]}, {"Q": [["0", "1", "1", "0", "0", "1", "1", "0"], ["0", "1", "0", "1", "-1", "0", "-1", "0"], ["1", "0", "0", "1", "1", "0", "0", "1"], ["1", "0", "1", "0", "0", "-1", "0", "-1"]], "R": [["0", "1", "1", "0"], ["0", "1", "0", "-1"], ["1", "0", "0", "1"], ["1", "0", "1", "0"]], "base": 696, "common_frame": [455, 33, 18, 12], "common_rank": 4, "first_correction": 321, "first_input": 1165, "helpers": [696, 697, 698, 699, 700, 701, 702, 703], "high": [699, 701, 702, 703], "independence_witness": {"boundary": "before-inputs-with-helper-correction-deferred", "determinant": "-1/256", "initial_scalar_columns": [1, 3, 4, 5, 8, 22, 23, 24, 696, 697, 698, 699, 700, 701, 702, 703], "minor": [["0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"]], "registers": [696, 697, 698, 699, 700, 701, 702, 703, 482, 483, 506, 507, 518, 519, 494, 495], "removed_correction_indices": [307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318], "scalar_prefix_length": 4773}, "input_arrays": [482, 483, 506, 507, 518, 519, 494, 495], "input_frames": [[388, 67, 33, 18, 12], [451, 33, 18, 8, 4], [385, 70, 33, 18, 12], [454, 32, 18, 12, 1], [262, 193, 33, 18, 12], [321, 134, 33, 18, 12], [259, 196, 33, 18, 12], [324, 131, 33, 18, 12]], "input_gate_indices": [1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165], "kernel_projection_ranks": [{"count": 8, "rank": 1, "size": 1}, {"count": 28, "rank": 2, "size": 2}, {"count": 56, "rank": 3, "size": 3}, {"count": 12, "rank": 3, "size": 4}, {"count": 58, "rank": 4, "size": 4}], "low": [696, 697, 698, 700], "output_entry_indices": [1836, 1837, 1832, 1833], "output_gate_indices": [1832, 1833, 1836, 1837, 1840, 1841, 1844, 1845], "profile": {"1": 24, "2": 8, "3": 4}, "rank_seven_kernel_frames": [{"eligible_targets": [], "frame": [388, 67, 33, 18, 12, 4, 1], "indices": [0, 1, 2, 3]}, {"eligible_targets": [], "frame": [388, 130, 67, 33, 18, 12, 4], "indices": [0, 1, 4, 5]}, {"eligible_targets": [], "frame": [388, 130, 67, 33, 18, 12, 5], "indices": [0, 2, 4, 6]}, {"eligible_targets": [222], "frame": [388, 197, 67, 33, 18, 12, 5], "indices": [0, 2, 5, 7]}, {"eligible_targets": [159], "frame": [388, 130, 67, 33, 18, 12, 1], "indices": [0, 3, 4, 7]}, {"eligible_targets": [], "frame": [388, 197, 67, 33, 18, 12, 1], "indices": [0, 3, 5, 6]}, {"eligible_targets": [], "frame": [451, 197, 66, 33, 18, 8, 4], "indices": [1, 2, 4, 7]}, {"eligible_targets": [133], "frame": [451, 130, 66, 33, 18, 8, 4], "indices": [1, 2, 5, 6]}, {"eligible_targets": [149], "frame": [451, 197, 33, 18, 8, 4, 1], "indices": [1, 3, 4, 6]}, {"eligible_targets": [], "frame": [451, 130, 33, 18, 8, 4, 1], "indices": [1, 3, 5, 7]}, {"eligible_targets": [], "frame": [385, 130, 70, 33, 18, 12, 1], "indices": [2, 3, 6, 7]}, {"eligible_targets": [], "frame": [262, 193, 71, 33, 18, 12, 5], "indices": [4, 5, 6, 7]}], "subset_spectrum": [{"count": 8, "frame_rank": 5, "matrix_rank": 1, "size": 1}, {"count": 28, "frame_rank": 6, "matrix_rank": 2, "size": 2}, {"count": 56, "frame_rank": 7, "matrix_rank": 3, "size": 3}, {"count": 12, "frame_rank": 7, "matrix_rank": 3, "size": 4}, {"count": 2, "frame_rank": 7, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 8, "matrix_rank": 4, "size": 4}, {"count": 56, "frame_rank": 8, "matrix_rank": 4, "size": 5}, {"count": 28, "frame_rank": 8, "matrix_rank": 4, "size": 6}, {"count": 8, "frame_rank": 8, "matrix_rank": 4, "size": 7}, {"count": 1, "frame_rank": 8, "matrix_rank": 4, "size": 8}], "target_arrays": [133, 149, 159, 222], "target_caps": [[257, 128, 64, 33, 16, 8, 4, 2], [258, 128, 64, 32, 18, 8, 4, 1], [260, 128, 64, 32, 16, 12, 2, 1], [257, 128, 64, 33, 17, 9, 5, 3]], "target_entry_frames": [[261, 128, 64, 33, 16, 12, 2], [258, 128, 64, 33, 18, 9, 5], [261, 128, 64, 33, 16, 12, 2], [258, 128, 64, 33, 18, 9, 5]]}]}]} \ No newline at end of file diff --git a/research/t74-low-alias-borrowing/inputs/extra.canonical.json.gz b/research/t74-low-alias-borrowing/inputs/extra.canonical.json.gz new file mode 100644 index 0000000000..e0d670d435 Binary files /dev/null and b/research/t74-low-alias-borrowing/inputs/extra.canonical.json.gz differ diff --git a/research/t74-low-alias-borrowing/inputs/gauge44.canonical.json.gz b/research/t74-low-alias-borrowing/inputs/gauge44.canonical.json.gz new file mode 100644 index 0000000000..4abb6e28f0 Binary files /dev/null and b/research/t74-low-alias-borrowing/inputs/gauge44.canonical.json.gz differ diff --git a/research/t74-low-alias-borrowing/inputs/witness_43_base.json b/research/t74-low-alias-borrowing/inputs/witness_43_base.json new file mode 100644 index 0000000000..9f4b93f3bc --- /dev/null +++ b/research/t74-low-alias-borrowing/inputs/witness_43_base.json @@ -0,0 +1 @@ +{"credit": "#2226 anticipatory dirty borrowing (Cinna Davis / 1337isnot1337), adapted to T74 words", "variant": "43_base", "pairs": [{"register": 597, "base": 592, "common_basis": [320, 192, 45, 30], "dimension": 4, "deadline": 1061, "deleted_echo_indices": [], "low": false, "borrow_from": 243, "retirement_B_event": -1, "retirement_frame": 66, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1061, "handoff_basis": [320, 192, 45, 30], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [261, 133, 85, 45]}, {"register": 643, "base": 640, "common_basis": [423, 65, 20, 10], "dimension": 4, "deadline": 1109, "deleted_echo_indices": [], "low": false, "borrow_from": 250, "retirement_B_event": -1, "retirement_frame": 66, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1109, "handoff_basis": [486, 65, 20, 10], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [261, 133, 85, 45]}, {"register": 645, "base": 640, "common_basis": [423, 65, 20, 10], "dimension": 4, "deadline": 1109, "deleted_echo_indices": [], "low": false, "borrow_from": 266, "retirement_B_event": -1, "retirement_frame": 95, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1109, "handoff_basis": [486, 65, 20, 10], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [400, 69, 35, 14]}, {"register": 646, "base": 640, "common_basis": [423, 65, 20, 10], "dimension": 4, "deadline": 1109, "deleted_echo_indices": [], "low": false, "borrow_from": 259, "retirement_B_event": -1, "retirement_frame": 95, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1109, "handoff_basis": [486, 65, 20, 10], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [400, 69, 35, 14]}, {"register": 659, "base": 656, "common_basis": [427, 96, 24, 6], "dimension": 4, "deadline": 1125, "deleted_echo_indices": [], "low": false, "borrow_from": 333, "retirement_B_event": 788, "retirement_frame": 211, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1125, "handoff_basis": [459, 96, 24, 6], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [266, 138, 75, 30]}, {"register": 661, "base": 656, "common_basis": [427, 96, 24, 6], "dimension": 4, "deadline": 1125, "deleted_echo_indices": [], "low": false, "borrow_from": 317, "retirement_B_event": 769, "retirement_frame": 182, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1125, "handoff_basis": [459, 96, 24, 6], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [385, 74, 44, 30]}, {"register": 651, "base": 648, "common_basis": [288, 160, 75, 25, 7], "dimension": 5, "deadline": 1117, "deleted_echo_indices": [], "low": false, "borrow_from": 554, "retirement_B_event": 1053, "retirement_frame": 734, "retirement_dimension": 5, "old_final_dimension": 8, "handoff_B": 1117, "handoff_basis": [384, 160, 75, 25, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [388, 67, 33, 18, 12]}, {"register": 683, "base": 680, "common_basis": [407, 66, 36, 9], "dimension": 4, "deadline": 1149, "deleted_echo_indices": [], "low": false, "borrow_from": 285, "retirement_B_event": 733, "retirement_frame": 124, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1149, "handoff_basis": [469, 66, 36, 9], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [388, 75, 41, 26]}, {"register": 686, "base": 680, "common_basis": [407, 66, 36, 9], "dimension": 4, "deadline": 1149, "deleted_echo_indices": [], "low": false, "borrow_from": 281, "retirement_B_event": 731, "retirement_frame": 124, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1149, "handoff_basis": [469, 66, 36, 9], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [388, 75, 41, 26]}, {"register": 699, "base": 696, "common_basis": [455, 33, 18, 12], "dimension": 4, "deadline": 1165, "deleted_echo_indices": [], "low": false, "borrow_from": 301, "retirement_B_event": 751, "retirement_frame": 153, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1165, "handoff_basis": [455, 33, 18, 12], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [273, 145, 85, 51]}, {"register": 702, "base": 696, "common_basis": [455, 33, 18, 12], "dimension": 4, "deadline": 1165, "deleted_echo_indices": [], "low": false, "borrow_from": 297, "retirement_B_event": 749, "retirement_frame": 153, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1165, "handoff_basis": [455, 33, 18, 12], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [273, 145, 85, 51]}, {"register": 703, "base": 696, "common_basis": [455, 33, 18, 12], "dimension": 4, "deadline": 1165, "deleted_echo_indices": [], "low": false, "borrow_from": 313, "retirement_B_event": 767, "retirement_frame": 182, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1165, "handoff_basis": [455, 33, 18, 12], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [385, 74, 44, 30]}, {"register": 701, "base": 696, "common_basis": [455, 33, 18, 12], "dimension": 4, "deadline": 1165, "deleted_echo_indices": [], "low": false, "borrow_from": 329, "retirement_B_event": 786, "retirement_frame": 211, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1165, "handoff_basis": [455, 33, 18, 12], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [266, 138, 75, 30]}, {"register": 595, "base": 592, "common_basis": [320, 192, 45, 30], "dimension": 4, "deadline": 1061, "deleted_echo_indices": [], "low": false, "borrow_from": 349, "retirement_B_event": 807, "retirement_frame": 240, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1061, "handoff_basis": [320, 192, 45, 30], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [416, 70, 19, 13]}, {"register": 695, "base": 688, "common_basis": [258, 130, 85, 45], "dimension": 4, "deadline": 1157, "deleted_echo_indices": [], "low": false, "borrow_from": 345, "retirement_B_event": 805, "retirement_frame": 240, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1157, "handoff_basis": [384, 130, 85, 45], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [416, 70, 19, 13]}, {"register": 598, "base": 592, "common_basis": [320, 192, 45, 30], "dimension": 4, "deadline": 1061, "deleted_echo_indices": [], "low": false, "borrow_from": 365, "retirement_B_event": 825, "retirement_frame": 269, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1061, "handoff_basis": [320, 192, 45, 30], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [262, 134, 102, 30]}, {"register": 599, "base": 592, "common_basis": [320, 192, 45, 30], "dimension": 4, "deadline": 1061, "deleted_echo_indices": [], "low": false, "borrow_from": 361, "retirement_B_event": 823, "retirement_frame": 269, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1061, "handoff_basis": [320, 192, 45, 30], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [262, 134, 102, 30]}, {"register": 694, "base": 688, "common_basis": [258, 130, 85, 45], "dimension": 4, "deadline": 1157, "deleted_echo_indices": [], "low": false, "borrow_from": 381, "retirement_B_event": 843, "retirement_frame": 298, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1157, "handoff_basis": [384, 130, 85, 45], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [392, 67, 37, 22]}, {"register": 693, "base": 688, "common_basis": [258, 130, 85, 45], "dimension": 4, "deadline": 1157, "deleted_echo_indices": [], "low": false, "borrow_from": 377, "retirement_B_event": 841, "retirement_frame": 298, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1157, "handoff_basis": [384, 130, 85, 45], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [392, 67, 37, 22]}, {"register": 691, "base": 688, "common_basis": [258, 130, 85, 45], "dimension": 4, "deadline": 1157, "deleted_echo_indices": [], "low": false, "borrow_from": 397, "retirement_B_event": 861, "retirement_frame": 327, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1157, "handoff_basis": [384, 130, 85, 45], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [259, 131, 75, 51]}, {"register": 687, "base": 680, "common_basis": [407, 66, 36, 9], "dimension": 4, "deadline": 1149, "deleted_echo_indices": [], "low": false, "borrow_from": 393, "retirement_B_event": 859, "retirement_frame": 327, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1149, "handoff_basis": [469, 66, 36, 9], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [259, 131, 75, 51]}, {"register": 685, "base": 680, "common_basis": [407, 66, 36, 9], "dimension": 4, "deadline": 1149, "deleted_echo_indices": [], "low": false, "borrow_from": 225, "retirement_B_event": -1, "retirement_frame": 37, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1149, "handoff_basis": [469, 66, 36, 9], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [448, 38, 21, 11]}, {"register": 679, "base": 672, "common_basis": [413, 72, 48, 3], "dimension": 4, "deadline": 1141, "deleted_echo_indices": [], "low": false, "borrow_from": 227, "retirement_B_event": -1, "retirement_frame": 37, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1141, "handoff_basis": [469, 72, 48, 3], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [448, 38, 21, 11]}, {"register": 678, "base": 672, "common_basis": [413, 72, 48, 3], "dimension": 4, "deadline": 1141, "deleted_echo_indices": [], "low": false, "borrow_from": 229, "retirement_B_event": -1, "retirement_frame": 37, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1141, "handoff_basis": [469, 72, 48, 3], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [448, 38, 21, 11]}, {"register": 677, "base": 672, "common_basis": [413, 72, 48, 3], "dimension": 4, "deadline": 1141, "deleted_echo_indices": [], "low": false, "borrow_from": 234, "retirement_B_event": -1, "retirement_frame": 37, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1141, "handoff_basis": [469, 72, 48, 3], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [448, 38, 21, 11]}, {"register": 675, "base": 672, "common_basis": [413, 72, 48, 3], "dimension": 4, "deadline": 1141, "deleted_echo_indices": [], "low": false, "borrow_from": 241, "retirement_B_event": -1, "retirement_frame": 66, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1141, "handoff_basis": [469, 72, 48, 3], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [261, 133, 85, 45]}, {"register": 663, "base": 656, "common_basis": [427, 96, 24, 6], "dimension": 4, "deadline": 1125, "deleted_echo_indices": [], "low": false, "borrow_from": 245, "retirement_B_event": -1, "retirement_frame": 66, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1125, "handoff_basis": [459, 96, 24, 6], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [261, 133, 85, 45]}, {"register": 662, "base": 656, "common_basis": [427, 96, 24, 6], "dimension": 4, "deadline": 1125, "deleted_echo_indices": [], "low": false, "borrow_from": 257, "retirement_B_event": -1, "retirement_frame": 95, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1125, "handoff_basis": [459, 96, 24, 6], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [400, 69, 35, 14]}, {"register": 647, "base": 640, "common_basis": [423, 65, 20, 10], "dimension": 4, "deadline": 1109, "deleted_echo_indices": [], "low": false, "borrow_from": 261, "retirement_B_event": -1, "retirement_frame": 95, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1109, "handoff_basis": [486, 65, 20, 10], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [400, 69, 35, 14]}, {"register": 653, "base": 648, "common_basis": [288, 160, 75, 25, 7], "dimension": 5, "deadline": 1117, "deleted_echo_indices": [], "low": false, "borrow_from": 73, "retirement_B_event": 954, "retirement_frame": 635, "retirement_dimension": 5, "old_final_dimension": 9, "handoff_B": 1117, "handoff_basis": [384, 160, 75, 25, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [320, 192, 32, 19, 13]}, {"register": 603, "base": 600, "common_basis": [409, 80, 40, 5, 2], "dimension": 5, "deadline": 1069, "deleted_echo_indices": [], "low": false, "borrow_from": 401, "retirement_B_event": -1, "retirement_frame": 356, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1069, "handoff_basis": [80, 40, 5, 2], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [265, 137, 75, 45]}, {"register": 605, "base": 600, "common_basis": [409, 80, 40, 5, 2], "dimension": 5, "deadline": 1069, "deleted_echo_indices": [], "low": false, "borrow_from": 403, "retirement_B_event": -1, "retirement_frame": 356, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1069, "handoff_basis": [80, 40, 5, 2], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [265, 137, 75, 45]}, {"register": 607, "base": 600, "common_basis": [409, 80, 40, 5, 2], "dimension": 5, "deadline": 1069, "deleted_echo_indices": [], "low": false, "borrow_from": 405, "retirement_B_event": -1, "retirement_frame": 356, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1069, "handoff_basis": [80, 40, 5, 2], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [265, 137, 75, 45]}, {"register": 611, "base": 608, "common_basis": [272, 144, 75, 42, 7], "dimension": 5, "deadline": 1077, "deleted_echo_indices": [], "low": false, "borrow_from": 410, "retirement_B_event": -1, "retirement_frame": 356, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1077, "handoff_basis": [144, 75, 42, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [265, 137, 75, 45]}, {"register": 613, "base": 608, "common_basis": [272, 144, 75, 42, 7], "dimension": 5, "deadline": 1077, "deleted_echo_indices": [], "low": false, "borrow_from": 417, "retirement_B_event": -1, "retirement_frame": 385, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1077, "handoff_basis": [144, 75, 42, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [386, 73, 45, 28]}, {"register": 614, "base": 608, "common_basis": [272, 144, 75, 42, 7], "dimension": 5, "deadline": 1077, "deleted_echo_indices": [], "low": false, "borrow_from": 419, "retirement_B_event": -1, "retirement_frame": 385, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1077, "handoff_basis": [144, 75, 42, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [386, 73, 45, 28]}, {"register": 615, "base": 608, "common_basis": [272, 144, 75, 42, 7], "dimension": 5, "deadline": 1077, "deleted_echo_indices": [], "low": false, "borrow_from": 421, "retirement_B_event": -1, "retirement_frame": 385, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1077, "handoff_basis": [144, 75, 42, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [386, 73, 45, 28]}, {"register": 627, "base": 624, "common_basis": [391, 68, 34, 17, 8], "dimension": 5, "deadline": 1093, "deleted_echo_indices": [], "low": false, "borrow_from": 426, "retirement_B_event": -1, "retirement_frame": 385, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1093, "handoff_basis": [391, 68, 34, 17], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [386, 73, 45, 28]}, {"register": 629, "base": 624, "common_basis": [391, 68, 34, 17, 8], "dimension": 5, "deadline": 1093, "deleted_echo_indices": [], "low": false, "borrow_from": 433, "retirement_B_event": -1, "retirement_frame": 414, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1093, "handoff_basis": [391, 68, 34, 17], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [268, 140, 45, 30]}, {"register": 630, "base": 624, "common_basis": [391, 68, 34, 17, 8], "dimension": 5, "deadline": 1093, "deleted_echo_indices": [], "low": false, "borrow_from": 435, "retirement_B_event": -1, "retirement_frame": 414, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1093, "handoff_basis": [391, 68, 34, 17], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [268, 140, 45, 30]}, {"register": 631, "base": 624, "common_basis": [391, 68, 34, 17, 8], "dimension": 5, "deadline": 1093, "deleted_echo_indices": [], "low": false, "borrow_from": 437, "retirement_B_event": -1, "retirement_frame": 414, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1093, "handoff_basis": [391, 68, 34, 17], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [268, 140, 45, 30]}, {"register": 655, "base": 648, "common_basis": [288, 160, 75, 25, 7], "dimension": 5, "deadline": 1117, "deleted_echo_indices": [], "low": false, "borrow_from": 442, "retirement_B_event": -1, "retirement_frame": 414, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1117, "handoff_basis": [384, 160, 75, 25], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [268, 140, 45, 30]}, {"register": 654, "base": 648, "common_basis": [288, 160, 75, 25, 7], "dimension": 5, "deadline": 1117, "deleted_echo_indices": [], "low": false, "borrow_from": 542, "retirement_B_event": 1057, "retirement_frame": 738, "retirement_dimension": 5, "old_final_dimension": 9, "handoff_B": 1117, "handoff_basis": [384, 160, 75, 25, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [262, 193, 33, 18, 12]}], "initial_corrections": [], "early_tail_events": [{"old_tail_index": 34, "before_B": 734, "gate": ["add", 282, 285, -1, 1, 124]}, {"old_tail_index": 35, "before_B": 734, "gate": ["scale", 282, 1, -1, 124]}, {"old_tail_index": 36, "before_B": 732, "gate": ["add", 277, 281, -1, 1, 124]}, {"old_tail_index": 37, "before_B": 732, "gate": ["scale", 277, 1, -1, 124]}, {"old_tail_index": 38, "before_B": 735, "gate": ["add", 275, 31, -1, 1, 124]}, {"old_tail_index": 39, "before_B": 733, "gate": ["add", 273, 12, -1, 1, 124]}, {"old_tail_index": 40, "before_B": 752, "gate": ["add", 298, 301, -1, 1, 153]}, {"old_tail_index": 41, "before_B": 752, "gate": ["scale", 298, 1, -1, 153]}, {"old_tail_index": 42, "before_B": 750, "gate": ["add", 293, 297, -1, 1, 153]}, {"old_tail_index": 43, "before_B": 750, "gate": ["scale", 293, 1, -1, 153]}, {"old_tail_index": 44, "before_B": 753, "gate": ["add", 291, 55, -1, 1, 153]}, {"old_tail_index": 45, "before_B": 751, "gate": ["add", 289, 101, -1, 1, 153]}, {"old_tail_index": 46, "before_B": 770, "gate": ["add", 314, 317, -1, 1, 182]}, {"old_tail_index": 47, "before_B": 770, "gate": ["scale", 314, 1, -1, 182]}, {"old_tail_index": 48, "before_B": 768, "gate": ["add", 309, 313, -1, 1, 182]}, {"old_tail_index": 49, "before_B": 768, "gate": ["scale", 309, 1, -1, 182]}, {"old_tail_index": 50, "before_B": 771, "gate": ["add", 307, 85, -1, 1, 182]}, {"old_tail_index": 51, "before_B": 769, "gate": ["add", 305, 98, -1, 1, 182]}, {"old_tail_index": 52, "before_B": 789, "gate": ["add", 330, 333, -1, 1, 211]}, {"old_tail_index": 53, "before_B": 789, "gate": ["scale", 330, 1, -1, 211]}, {"old_tail_index": 54, "before_B": 787, "gate": ["add", 325, 329, -1, 1, 211]}, {"old_tail_index": 55, "before_B": 787, "gate": ["scale", 325, 1, -1, 211]}, {"old_tail_index": 56, "before_B": 790, "gate": ["add", 323, 33, -1, 1, 211]}, {"old_tail_index": 57, "before_B": 788, "gate": ["add", 321, 49, -1, 1, 211]}, {"old_tail_index": 58, "before_B": 808, "gate": ["add", 346, 349, -1, 1, 240]}, {"old_tail_index": 59, "before_B": 808, "gate": ["scale", 346, 1, -1, 240]}, {"old_tail_index": 60, "before_B": 806, "gate": ["add", 341, 345, -1, 1, 240]}, {"old_tail_index": 61, "before_B": 806, "gate": ["scale", 341, 1, -1, 240]}, {"old_tail_index": 62, "before_B": 809, "gate": ["add", 339, 1, -1, 1, 240]}, {"old_tail_index": 63, "before_B": 807, "gate": ["add", 337, 6, -1, 1, 240]}, {"old_tail_index": 64, "before_B": 826, "gate": ["add", 362, 365, -1, 1, 269]}, {"old_tail_index": 65, "before_B": 826, "gate": ["scale", 362, 1, -1, 269]}, {"old_tail_index": 66, "before_B": 824, "gate": ["add", 357, 361, -1, 1, 269]}, {"old_tail_index": 67, "before_B": 824, "gate": ["scale", 357, 1, -1, 269]}, {"old_tail_index": 68, "before_B": 827, "gate": ["add", 355, 74, -1, 1, 269]}, {"old_tail_index": 69, "before_B": 825, "gate": ["add", 353, 83, -1, 1, 269]}, {"old_tail_index": 70, "before_B": 844, "gate": ["add", 378, 381, -1, 1, 298]}, {"old_tail_index": 71, "before_B": 844, "gate": ["scale", 378, 1, -1, 298]}, {"old_tail_index": 72, "before_B": 842, "gate": ["add", 373, 377, -1, 1, 298]}, {"old_tail_index": 73, "before_B": 842, "gate": ["scale", 373, 1, -1, 298]}, {"old_tail_index": 74, "before_B": 845, "gate": ["add", 371, 88, -1, 1, 298]}, {"old_tail_index": 75, "before_B": 843, "gate": ["add", 369, 80, -1, 1, 298]}, {"old_tail_index": 76, "before_B": 862, "gate": ["add", 394, 397, -1, 1, 327]}, {"old_tail_index": 77, "before_B": 862, "gate": ["scale", 394, 1, -1, 327]}, {"old_tail_index": 78, "before_B": 860, "gate": ["add", 389, 393, -1, 1, 327]}, {"old_tail_index": 79, "before_B": 860, "gate": ["scale", 389, 1, -1, 327]}, {"old_tail_index": 80, "before_B": 863, "gate": ["add", 387, 4, -1, 1, 327]}, {"old_tail_index": 81, "before_B": 861, "gate": ["add", 385, 68, -1, 1, 327]}], "replay": {"status": "PASS_EXACT_FREE_OPERATOR_BORROWING_REPLAY", "local_profile": {"1": 2351, "2": 501, "3": 414, "4": 129, "5": 42, "8": 8}, "local_mass": 5385, "remaining_registers": 661, "zero_FULL_cleanup_buffers": 76, "exact_cold_restoration": [{"register": 273, "frame": 124, "preparation": {"273": "1"}}, {"register": 275, "frame": 124, "preparation": {"275": "1"}}, {"register": 277, "frame": 124, "preparation": {"277": "1"}}, {"register": 282, "frame": 124, "preparation": {"282": "1"}}, {"register": 289, "frame": 153, "preparation": {"289": "1"}}, {"register": 291, "frame": 153, "preparation": {"291": "1"}}, {"register": 293, "frame": 153, "preparation": {"293": "1"}}, {"register": 298, "frame": 153, "preparation": {"298": "1"}}, {"register": 305, "frame": 182, "preparation": {"305": "1"}}, {"register": 307, "frame": 182, "preparation": {"307": "1"}}, {"register": 309, "frame": 182, "preparation": {"309": "1"}}, {"register": 314, "frame": 182, "preparation": {"314": "1"}}, {"register": 321, "frame": 211, "preparation": {"321": "1"}}, {"register": 323, "frame": 211, "preparation": {"323": "1"}}, {"register": 325, "frame": 211, "preparation": {"325": "1"}}, {"register": 330, "frame": 211, "preparation": {"330": "1"}}, {"register": 337, "frame": 240, "preparation": {"337": "1"}}, {"register": 339, "frame": 240, "preparation": {"339": "1"}}, {"register": 341, "frame": 240, "preparation": {"341": "1"}}, {"register": 346, "frame": 240, "preparation": {"346": "1"}}, {"register": 353, "frame": 269, "preparation": {"353": "1"}}, {"register": 355, "frame": 269, "preparation": {"355": "1"}}, {"register": 357, "frame": 269, "preparation": {"357": "1"}}, {"register": 362, "frame": 269, "preparation": {"362": "1"}}, {"register": 369, "frame": 298, "preparation": {"369": "1"}}, {"register": 371, "frame": 298, "preparation": {"371": "1"}}, {"register": 373, "frame": 298, "preparation": {"373": "1"}}, {"register": 378, "frame": 298, "preparation": {"378": "1"}}, {"register": 385, "frame": 327, "preparation": {"385": "1"}}, {"register": 387, "frame": 327, "preparation": {"387": "1"}}, {"register": 389, "frame": 327, "preparation": {"389": "1"}}, {"register": 394, "frame": 327, "preparation": {"394": "1"}}, {"register": 572, "frame": 1005, "preparation": {"572": "1", "408": "-1"}}, {"register": 573, "frame": 1005, "preparation": {"573": "1", "105": "-1"}}, {"register": 574, "frame": 1004, "preparation": {"574": "1", "412": "-1"}}, {"register": 575, "frame": 1004, "preparation": {"575": "1", "414": "-1"}}, {"register": 580, "frame": 1006, "preparation": {"580": "1", "424": "-1"}}, {"register": 581, "frame": 1006, "preparation": {"581": "1", "44": "-1"}}, {"register": 582, "frame": 1007, "preparation": {"582": "1", "428": "-1"}}, {"register": 583, "frame": 1007, "preparation": {"583": "1", "430": "-1"}}, {"register": 311, "frame": 1003, "preparation": {"498": "1", "311": "-1"}}, {"register": 327, "frame": 1002, "preparation": {"511": "1", "322": "-1"}}, {"register": 448, "frame": 998, "preparation": {"448": "1", "231": "-1"}}, {"register": 449, "frame": 998, "preparation": {"449": "1", "226": "-1"}}, {"register": 450, "frame": 999, "preparation": {"450": "1", "230": "-1"}}, {"register": 451, "frame": 999, "preparation": {"451": "1", "228": "-1"}}, {"register": 452, "frame": 999, "preparation": {"452": "1", "232": "-1"}}, {"register": 453, "frame": 999, "preparation": {"453": "1", "7": "-1"}}, {"register": 454, "frame": 998, "preparation": {"454": "1", "236": "-1"}}, {"register": 455, "frame": 998, "preparation": {"455": "1", "238": "-1"}}, {"register": 484, "frame": 998, "preparation": {"484": "1", "231": "-1", "299": "-1"}}, {"register": 485, "frame": 998, "preparation": {"485": "1", "226": "-1", "54": "-1"}}, {"register": 498, "frame": 1003, "preparation": {"499": "1", "306": "-1"}}, {"register": 500, "frame": 1001, "preparation": {"500": "1", "310": "-1"}}, {"register": 501, "frame": 1001, "preparation": {"501": "1", "308": "-1"}}, {"register": 508, "frame": 999, "preparation": {"508": "1", "331": "-1", "230": "-1"}}, {"register": 509, "frame": 999, "preparation": {"509": "1", "228": "-1", "34": "-1"}}, {"register": 510, "frame": 1002, "preparation": {"511": "-1", "510": "1"}}, {"register": 512, "frame": 1000, "preparation": {"512": "1", "326": "-1"}}, {"register": 513, "frame": 1000, "preparation": {"513": "1", "324": "-1"}}, {"register": 531, "frame": 999, "preparation": {"531": "1", "351": "-1", "587": "-1/2"}}, {"register": 532, "frame": 999, "preparation": {"532": "1", "363": "-1", "232": "2"}}, {"register": 543, "frame": 999, "preparation": {"543": "1", "367": "-1", "589": "1"}}, {"register": 555, "frame": 998, "preparation": {"555": "1", "383": "-1", "585": "-1/2"}}, {"register": 556, "frame": 998, "preparation": {"556": "1", "236": "2", "395": "-1"}}, {"register": 557, "frame": 998, "preparation": {"557": "1", "5": "-1", "238": "2"}}, {"register": 566, "frame": 998, "preparation": {"566": "1", "69": "-1"}}, {"register": 567, "frame": 998, "preparation": {"567": "1", "399": "-1", "591": "1"}}, {"register": 584, "frame": 998, "preparation": {"584": "1", "439": "-1"}}, {"register": 585, "frame": 998, "preparation": {"585": "1", "434": "-1"}}, {"register": 586, "frame": 999, "preparation": {"586": "1", "438": "-1"}}, {"register": 587, "frame": 999, "preparation": {"587": "1", "436": "-1"}}, {"register": 588, "frame": 999, "preparation": {"588": "1", "440": "-1"}}, {"register": 589, "frame": 999, "preparation": {"589": "1", "46": "-1"}}, {"register": 590, "frame": 998, "preparation": {"590": "1", "444": "-1"}}, {"register": 591, "frame": 998, "preparation": {"591": "1", "446": "-1"}}], "symbolic_warps": [{"operator": 1, "borrow_from": 243, "removed": 597, "from_basis": [261, 133, 85, 45], "to_basis": [320, 192, 45, 30], "physical_handoff_rank": 0}, {"operator": 14, "borrow_from": 349, "removed": 595, "from_basis": [416, 70, 19, 13], "to_basis": [320, 192, 45, 30], "physical_handoff_rank": 0}, {"operator": 16, "borrow_from": 365, "removed": 598, "from_basis": [262, 134, 102, 30], "to_basis": [320, 192, 45, 30], "physical_handoff_rank": 0}, {"operator": 17, "borrow_from": 361, "removed": 599, "from_basis": [262, 134, 102, 30], "to_basis": [320, 192, 45, 30], "physical_handoff_rank": 0}, {"operator": 31, "borrow_from": 401, "removed": 603, "from_basis": [265, 137, 75, 45], "to_basis": [80, 40, 5, 2], "physical_handoff_rank": 0}, {"operator": 32, "borrow_from": 403, "removed": 605, "from_basis": [265, 137, 75, 45], "to_basis": [80, 40, 5, 2], "physical_handoff_rank": 0}, {"operator": 33, "borrow_from": 405, "removed": 607, "from_basis": [265, 137, 75, 45], "to_basis": [80, 40, 5, 2], "physical_handoff_rank": 0}, {"operator": 34, "borrow_from": 410, "removed": 611, "from_basis": [265, 137, 75, 45], "to_basis": [144, 75, 42, 7], "physical_handoff_rank": 0}, {"operator": 35, "borrow_from": 417, "removed": 613, "from_basis": [386, 73, 45, 28], "to_basis": [144, 75, 42, 7], "physical_handoff_rank": 0}, {"operator": 36, "borrow_from": 419, "removed": 614, "from_basis": [386, 73, 45, 28], "to_basis": [144, 75, 42, 7], "physical_handoff_rank": 0}, {"operator": 37, "borrow_from": 421, "removed": 615, "from_basis": [386, 73, 45, 28], "to_basis": [144, 75, 42, 7], "physical_handoff_rank": 0}, {"operator": 38, "borrow_from": 426, "removed": 627, "from_basis": [386, 73, 45, 28], "to_basis": [391, 68, 34, 17], "physical_handoff_rank": 0}, {"operator": 39, "borrow_from": 433, "removed": 629, "from_basis": [268, 140, 45, 30], "to_basis": [391, 68, 34, 17], "physical_handoff_rank": 0}, {"operator": 40, "borrow_from": 435, "removed": 630, "from_basis": [268, 140, 45, 30], "to_basis": [391, 68, 34, 17], "physical_handoff_rank": 0}, {"operator": 41, "borrow_from": 437, "removed": 631, "from_basis": [268, 140, 45, 30], "to_basis": [391, 68, 34, 17], "physical_handoff_rank": 0}, {"operator": 2, "borrow_from": 250, "removed": 643, "from_basis": [261, 133, 85, 45], "to_basis": [486, 65, 20, 10], "physical_handoff_rank": 0}, {"operator": 3, "borrow_from": 266, "removed": 645, "from_basis": [400, 69, 35, 14], "to_basis": [486, 65, 20, 10], "physical_handoff_rank": 0}, {"operator": 4, "borrow_from": 259, "removed": 646, "from_basis": [400, 69, 35, 14], "to_basis": [486, 65, 20, 10], "physical_handoff_rank": 0}, {"operator": 29, "borrow_from": 261, "removed": 647, "from_basis": [400, 69, 35, 14], "to_basis": [486, 65, 20, 10], "physical_handoff_rank": 0}, {"operator": 7, "borrow_from": 554, "removed": 651, "from_basis": [388, 67, 33, 18, 12], "to_basis": [384, 160, 75, 25, 7], "physical_handoff_rank": 0}, {"operator": 30, "borrow_from": 73, "removed": 653, "from_basis": [320, 192, 32, 19, 13], "to_basis": [384, 160, 75, 25, 7], "physical_handoff_rank": 0}, {"operator": 42, "borrow_from": 442, "removed": 655, "from_basis": [268, 140, 45, 30], "to_basis": [384, 160, 75, 25], "physical_handoff_rank": 0}, {"operator": 43, "borrow_from": 542, "removed": 654, "from_basis": [262, 193, 33, 18, 12], "to_basis": [384, 160, 75, 25, 7], "physical_handoff_rank": 0}, {"operator": 5, "borrow_from": 333, "removed": 659, "from_basis": [266, 138, 75, 30], "to_basis": [459, 96, 24, 6], "physical_handoff_rank": 0}, {"operator": 6, "borrow_from": 317, "removed": 661, "from_basis": [385, 74, 44, 30], "to_basis": [459, 96, 24, 6], "physical_handoff_rank": 0}, {"operator": 27, "borrow_from": 245, "removed": 663, "from_basis": [261, 133, 85, 45], "to_basis": [459, 96, 24, 6], "physical_handoff_rank": 0}, {"operator": 28, "borrow_from": 257, "removed": 662, "from_basis": [400, 69, 35, 14], "to_basis": [459, 96, 24, 6], "physical_handoff_rank": 0}, {"operator": 23, "borrow_from": 227, "removed": 679, "from_basis": [448, 38, 21, 11], "to_basis": [469, 72, 48, 3], "physical_handoff_rank": 0}, {"operator": 24, "borrow_from": 229, "removed": 678, "from_basis": [448, 38, 21, 11], "to_basis": [469, 72, 48, 3], "physical_handoff_rank": 0}, {"operator": 25, "borrow_from": 234, "removed": 677, "from_basis": [448, 38, 21, 11], "to_basis": [469, 72, 48, 3], "physical_handoff_rank": 0}, {"operator": 26, "borrow_from": 241, "removed": 675, "from_basis": [261, 133, 85, 45], "to_basis": [469, 72, 48, 3], "physical_handoff_rank": 0}, {"operator": 8, "borrow_from": 285, "removed": 683, "from_basis": [388, 75, 41, 26], "to_basis": [469, 66, 36, 9], "physical_handoff_rank": 0}, {"operator": 9, "borrow_from": 281, "removed": 686, "from_basis": [388, 75, 41, 26], "to_basis": [469, 66, 36, 9], "physical_handoff_rank": 0}, {"operator": 21, "borrow_from": 393, "removed": 687, "from_basis": [259, 131, 75, 51], "to_basis": [469, 66, 36, 9], "physical_handoff_rank": 0}, {"operator": 22, "borrow_from": 225, "removed": 685, "from_basis": [448, 38, 21, 11], "to_basis": [469, 66, 36, 9], "physical_handoff_rank": 0}, {"operator": 15, "borrow_from": 345, "removed": 695, "from_basis": [416, 70, 19, 13], "to_basis": [384, 130, 85, 45], "physical_handoff_rank": 0}, {"operator": 18, "borrow_from": 381, "removed": 694, "from_basis": [392, 67, 37, 22], "to_basis": [384, 130, 85, 45], "physical_handoff_rank": 0}, {"operator": 19, "borrow_from": 377, "removed": 693, "from_basis": [392, 67, 37, 22], "to_basis": [384, 130, 85, 45], "physical_handoff_rank": 0}, {"operator": 20, "borrow_from": 397, "removed": 691, "from_basis": [259, 131, 75, 51], "to_basis": [384, 130, 85, 45], "physical_handoff_rank": 0}, {"operator": 10, "borrow_from": 301, "removed": 699, "from_basis": [273, 145, 85, 51], "to_basis": [455, 33, 18, 12], "physical_handoff_rank": 0}, {"operator": 11, "borrow_from": 297, "removed": 702, "from_basis": [273, 145, 85, 51], "to_basis": [455, 33, 18, 12], "physical_handoff_rank": 0}, {"operator": 12, "borrow_from": 313, "removed": 703, "from_basis": [385, 74, 44, 30], "to_basis": [455, 33, 18, 12], "physical_handoff_rank": 0}, {"operator": 13, "borrow_from": 329, "removed": 701, "from_basis": [266, 138, 75, 30], "to_basis": [455, 33, 18, 12], "physical_handoff_rank": 0}]}, "gaussian": {"status": "PASS_EXACT_GAUSSIAN_BORROW_HANDOFFS", "operators": 43, "records": [{"operator": 1, "G_columns": [1, 2, 4, 8, 64, 19, 104, 197, 325], "handoff_exact_monomial_sha256": "6cf8c0f9b98f3f5b3fc8b5cc39734c2a340bdde82b7013e9b77f12930b816490", "full_exit_exact_monomial_sha256": "270a211e83af324abd684553bedbcafb54aa0f2d882124d2120566884a9d7959"}, {"operator": 14, "G_columns": [1, 2, 4, 27, 46, 8, 198, 64, 264], "handoff_exact_monomial_sha256": "409dcf3130f1420b7a9f53a000956599f07e670a81747d51895826f9753a1b02", "full_exit_exact_monomial_sha256": "726e078d38693898e271f2870e25422f7f0b89a5042f05e92246260497abce5a"}, {"operator": 16, "G_columns": [1, 2, 4, 8, 16, 64, 107, 198, 326], "handoff_exact_monomial_sha256": "128488b96c4be786bca41db2dd094730dfe5ba743ada1e41df2148f3d4ea1684", "full_exit_exact_monomial_sha256": "2de4692a470bc8807c2c93b9bfdde380c12422c5ab7eb258e6a6a469c0274fd2"}, {"operator": 17, "G_columns": [1, 2, 4, 8, 16, 64, 107, 198, 326], "handoff_exact_monomial_sha256": "128488b96c4be786bca41db2dd094730dfe5ba743ada1e41df2148f3d4ea1684", "full_exit_exact_monomial_sha256": "2de4692a470bc8807c2c93b9bfdde380c12422c5ab7eb258e6a6a469c0274fd2"}, {"operator": 31, "G_columns": [1, 8, 16, 128, 256, 147, 140, 169, 209], "handoff_exact_monomial_sha256": "92f7d354f79c5184db61c3266271bbdb5a503848925289336cf1f74731916572", "full_exit_exact_monomial_sha256": "9524c1b6e789428fdf922bdcba1039c0a161c8a92e3fde97a412840e90e0d09d"}, {"operator": 32, "G_columns": [1, 8, 16, 128, 256, 147, 140, 169, 209], "handoff_exact_monomial_sha256": "92f7d354f79c5184db61c3266271bbdb5a503848925289336cf1f74731916572", "full_exit_exact_monomial_sha256": "9524c1b6e789428fdf922bdcba1039c0a161c8a92e3fde97a412840e90e0d09d"}, {"operator": 33, "G_columns": [1, 8, 16, 128, 256, 147, 140, 169, 209], "handoff_exact_monomial_sha256": "92f7d354f79c5184db61c3266271bbdb5a503848925289336cf1f74731916572", "full_exit_exact_monomial_sha256": "9524c1b6e789428fdf922bdcba1039c0a161c8a92e3fde97a412840e90e0d09d"}, {"operator": 34, "G_columns": [1, 2, 8, 16, 256, 30, 57, 90, 129], "handoff_exact_monomial_sha256": "a110db1ecdf22c9fb177ba8da8022231d8c498aca5114e846ee96be1f3930a78", "full_exit_exact_monomial_sha256": "a2acaaa3f8426dd5fcddc0963dc028f3935edc0f8b8db21e64b3b13651c4794d"}, {"operator": 35, "G_columns": [1, 2, 8, 16, 31, 51, 90, 256, 402], "handoff_exact_monomial_sha256": "fe18b6b1d93e1bd2dfc42c93ae0f3b7bd5b64f1dfe76c105c99b5597fbb23988", "full_exit_exact_monomial_sha256": "7ebe71197c980ded084c48963fe498382794bf3f57de6b9b3bca235d51a52949"}, {"operator": 36, "G_columns": [1, 2, 8, 16, 31, 51, 90, 256, 402], "handoff_exact_monomial_sha256": "fe18b6b1d93e1bd2dfc42c93ae0f3b7bd5b64f1dfe76c105c99b5597fbb23988", "full_exit_exact_monomial_sha256": "7ebe71197c980ded084c48963fe498382794bf3f57de6b9b3bca235d51a52949"}, {"operator": 37, "G_columns": [1, 2, 8, 16, 31, 51, 90, 256, 402], "handoff_exact_monomial_sha256": "fe18b6b1d93e1bd2dfc42c93ae0f3b7bd5b64f1dfe76c105c99b5597fbb23988", "full_exit_exact_monomial_sha256": "7ebe71197c980ded084c48963fe498382794bf3f57de6b9b3bca235d51a52949"}, {"operator": 38, "G_columns": [1, 2, 4, 8, 29, 47, 77, 128, 261], "handoff_exact_monomial_sha256": "4d5e3716c6663e7c72ae969dfc2bb1d41b5a75ca49f9180b44fb4aa0676db55c", "full_exit_exact_monomial_sha256": "da709e429065e49d0128c24e6b8d73d7949d2d15ac6c9865b597d23694d84ae2"}, {"operator": 39, "G_columns": [1, 2, 4, 8, 31, 47, 128, 72, 395], "handoff_exact_monomial_sha256": "d6d2eb1462ff1334a3a5f205042992ef1b75e41a1fd6c592453efc12e93b40b4", "full_exit_exact_monomial_sha256": "eb75c7473be2e377108991106d2d0029a160fc26722c04d66721ba1828935a9c"}, {"operator": 40, "G_columns": [1, 2, 4, 8, 31, 47, 128, 72, 395], "handoff_exact_monomial_sha256": "d6d2eb1462ff1334a3a5f205042992ef1b75e41a1fd6c592453efc12e93b40b4", "full_exit_exact_monomial_sha256": "eb75c7473be2e377108991106d2d0029a160fc26722c04d66721ba1828935a9c"}, {"operator": 41, "G_columns": [1, 2, 4, 8, 31, 47, 128, 72, 395], "handoff_exact_monomial_sha256": "d6d2eb1462ff1334a3a5f205042992ef1b75e41a1fd6c592453efc12e93b40b4", "full_exit_exact_monomial_sha256": "eb75c7473be2e377108991106d2d0029a160fc26722c04d66721ba1828935a9c"}, {"operator": 2, "G_columns": [1, 2, 4, 32, 128, 47, 145, 68, 483], "handoff_exact_monomial_sha256": "274ab0dc9326a464b10185c96fbf4733d6d8a71072edc6177751f18c0bade9a0", "full_exit_exact_monomial_sha256": "4128f5981c0da1da48b95f9448451412b037a42ef0b87a20799e18afe86b2a84"}, {"operator": 3, "G_columns": [1, 2, 4, 12, 32, 23, 68, 128, 326], "handoff_exact_monomial_sha256": "3cbf1001720666131788bfaff5a9170b32261c3a1838ee8bf1cfcd065c79c8d2", "full_exit_exact_monomial_sha256": "716f8283675093de63d721830e4fad12fd8a39d2ffe7c752f05d21f3e4a33571"}, {"operator": 4, "G_columns": [1, 2, 4, 12, 32, 23, 68, 128, 326], "handoff_exact_monomial_sha256": "3cbf1001720666131788bfaff5a9170b32261c3a1838ee8bf1cfcd065c79c8d2", "full_exit_exact_monomial_sha256": "716f8283675093de63d721830e4fad12fd8a39d2ffe7c752f05d21f3e4a33571"}, {"operator": 29, "G_columns": [1, 2, 4, 12, 32, 23, 68, 128, 326], "handoff_exact_monomial_sha256": "3cbf1001720666131788bfaff5a9170b32261c3a1838ee8bf1cfcd065c79c8d2", "full_exit_exact_monomial_sha256": "716f8283675093de63d721830e4fad12fd8a39d2ffe7c752f05d21f3e4a33571"}, {"operator": 7, "G_columns": [1, 2, 8, 15, 27, 74, 163, 32, 424], "handoff_exact_monomial_sha256": "b5719508324b12420b01f10070d9158b8cda290715f4d7a263d45f2d68f6aa7c", "full_exit_exact_monomial_sha256": "fb97b382c57cbe403e5945283d28cfe1f1bb7ea8bd235f4872765e1f46b4c7fa"}, {"operator": 30, "G_columns": [1, 2, 8, 14, 26, 75, 32, 128, 416], "handoff_exact_monomial_sha256": "6efb2a4bb882d4c98dd8979c02bbc8c9954582b8f1ec1ec64c700c9d2c0de8f4", "full_exit_exact_monomial_sha256": "78a5a89545b60921ef7211cc049206a47f9ae3c28afdb53c9f25ec14b619335d"}, {"operator": 42, "G_columns": [1, 2, 4, 8, 23, 70, 32, 172, 396], "handoff_exact_monomial_sha256": "da2efaf833906b554c722a17cc7f074d87b909a8486423ffdc53e04b65372de0", "full_exit_exact_monomial_sha256": "b3633f1dfc8d6ad0d8eac3b953ba2cc217a83e681e4ac93aa41849460ecbeac9"}, {"operator": 43, "G_columns": [1, 2, 8, 15, 27, 74, 32, 129, 394], "handoff_exact_monomial_sha256": "230e6fecbc94c0cf2da12903787af836f323ad381aa32674d22233c107069db3", "full_exit_exact_monomial_sha256": "31d703f818e3e52a4c2768d30af947358093673cab0005d4c82a33accee62192"}, {"operator": 5, "G_columns": [1, 2, 8, 32, 44, 128, 59, 66, 489], "handoff_exact_monomial_sha256": "1058f8b951102c293951a04e36ad83b3e0ad7c4b372b8ecef8035dad5a18e1bf", "full_exit_exact_monomial_sha256": "f10368763cbdc46b83fb478fd50c2dc8391757e01f040fe67aae7e0020ce9860"}, {"operator": 6, "G_columns": [1, 2, 8, 32, 44, 48, 66, 128, 330], "handoff_exact_monomial_sha256": "09ec6b3f9fa181cdd0dac78d2c35b4594723a305960e8eb75e1ec3ee22cf2693", "full_exit_exact_monomial_sha256": "e93033cf83683623d8e52ed40b2429c2ef15523b61700441b88758d1af77ee30"}, {"operator": 27, "G_columns": [1, 2, 8, 32, 128, 47, 145, 105, 450], "handoff_exact_monomial_sha256": "94122f9a3de80d451b243e2e6473a8bc0f56d5c3625f0154cd99ab50fbbf022e", "full_exit_exact_monomial_sha256": "035484c8054886881108ee0cccb238df6bc0a3c1f785486ff9d3f419ce1f7dec"}, {"operator": 28, "G_columns": [1, 2, 8, 12, 32, 27, 105, 128, 363], "handoff_exact_monomial_sha256": "9950407ae3dafcbbb524121019a731b0bb3ea637a121bae2230499c8135296c7", "full_exit_exact_monomial_sha256": "fed181a27b1767b27418eda196bc3f8c9971d270783d0ecaec54547400e8a1ff"}, {"operator": 23, "G_columns": [1, 4, 8, 6, 57, 68, 16, 128, 325], "handoff_exact_monomial_sha256": "2dfc1e190b74d747165f8b25691dc73760c41f5a81d14c11f3b6fcdaacbf84a9", "full_exit_exact_monomial_sha256": "3a285b1adc2256fba3abc2bfd6fd2af9cbb1e623058268e950e49d3731d4b25b"}, {"operator": 24, "G_columns": [1, 4, 8, 6, 57, 68, 16, 128, 325], "handoff_exact_monomial_sha256": "2dfc1e190b74d747165f8b25691dc73760c41f5a81d14c11f3b6fcdaacbf84a9", "full_exit_exact_monomial_sha256": "3a285b1adc2256fba3abc2bfd6fd2af9cbb1e623058268e950e49d3731d4b25b"}, {"operator": 25, "G_columns": [1, 4, 8, 6, 57, 68, 16, 128, 325], "handoff_exact_monomial_sha256": "2dfc1e190b74d747165f8b25691dc73760c41f5a81d14c11f3b6fcdaacbf84a9", "full_exit_exact_monomial_sha256": "3a285b1adc2256fba3abc2bfd6fd2af9cbb1e623058268e950e49d3731d4b25b"}, {"operator": 26, "G_columns": [1, 4, 8, 16, 128, 26, 185, 65, 476], "handoff_exact_monomial_sha256": "313bb2ad48197e123504a494e7261c4f16f8345b61502472a505f5e8a4ffeed2", "full_exit_exact_monomial_sha256": "5183b631ae214ae8fcd40bb479ba34be715ba2bc497e4974afd327fd9422e099"}, {"operator": 8, "G_columns": [1, 2, 4, 16, 27, 53, 81, 128, 337], "handoff_exact_monomial_sha256": "1f0bc88ef72044371a1b248bf457df6baaf719b79f0b68f5b6344f882ab4279a", "full_exit_exact_monomial_sha256": "3f70bc24f57a78fedd30541c26a2ce7ae0bb03ef5c3d83848efb3bc3f790ea13"}, {"operator": 9, "G_columns": [1, 2, 4, 16, 27, 53, 81, 128, 337], "handoff_exact_monomial_sha256": "1f0bc88ef72044371a1b248bf457df6baaf719b79f0b68f5b6344f882ab4279a", "full_exit_exact_monomial_sha256": "3f70bc24f57a78fedd30541c26a2ce7ae0bb03ef5c3d83848efb3bc3f790ea13"}, {"operator": 21, "G_columns": [1, 2, 4, 16, 128, 138, 55, 65, 470], "handoff_exact_monomial_sha256": "9aac5012d2e6559816243a71a3d2242f9ab1fd5c93999852154b17d7016246b1", "full_exit_exact_monomial_sha256": "fe67c87c4305ec4904f7b1caff4270da969cbec68b30396419d56ad034bb077a"}, {"operator": 22, "G_columns": [1, 2, 4, 10, 33, 68, 16, 128, 325], "handoff_exact_monomial_sha256": "ff04b6e08be7b0eecc02fe682db07c8443be8d8ccfc01acd954bf9d340a23725", "full_exit_exact_monomial_sha256": "9cac0ebf245216aa73aef54a6b1f2819dd58890566e175330b89efaa55081010"}, {"operator": 15, "G_columns": [1, 2, 4, 40, 86, 8, 132, 16, 408], "handoff_exact_monomial_sha256": "cec7ff0123251549c69eaeb589fa79562a842ecf40de40aecc761bdf043c4fd2", "full_exit_exact_monomial_sha256": "40efcad72e80e65e7f8a29c26622bcfba6ebbfced1ba108478c5cb79f016afe4"}, {"operator": 18, "G_columns": [1, 2, 4, 8, 43, 80, 129, 16, 408], "handoff_exact_monomial_sha256": "542bcfe937ce79a4f3132048c70c7899637044e281e6156d0429de47515c75e2", "full_exit_exact_monomial_sha256": "cd610342e99dd286b5604c783a53b18f9e8805b700d2a2ab1f2a69f38998664a"}, {"operator": 19, "G_columns": [1, 2, 4, 8, 43, 80, 129, 16, 408], "handoff_exact_monomial_sha256": "542bcfe937ce79a4f3132048c70c7899637044e281e6156d0429de47515c75e2", "full_exit_exact_monomial_sha256": "cd610342e99dd286b5604c783a53b18f9e8805b700d2a2ab1f2a69f38998664a"}, {"operator": 20, "G_columns": [1, 2, 4, 8, 16, 62, 94, 129, 387], "handoff_exact_monomial_sha256": "1d151f1d9ddc9aed0a277c1d756e1deb703f2c5b4be38cdbb598cbe428de3dfb", "full_exit_exact_monomial_sha256": "07afa8d5a0aec069987438247c55b91ed85c84d71e6bfbd636da943e937120d7"}, {"operator": 10, "G_columns": [1, 2, 4, 64, 128, 143, 151, 160, 326], "handoff_exact_monomial_sha256": "7c58ca977f777b8a9c2e9708aa59f53ca850db9ca068470c1079bba62cc15191", "full_exit_exact_monomial_sha256": "416ddf0788d10d7a1b3304dad5c801688b1fd8bddc6e08cff90f5a02bb764f6b"}, {"operator": 11, "G_columns": [1, 2, 4, 64, 128, 143, 151, 160, 326], "handoff_exact_monomial_sha256": "7c58ca977f777b8a9c2e9708aa59f53ca850db9ca068470c1079bba62cc15191", "full_exit_exact_monomial_sha256": "416ddf0788d10d7a1b3304dad5c801688b1fd8bddc6e08cff90f5a02bb764f6b"}, {"operator": 12, "G_columns": [1, 2, 4, 64, 74, 86, 99, 128, 326], "handoff_exact_monomial_sha256": "4483ff575eb4cbc74feb2e8d95c414bf361bbae7df79d88a16c821e72b829429", "full_exit_exact_monomial_sha256": "b1417ab0cf194f64c94a9a5d584e7fe22beccea88e65d7a0ca8ece5c3b32b77e"}, {"operator": 13, "G_columns": [1, 2, 4, 64, 74, 128, 81, 99, 389], "handoff_exact_monomial_sha256": "4c210d00727ae6d8766019b938ee502095a23011211d32929689c043538eb19c", "full_exit_exact_monomial_sha256": "df2e2ec142b4b4fc1b4726e7f2b381e9231672788a4c440ff372587ddcf02720"}]}} \ No newline at end of file diff --git a/research/t74-low-alias-borrowing/inputs/witness_43_extra.json b/research/t74-low-alias-borrowing/inputs/witness_43_extra.json new file mode 100644 index 0000000000..864ba533f5 --- /dev/null +++ b/research/t74-low-alias-borrowing/inputs/witness_43_extra.json @@ -0,0 +1 @@ +{"credit": "#2226 anticipatory dirty borrowing (Cinna Davis / 1337isnot1337), adapted to T74 words", "variant": "43_extra", "pairs": [{"register": 597, "base": 592, "common_basis": [320, 192, 45, 30], "dimension": 4, "deadline": 1061, "deleted_echo_indices": [], "low": false, "borrow_from": 243, "retirement_B_event": -1, "retirement_frame": 66, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1061, "handoff_basis": [320, 192, 45, 30], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [261, 133, 85, 45]}, {"register": 643, "base": 640, "common_basis": [423, 65, 20, 10], "dimension": 4, "deadline": 1109, "deleted_echo_indices": [], "low": false, "borrow_from": 250, "retirement_B_event": -1, "retirement_frame": 66, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1109, "handoff_basis": [486, 65, 20, 10], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [261, 133, 85, 45]}, {"register": 645, "base": 640, "common_basis": [423, 65, 20, 10], "dimension": 4, "deadline": 1109, "deleted_echo_indices": [], "low": false, "borrow_from": 266, "retirement_B_event": -1, "retirement_frame": 95, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1109, "handoff_basis": [486, 65, 20, 10], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [400, 69, 35, 14]}, {"register": 646, "base": 640, "common_basis": [423, 65, 20, 10], "dimension": 4, "deadline": 1109, "deleted_echo_indices": [], "low": false, "borrow_from": 259, "retirement_B_event": -1, "retirement_frame": 95, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1109, "handoff_basis": [486, 65, 20, 10], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [400, 69, 35, 14]}, {"register": 659, "base": 656, "common_basis": [427, 96, 24, 6], "dimension": 4, "deadline": 1125, "deleted_echo_indices": [], "low": false, "borrow_from": 333, "retirement_B_event": 788, "retirement_frame": 211, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1125, "handoff_basis": [459, 96, 24, 6], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [266, 138, 75, 30]}, {"register": 661, "base": 656, "common_basis": [427, 96, 24, 6], "dimension": 4, "deadline": 1125, "deleted_echo_indices": [], "low": false, "borrow_from": 317, "retirement_B_event": 769, "retirement_frame": 182, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1125, "handoff_basis": [459, 96, 24, 6], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [385, 74, 44, 30]}, {"register": 651, "base": 648, "common_basis": [288, 160, 75, 25, 7], "dimension": 5, "deadline": 1117, "deleted_echo_indices": [], "low": false, "borrow_from": 554, "retirement_B_event": 1053, "retirement_frame": 734, "retirement_dimension": 5, "old_final_dimension": 8, "handoff_B": 1117, "handoff_basis": [384, 160, 75, 25, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [388, 67, 33, 18, 12]}, {"register": 683, "base": 680, "common_basis": [407, 66, 36, 9], "dimension": 4, "deadline": 1149, "deleted_echo_indices": [], "low": false, "borrow_from": 285, "retirement_B_event": 733, "retirement_frame": 124, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1149, "handoff_basis": [469, 66, 36, 9], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [388, 75, 41, 26]}, {"register": 686, "base": 680, "common_basis": [407, 66, 36, 9], "dimension": 4, "deadline": 1149, "deleted_echo_indices": [], "low": false, "borrow_from": 281, "retirement_B_event": 731, "retirement_frame": 124, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1149, "handoff_basis": [469, 66, 36, 9], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [388, 75, 41, 26]}, {"register": 699, "base": 696, "common_basis": [455, 33, 18, 12], "dimension": 4, "deadline": 1165, "deleted_echo_indices": [], "low": false, "borrow_from": 301, "retirement_B_event": 751, "retirement_frame": 153, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1165, "handoff_basis": [455, 33, 18, 12], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [273, 145, 85, 51]}, {"register": 702, "base": 696, "common_basis": [455, 33, 18, 12], "dimension": 4, "deadline": 1165, "deleted_echo_indices": [], "low": false, "borrow_from": 297, "retirement_B_event": 749, "retirement_frame": 153, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1165, "handoff_basis": [455, 33, 18, 12], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [273, 145, 85, 51]}, {"register": 703, "base": 696, "common_basis": [455, 33, 18, 12], "dimension": 4, "deadline": 1165, "deleted_echo_indices": [], "low": false, "borrow_from": 313, "retirement_B_event": 767, "retirement_frame": 182, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1165, "handoff_basis": [455, 33, 18, 12], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [385, 74, 44, 30]}, {"register": 701, "base": 696, "common_basis": [455, 33, 18, 12], "dimension": 4, "deadline": 1165, "deleted_echo_indices": [], "low": false, "borrow_from": 329, "retirement_B_event": 786, "retirement_frame": 211, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1165, "handoff_basis": [455, 33, 18, 12], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [266, 138, 75, 30]}, {"register": 595, "base": 592, "common_basis": [320, 192, 45, 30], "dimension": 4, "deadline": 1061, "deleted_echo_indices": [], "low": false, "borrow_from": 349, "retirement_B_event": 807, "retirement_frame": 240, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1061, "handoff_basis": [320, 192, 45, 30], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [416, 70, 19, 13]}, {"register": 695, "base": 688, "common_basis": [258, 130, 85, 45], "dimension": 4, "deadline": 1157, "deleted_echo_indices": [], "low": false, "borrow_from": 345, "retirement_B_event": 805, "retirement_frame": 240, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1157, "handoff_basis": [384, 130, 85, 45], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [416, 70, 19, 13]}, {"register": 598, "base": 592, "common_basis": [320, 192, 45, 30], "dimension": 4, "deadline": 1061, "deleted_echo_indices": [], "low": false, "borrow_from": 365, "retirement_B_event": 825, "retirement_frame": 269, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1061, "handoff_basis": [320, 192, 45, 30], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [262, 134, 102, 30]}, {"register": 599, "base": 592, "common_basis": [320, 192, 45, 30], "dimension": 4, "deadline": 1061, "deleted_echo_indices": [], "low": false, "borrow_from": 361, "retirement_B_event": 823, "retirement_frame": 269, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1061, "handoff_basis": [320, 192, 45, 30], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [262, 134, 102, 30]}, {"register": 694, "base": 688, "common_basis": [258, 130, 85, 45], "dimension": 4, "deadline": 1157, "deleted_echo_indices": [], "low": false, "borrow_from": 381, "retirement_B_event": 843, "retirement_frame": 298, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1157, "handoff_basis": [384, 130, 85, 45], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [392, 67, 37, 22]}, {"register": 693, "base": 688, "common_basis": [258, 130, 85, 45], "dimension": 4, "deadline": 1157, "deleted_echo_indices": [], "low": false, "borrow_from": 377, "retirement_B_event": 841, "retirement_frame": 298, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1157, "handoff_basis": [384, 130, 85, 45], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [392, 67, 37, 22]}, {"register": 691, "base": 688, "common_basis": [258, 130, 85, 45], "dimension": 4, "deadline": 1157, "deleted_echo_indices": [], "low": false, "borrow_from": 397, "retirement_B_event": 861, "retirement_frame": 327, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1157, "handoff_basis": [384, 130, 85, 45], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [259, 131, 75, 51]}, {"register": 687, "base": 680, "common_basis": [407, 66, 36, 9], "dimension": 4, "deadline": 1149, "deleted_echo_indices": [], "low": false, "borrow_from": 393, "retirement_B_event": 859, "retirement_frame": 327, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1149, "handoff_basis": [469, 66, 36, 9], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [259, 131, 75, 51]}, {"register": 685, "base": 680, "common_basis": [407, 66, 36, 9], "dimension": 4, "deadline": 1149, "deleted_echo_indices": [], "low": false, "borrow_from": 225, "retirement_B_event": -1, "retirement_frame": 37, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1149, "handoff_basis": [469, 66, 36, 9], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [448, 38, 21, 11]}, {"register": 679, "base": 672, "common_basis": [413, 72, 48, 3], "dimension": 4, "deadline": 1141, "deleted_echo_indices": [], "low": false, "borrow_from": 227, "retirement_B_event": -1, "retirement_frame": 37, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1141, "handoff_basis": [469, 72, 48, 3], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [448, 38, 21, 11]}, {"register": 678, "base": 672, "common_basis": [413, 72, 48, 3], "dimension": 4, "deadline": 1141, "deleted_echo_indices": [], "low": false, "borrow_from": 229, "retirement_B_event": -1, "retirement_frame": 37, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1141, "handoff_basis": [469, 72, 48, 3], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [448, 38, 21, 11]}, {"register": 677, "base": 672, "common_basis": [413, 72, 48, 3], "dimension": 4, "deadline": 1141, "deleted_echo_indices": [], "low": false, "borrow_from": 234, "retirement_B_event": -1, "retirement_frame": 37, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1141, "handoff_basis": [469, 72, 48, 3], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [448, 38, 21, 11]}, {"register": 675, "base": 672, "common_basis": [413, 72, 48, 3], "dimension": 4, "deadline": 1141, "deleted_echo_indices": [], "low": false, "borrow_from": 241, "retirement_B_event": -1, "retirement_frame": 66, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1141, "handoff_basis": [469, 72, 48, 3], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [261, 133, 85, 45]}, {"register": 663, "base": 656, "common_basis": [427, 96, 24, 6], "dimension": 4, "deadline": 1125, "deleted_echo_indices": [], "low": false, "borrow_from": 245, "retirement_B_event": -1, "retirement_frame": 66, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1125, "handoff_basis": [459, 96, 24, 6], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [261, 133, 85, 45]}, {"register": 662, "base": 656, "common_basis": [427, 96, 24, 6], "dimension": 4, "deadline": 1125, "deleted_echo_indices": [], "low": false, "borrow_from": 257, "retirement_B_event": -1, "retirement_frame": 95, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1125, "handoff_basis": [459, 96, 24, 6], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [400, 69, 35, 14]}, {"register": 647, "base": 640, "common_basis": [423, 65, 20, 10], "dimension": 4, "deadline": 1109, "deleted_echo_indices": [], "low": false, "borrow_from": 261, "retirement_B_event": -1, "retirement_frame": 95, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1109, "handoff_basis": [486, 65, 20, 10], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [400, 69, 35, 14]}, {"register": 653, "base": 648, "common_basis": [288, 160, 75, 25, 7], "dimension": 5, "deadline": 1117, "deleted_echo_indices": [], "low": false, "borrow_from": 73, "retirement_B_event": 954, "retirement_frame": 635, "retirement_dimension": 5, "old_final_dimension": 9, "handoff_B": 1117, "handoff_basis": [384, 160, 75, 25, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [320, 192, 32, 19, 13]}, {"register": 603, "base": 600, "common_basis": [409, 80, 40, 5, 2], "dimension": 5, "deadline": 1069, "deleted_echo_indices": [], "low": false, "borrow_from": 401, "retirement_B_event": -1, "retirement_frame": 356, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1069, "handoff_basis": [80, 40, 5, 2], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [265, 137, 75, 45]}, {"register": 605, "base": 600, "common_basis": [409, 80, 40, 5, 2], "dimension": 5, "deadline": 1069, "deleted_echo_indices": [], "low": false, "borrow_from": 403, "retirement_B_event": -1, "retirement_frame": 356, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1069, "handoff_basis": [80, 40, 5, 2], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [265, 137, 75, 45]}, {"register": 607, "base": 600, "common_basis": [409, 80, 40, 5, 2], "dimension": 5, "deadline": 1069, "deleted_echo_indices": [], "low": false, "borrow_from": 405, "retirement_B_event": -1, "retirement_frame": 356, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1069, "handoff_basis": [80, 40, 5, 2], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [265, 137, 75, 45]}, {"register": 611, "base": 608, "common_basis": [272, 144, 75, 42, 7], "dimension": 5, "deadline": 1077, "deleted_echo_indices": [], "low": false, "borrow_from": 410, "retirement_B_event": -1, "retirement_frame": 356, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1077, "handoff_basis": [144, 75, 42, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [265, 137, 75, 45]}, {"register": 613, "base": 608, "common_basis": [272, 144, 75, 42, 7], "dimension": 5, "deadline": 1077, "deleted_echo_indices": [], "low": false, "borrow_from": 417, "retirement_B_event": -1, "retirement_frame": 385, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1077, "handoff_basis": [144, 75, 42, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [386, 73, 45, 28]}, {"register": 614, "base": 608, "common_basis": [272, 144, 75, 42, 7], "dimension": 5, "deadline": 1077, "deleted_echo_indices": [], "low": false, "borrow_from": 419, "retirement_B_event": -1, "retirement_frame": 385, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1077, "handoff_basis": [144, 75, 42, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [386, 73, 45, 28]}, {"register": 615, "base": 608, "common_basis": [272, 144, 75, 42, 7], "dimension": 5, "deadline": 1077, "deleted_echo_indices": [], "low": false, "borrow_from": 421, "retirement_B_event": -1, "retirement_frame": 385, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1077, "handoff_basis": [144, 75, 42, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [386, 73, 45, 28]}, {"register": 627, "base": 624, "common_basis": [391, 68, 34, 17, 8], "dimension": 5, "deadline": 1093, "deleted_echo_indices": [], "low": false, "borrow_from": 426, "retirement_B_event": -1, "retirement_frame": 385, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1093, "handoff_basis": [68, 34, 17, 8], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [386, 73, 45, 28]}, {"register": 629, "base": 624, "common_basis": [391, 68, 34, 17, 8], "dimension": 5, "deadline": 1093, "deleted_echo_indices": [], "low": false, "borrow_from": 433, "retirement_B_event": -1, "retirement_frame": 414, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1093, "handoff_basis": [68, 34, 17, 8], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [268, 140, 45, 30]}, {"register": 630, "base": 624, "common_basis": [391, 68, 34, 17, 8], "dimension": 5, "deadline": 1093, "deleted_echo_indices": [], "low": false, "borrow_from": 435, "retirement_B_event": -1, "retirement_frame": 414, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1093, "handoff_basis": [68, 34, 17, 8], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [268, 140, 45, 30]}, {"register": 631, "base": 624, "common_basis": [391, 68, 34, 17, 8], "dimension": 5, "deadline": 1093, "deleted_echo_indices": [], "low": false, "borrow_from": 437, "retirement_B_event": -1, "retirement_frame": 414, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1093, "handoff_basis": [68, 34, 17, 8], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [268, 140, 45, 30]}, {"register": 655, "base": 648, "common_basis": [288, 160, 75, 25, 7], "dimension": 5, "deadline": 1117, "deleted_echo_indices": [], "low": false, "borrow_from": 442, "retirement_B_event": -1, "retirement_frame": 414, "retirement_dimension": 4, "old_final_dimension": 9, "handoff_B": 1117, "handoff_basis": [384, 160, 75, 25], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [268, 140, 45, 30]}, {"register": 654, "base": 648, "common_basis": [288, 160, 75, 25, 7], "dimension": 5, "deadline": 1117, "deleted_echo_indices": [], "low": false, "borrow_from": 542, "retirement_B_event": 1057, "retirement_frame": 738, "retirement_dimension": 5, "old_final_dimension": 9, "handoff_B": 1117, "handoff_basis": [384, 160, 75, 25, 7], "handoff_paid_rank": 0, "anticipate": false, "retirement_basis": [262, 193, 33, 18, 12]}], "initial_corrections": [], "early_tail_events": [{"old_tail_index": 34, "before_B": 734, "gate": ["add", 282, 285, -1, 1, 124]}, {"old_tail_index": 35, "before_B": 734, "gate": ["scale", 282, 1, -1, 124]}, {"old_tail_index": 36, "before_B": 732, "gate": ["add", 277, 281, -1, 1, 124]}, {"old_tail_index": 37, "before_B": 732, "gate": ["scale", 277, 1, -1, 124]}, {"old_tail_index": 38, "before_B": 735, "gate": ["add", 275, 31, -1, 1, 124]}, {"old_tail_index": 39, "before_B": 733, "gate": ["add", 273, 12, -1, 1, 124]}, {"old_tail_index": 40, "before_B": 752, "gate": ["add", 298, 301, -1, 1, 153]}, {"old_tail_index": 41, "before_B": 752, "gate": ["scale", 298, 1, -1, 153]}, {"old_tail_index": 42, "before_B": 750, "gate": ["add", 293, 297, -1, 1, 153]}, {"old_tail_index": 43, "before_B": 750, "gate": ["scale", 293, 1, -1, 153]}, {"old_tail_index": 44, "before_B": 753, "gate": ["add", 291, 55, -1, 1, 153]}, {"old_tail_index": 45, "before_B": 751, "gate": ["add", 289, 101, -1, 1, 153]}, {"old_tail_index": 46, "before_B": 770, "gate": ["add", 314, 317, -1, 1, 182]}, {"old_tail_index": 47, "before_B": 770, "gate": ["scale", 314, 1, -1, 182]}, {"old_tail_index": 48, "before_B": 768, "gate": ["add", 309, 313, -1, 1, 182]}, {"old_tail_index": 49, "before_B": 768, "gate": ["scale", 309, 1, -1, 182]}, {"old_tail_index": 50, "before_B": 771, "gate": ["add", 307, 85, -1, 1, 182]}, {"old_tail_index": 51, "before_B": 769, "gate": ["add", 305, 98, -1, 1, 182]}, {"old_tail_index": 52, "before_B": 789, "gate": ["add", 330, 333, -1, 1, 211]}, {"old_tail_index": 53, "before_B": 789, "gate": ["scale", 330, 1, -1, 211]}, {"old_tail_index": 54, "before_B": 787, "gate": ["add", 325, 329, -1, 1, 211]}, {"old_tail_index": 55, "before_B": 787, "gate": ["scale", 325, 1, -1, 211]}, {"old_tail_index": 56, "before_B": 790, "gate": ["add", 323, 33, -1, 1, 211]}, {"old_tail_index": 57, "before_B": 788, "gate": ["add", 321, 49, -1, 1, 211]}, {"old_tail_index": 58, "before_B": 808, "gate": ["add", 346, 349, -1, 1, 240]}, {"old_tail_index": 59, "before_B": 808, "gate": ["scale", 346, 1, -1, 240]}, {"old_tail_index": 60, "before_B": 806, "gate": ["add", 341, 345, -1, 1, 240]}, {"old_tail_index": 61, "before_B": 806, "gate": ["scale", 341, 1, -1, 240]}, {"old_tail_index": 62, "before_B": 809, "gate": ["add", 339, 1, -1, 1, 240]}, {"old_tail_index": 63, "before_B": 807, "gate": ["add", 337, 6, -1, 1, 240]}, {"old_tail_index": 64, "before_B": 826, "gate": ["add", 362, 365, -1, 1, 269]}, {"old_tail_index": 65, "before_B": 826, "gate": ["scale", 362, 1, -1, 269]}, {"old_tail_index": 66, "before_B": 824, "gate": ["add", 357, 361, -1, 1, 269]}, {"old_tail_index": 67, "before_B": 824, "gate": ["scale", 357, 1, -1, 269]}, {"old_tail_index": 68, "before_B": 827, "gate": ["add", 355, 74, -1, 1, 269]}, {"old_tail_index": 69, "before_B": 825, "gate": ["add", 353, 83, -1, 1, 269]}, {"old_tail_index": 70, "before_B": 844, "gate": ["add", 378, 381, -1, 1, 298]}, {"old_tail_index": 71, "before_B": 844, "gate": ["scale", 378, 1, -1, 298]}, {"old_tail_index": 72, "before_B": 842, "gate": ["add", 373, 377, -1, 1, 298]}, {"old_tail_index": 73, "before_B": 842, "gate": ["scale", 373, 1, -1, 298]}, {"old_tail_index": 74, "before_B": 845, "gate": ["add", 371, 88, -1, 1, 298]}, {"old_tail_index": 75, "before_B": 843, "gate": ["add", 369, 80, -1, 1, 298]}, {"old_tail_index": 76, "before_B": 862, "gate": ["add", 394, 397, -1, 1, 327]}, {"old_tail_index": 77, "before_B": 862, "gate": ["scale", 394, 1, -1, 327]}, {"old_tail_index": 78, "before_B": 860, "gate": ["add", 389, 393, -1, 1, 327]}, {"old_tail_index": 79, "before_B": 860, "gate": ["scale", 389, 1, -1, 327]}, {"old_tail_index": 80, "before_B": 863, "gate": ["add", 387, 4, -1, 1, 327]}, {"old_tail_index": 81, "before_B": 861, "gate": ["add", 385, 68, -1, 1, 327]}], "replay": {"status": "PASS_EXACT_FREE_OPERATOR_BORROWING_REPLAY", "local_profile": {"1": 2339, "2": 509, "3": 418, "4": 125, "5": 42, "8": 8}, "local_mass": 5385, "remaining_registers": 661, "zero_FULL_cleanup_buffers": 76, "exact_cold_restoration": [{"register": 273, "frame": 124, "preparation": {"273": "1"}}, {"register": 275, "frame": 124, "preparation": {"275": "1"}}, {"register": 277, "frame": 124, "preparation": {"277": "1"}}, {"register": 282, "frame": 124, "preparation": {"282": "1"}}, {"register": 289, "frame": 153, "preparation": {"289": "1"}}, {"register": 291, "frame": 153, "preparation": {"291": "1"}}, {"register": 293, "frame": 153, "preparation": {"293": "1"}}, {"register": 298, "frame": 153, "preparation": {"298": "1"}}, {"register": 305, "frame": 182, "preparation": {"305": "1"}}, {"register": 307, "frame": 182, "preparation": {"307": "1"}}, {"register": 309, "frame": 182, "preparation": {"309": "1"}}, {"register": 314, "frame": 182, "preparation": {"314": "1"}}, {"register": 321, "frame": 211, "preparation": {"321": "1"}}, {"register": 323, "frame": 211, "preparation": {"323": "1"}}, {"register": 325, "frame": 211, "preparation": {"325": "1"}}, {"register": 330, "frame": 211, "preparation": {"330": "1"}}, {"register": 337, "frame": 240, "preparation": {"337": "1"}}, {"register": 339, "frame": 240, "preparation": {"339": "1"}}, {"register": 341, "frame": 240, "preparation": {"341": "1"}}, {"register": 346, "frame": 240, "preparation": {"346": "1"}}, {"register": 353, "frame": 269, "preparation": {"353": "1"}}, {"register": 355, "frame": 269, "preparation": {"355": "1"}}, {"register": 357, "frame": 269, "preparation": {"357": "1"}}, {"register": 362, "frame": 269, "preparation": {"362": "1"}}, {"register": 369, "frame": 298, "preparation": {"369": "1"}}, {"register": 371, "frame": 298, "preparation": {"371": "1"}}, {"register": 373, "frame": 298, "preparation": {"373": "1"}}, {"register": 378, "frame": 298, "preparation": {"378": "1"}}, {"register": 385, "frame": 327, "preparation": {"385": "1"}}, {"register": 387, "frame": 327, "preparation": {"387": "1"}}, {"register": 389, "frame": 327, "preparation": {"389": "1"}}, {"register": 394, "frame": 327, "preparation": {"394": "1"}}, {"register": 572, "frame": 1005, "preparation": {"572": "1", "408": "-1"}}, {"register": 573, "frame": 1005, "preparation": {"573": "1", "105": "-1"}}, {"register": 574, "frame": 1004, "preparation": {"574": "1", "412": "-1"}}, {"register": 575, "frame": 1004, "preparation": {"575": "1", "414": "-1"}}, {"register": 580, "frame": 1006, "preparation": {"580": "1", "424": "-1"}}, {"register": 581, "frame": 1006, "preparation": {"581": "1", "44": "-1"}}, {"register": 582, "frame": 1007, "preparation": {"582": "1", "428": "-1"}}, {"register": 583, "frame": 1007, "preparation": {"583": "1", "430": "-1"}}, {"register": 311, "frame": 1003, "preparation": {"498": "1", "311": "-1"}}, {"register": 327, "frame": 1002, "preparation": {"511": "1", "322": "-1"}}, {"register": 448, "frame": 998, "preparation": {"448": "1", "231": "-1"}}, {"register": 449, "frame": 998, "preparation": {"449": "1", "226": "-1"}}, {"register": 450, "frame": 999, "preparation": {"450": "1", "230": "-1"}}, {"register": 451, "frame": 999, "preparation": {"451": "1", "228": "-1"}}, {"register": 452, "frame": 999, "preparation": {"452": "1", "232": "-1"}}, {"register": 453, "frame": 999, "preparation": {"453": "1", "7": "-1"}}, {"register": 454, "frame": 998, "preparation": {"454": "1", "236": "-1"}}, {"register": 455, "frame": 998, "preparation": {"455": "1", "238": "-1"}}, {"register": 484, "frame": 998, "preparation": {"484": "1", "231": "-1", "299": "-1"}}, {"register": 485, "frame": 998, "preparation": {"485": "1", "226": "-1", "54": "-1"}}, {"register": 498, "frame": 1003, "preparation": {"499": "1", "306": "-1"}}, {"register": 500, "frame": 1001, "preparation": {"500": "1", "310": "-1"}}, {"register": 501, "frame": 1001, "preparation": {"501": "1", "308": "-1"}}, {"register": 508, "frame": 999, "preparation": {"508": "1", "331": "-1", "230": "-1"}}, {"register": 509, "frame": 999, "preparation": {"509": "1", "228": "-1", "34": "-1"}}, {"register": 510, "frame": 1002, "preparation": {"511": "-1", "510": "1"}}, {"register": 512, "frame": 1000, "preparation": {"512": "1", "326": "-1"}}, {"register": 513, "frame": 1000, "preparation": {"513": "1", "324": "-1"}}, {"register": 531, "frame": 999, "preparation": {"531": "1", "351": "-1", "587": "-1/2"}}, {"register": 532, "frame": 999, "preparation": {"532": "1", "363": "-1", "232": "2"}}, {"register": 543, "frame": 999, "preparation": {"543": "1", "367": "-1", "589": "1"}}, {"register": 555, "frame": 998, "preparation": {"555": "1", "383": "-1", "585": "-1/2"}}, {"register": 556, "frame": 998, "preparation": {"556": "1", "236": "2", "395": "-1"}}, {"register": 557, "frame": 998, "preparation": {"557": "1", "5": "-1", "238": "2"}}, {"register": 566, "frame": 998, "preparation": {"566": "1", "69": "-1"}}, {"register": 567, "frame": 998, "preparation": {"567": "1", "399": "-1", "591": "1"}}, {"register": 584, "frame": 998, "preparation": {"584": "1", "439": "-1"}}, {"register": 585, "frame": 998, "preparation": {"585": "1", "434": "-1"}}, {"register": 586, "frame": 999, "preparation": {"586": "1", "438": "-1"}}, {"register": 587, "frame": 999, "preparation": {"587": "1", "436": "-1"}}, {"register": 588, "frame": 999, "preparation": {"588": "1", "440": "-1"}}, {"register": 589, "frame": 999, "preparation": {"589": "1", "46": "-1"}}, {"register": 590, "frame": 998, "preparation": {"590": "1", "444": "-1"}}, {"register": 591, "frame": 998, "preparation": {"591": "1", "446": "-1"}}], "symbolic_warps": [{"operator": 1, "borrow_from": 243, "removed": 597, "from_basis": [261, 133, 85, 45], "to_basis": [320, 192, 45, 30], "physical_handoff_rank": 0}, {"operator": 14, "borrow_from": 349, "removed": 595, "from_basis": [416, 70, 19, 13], "to_basis": [320, 192, 45, 30], "physical_handoff_rank": 0}, {"operator": 16, "borrow_from": 365, "removed": 598, "from_basis": [262, 134, 102, 30], "to_basis": [320, 192, 45, 30], "physical_handoff_rank": 0}, {"operator": 17, "borrow_from": 361, "removed": 599, "from_basis": [262, 134, 102, 30], "to_basis": [320, 192, 45, 30], "physical_handoff_rank": 0}, {"operator": 31, "borrow_from": 401, "removed": 603, "from_basis": [265, 137, 75, 45], "to_basis": [80, 40, 5, 2], "physical_handoff_rank": 0}, {"operator": 32, "borrow_from": 403, "removed": 605, "from_basis": [265, 137, 75, 45], "to_basis": [80, 40, 5, 2], "physical_handoff_rank": 0}, {"operator": 33, "borrow_from": 405, "removed": 607, "from_basis": [265, 137, 75, 45], "to_basis": [80, 40, 5, 2], "physical_handoff_rank": 0}, {"operator": 34, "borrow_from": 410, "removed": 611, "from_basis": [265, 137, 75, 45], "to_basis": [144, 75, 42, 7], "physical_handoff_rank": 0}, {"operator": 35, "borrow_from": 417, "removed": 613, "from_basis": [386, 73, 45, 28], "to_basis": [144, 75, 42, 7], "physical_handoff_rank": 0}, {"operator": 36, "borrow_from": 419, "removed": 614, "from_basis": [386, 73, 45, 28], "to_basis": [144, 75, 42, 7], "physical_handoff_rank": 0}, {"operator": 37, "borrow_from": 421, "removed": 615, "from_basis": [386, 73, 45, 28], "to_basis": [144, 75, 42, 7], "physical_handoff_rank": 0}, {"operator": 38, "borrow_from": 426, "removed": 627, "from_basis": [386, 73, 45, 28], "to_basis": [68, 34, 17, 8], "physical_handoff_rank": 0}, {"operator": 39, "borrow_from": 433, "removed": 629, "from_basis": [268, 140, 45, 30], "to_basis": [68, 34, 17, 8], "physical_handoff_rank": 0}, {"operator": 40, "borrow_from": 435, "removed": 630, "from_basis": [268, 140, 45, 30], "to_basis": [68, 34, 17, 8], "physical_handoff_rank": 0}, {"operator": 41, "borrow_from": 437, "removed": 631, "from_basis": [268, 140, 45, 30], "to_basis": [68, 34, 17, 8], "physical_handoff_rank": 0}, {"operator": 2, "borrow_from": 250, "removed": 643, "from_basis": [261, 133, 85, 45], "to_basis": [486, 65, 20, 10], "physical_handoff_rank": 0}, {"operator": 3, "borrow_from": 266, "removed": 645, "from_basis": [400, 69, 35, 14], "to_basis": [486, 65, 20, 10], "physical_handoff_rank": 0}, {"operator": 4, "borrow_from": 259, "removed": 646, "from_basis": [400, 69, 35, 14], "to_basis": [486, 65, 20, 10], "physical_handoff_rank": 0}, {"operator": 29, "borrow_from": 261, "removed": 647, "from_basis": [400, 69, 35, 14], "to_basis": [486, 65, 20, 10], "physical_handoff_rank": 0}, {"operator": 7, "borrow_from": 554, "removed": 651, "from_basis": [388, 67, 33, 18, 12], "to_basis": [384, 160, 75, 25, 7], "physical_handoff_rank": 0}, {"operator": 30, "borrow_from": 73, "removed": 653, "from_basis": [320, 192, 32, 19, 13], "to_basis": [384, 160, 75, 25, 7], "physical_handoff_rank": 0}, {"operator": 42, "borrow_from": 442, "removed": 655, "from_basis": [268, 140, 45, 30], "to_basis": [384, 160, 75, 25], "physical_handoff_rank": 0}, {"operator": 43, "borrow_from": 542, "removed": 654, "from_basis": [262, 193, 33, 18, 12], "to_basis": [384, 160, 75, 25, 7], "physical_handoff_rank": 0}, {"operator": 5, "borrow_from": 333, "removed": 659, "from_basis": [266, 138, 75, 30], "to_basis": [459, 96, 24, 6], "physical_handoff_rank": 0}, {"operator": 6, "borrow_from": 317, "removed": 661, "from_basis": [385, 74, 44, 30], "to_basis": [459, 96, 24, 6], "physical_handoff_rank": 0}, {"operator": 27, "borrow_from": 245, "removed": 663, "from_basis": [261, 133, 85, 45], "to_basis": [459, 96, 24, 6], "physical_handoff_rank": 0}, {"operator": 28, "borrow_from": 257, "removed": 662, "from_basis": [400, 69, 35, 14], "to_basis": [459, 96, 24, 6], "physical_handoff_rank": 0}, {"operator": 23, "borrow_from": 227, "removed": 679, "from_basis": [448, 38, 21, 11], "to_basis": [469, 72, 48, 3], "physical_handoff_rank": 0}, {"operator": 24, "borrow_from": 229, "removed": 678, "from_basis": [448, 38, 21, 11], "to_basis": [469, 72, 48, 3], "physical_handoff_rank": 0}, {"operator": 25, "borrow_from": 234, "removed": 677, "from_basis": [448, 38, 21, 11], "to_basis": [469, 72, 48, 3], "physical_handoff_rank": 0}, {"operator": 26, "borrow_from": 241, "removed": 675, "from_basis": [261, 133, 85, 45], "to_basis": [469, 72, 48, 3], "physical_handoff_rank": 0}, {"operator": 8, "borrow_from": 285, "removed": 683, "from_basis": [388, 75, 41, 26], "to_basis": [469, 66, 36, 9], "physical_handoff_rank": 0}, {"operator": 9, "borrow_from": 281, "removed": 686, "from_basis": [388, 75, 41, 26], "to_basis": [469, 66, 36, 9], "physical_handoff_rank": 0}, {"operator": 21, "borrow_from": 393, "removed": 687, "from_basis": [259, 131, 75, 51], "to_basis": [469, 66, 36, 9], "physical_handoff_rank": 0}, {"operator": 22, "borrow_from": 225, "removed": 685, "from_basis": [448, 38, 21, 11], "to_basis": [469, 66, 36, 9], "physical_handoff_rank": 0}, {"operator": 15, "borrow_from": 345, "removed": 695, "from_basis": [416, 70, 19, 13], "to_basis": [384, 130, 85, 45], "physical_handoff_rank": 0}, {"operator": 18, "borrow_from": 381, "removed": 694, "from_basis": [392, 67, 37, 22], "to_basis": [384, 130, 85, 45], "physical_handoff_rank": 0}, {"operator": 19, "borrow_from": 377, "removed": 693, "from_basis": [392, 67, 37, 22], "to_basis": [384, 130, 85, 45], "physical_handoff_rank": 0}, {"operator": 20, "borrow_from": 397, "removed": 691, "from_basis": [259, 131, 75, 51], "to_basis": [384, 130, 85, 45], "physical_handoff_rank": 0}, {"operator": 10, "borrow_from": 301, "removed": 699, "from_basis": [273, 145, 85, 51], "to_basis": [455, 33, 18, 12], "physical_handoff_rank": 0}, {"operator": 11, "borrow_from": 297, "removed": 702, "from_basis": [273, 145, 85, 51], "to_basis": [455, 33, 18, 12], "physical_handoff_rank": 0}, {"operator": 12, "borrow_from": 313, "removed": 703, "from_basis": [385, 74, 44, 30], "to_basis": [455, 33, 18, 12], "physical_handoff_rank": 0}, {"operator": 13, "borrow_from": 329, "removed": 701, "from_basis": [266, 138, 75, 30], "to_basis": [455, 33, 18, 12], "physical_handoff_rank": 0}]}, "gaussian": {"status": "PASS_EXACT_GAUSSIAN_BORROW_HANDOFFS", "operators": 43, "records": [{"operator": 1, "G_columns": [1, 2, 4, 8, 64, 19, 104, 197, 325], "handoff_exact_monomial_sha256": "6cf8c0f9b98f3f5b3fc8b5cc39734c2a340bdde82b7013e9b77f12930b816490", "full_exit_exact_monomial_sha256": "270a211e83af324abd684553bedbcafb54aa0f2d882124d2120566884a9d7959"}, {"operator": 14, "G_columns": [1, 2, 4, 27, 46, 8, 198, 64, 264], "handoff_exact_monomial_sha256": "409dcf3130f1420b7a9f53a000956599f07e670a81747d51895826f9753a1b02", "full_exit_exact_monomial_sha256": "726e078d38693898e271f2870e25422f7f0b89a5042f05e92246260497abce5a"}, {"operator": 16, "G_columns": [1, 2, 4, 8, 16, 64, 107, 198, 326], "handoff_exact_monomial_sha256": "128488b96c4be786bca41db2dd094730dfe5ba743ada1e41df2148f3d4ea1684", "full_exit_exact_monomial_sha256": "2de4692a470bc8807c2c93b9bfdde380c12422c5ab7eb258e6a6a469c0274fd2"}, {"operator": 17, "G_columns": [1, 2, 4, 8, 16, 64, 107, 198, 326], "handoff_exact_monomial_sha256": "128488b96c4be786bca41db2dd094730dfe5ba743ada1e41df2148f3d4ea1684", "full_exit_exact_monomial_sha256": "2de4692a470bc8807c2c93b9bfdde380c12422c5ab7eb258e6a6a469c0274fd2"}, {"operator": 31, "G_columns": [1, 8, 16, 128, 256, 147, 140, 169, 209], "handoff_exact_monomial_sha256": "92f7d354f79c5184db61c3266271bbdb5a503848925289336cf1f74731916572", "full_exit_exact_monomial_sha256": "9524c1b6e789428fdf922bdcba1039c0a161c8a92e3fde97a412840e90e0d09d"}, {"operator": 32, "G_columns": [1, 8, 16, 128, 256, 147, 140, 169, 209], "handoff_exact_monomial_sha256": "92f7d354f79c5184db61c3266271bbdb5a503848925289336cf1f74731916572", "full_exit_exact_monomial_sha256": "9524c1b6e789428fdf922bdcba1039c0a161c8a92e3fde97a412840e90e0d09d"}, {"operator": 33, "G_columns": [1, 8, 16, 128, 256, 147, 140, 169, 209], "handoff_exact_monomial_sha256": "92f7d354f79c5184db61c3266271bbdb5a503848925289336cf1f74731916572", "full_exit_exact_monomial_sha256": "9524c1b6e789428fdf922bdcba1039c0a161c8a92e3fde97a412840e90e0d09d"}, {"operator": 34, "G_columns": [1, 2, 8, 16, 256, 30, 57, 90, 129], "handoff_exact_monomial_sha256": "a110db1ecdf22c9fb177ba8da8022231d8c498aca5114e846ee96be1f3930a78", "full_exit_exact_monomial_sha256": "a2acaaa3f8426dd5fcddc0963dc028f3935edc0f8b8db21e64b3b13651c4794d"}, {"operator": 35, "G_columns": [1, 2, 8, 16, 31, 51, 90, 256, 402], "handoff_exact_monomial_sha256": "fe18b6b1d93e1bd2dfc42c93ae0f3b7bd5b64f1dfe76c105c99b5597fbb23988", "full_exit_exact_monomial_sha256": "7ebe71197c980ded084c48963fe498382794bf3f57de6b9b3bca235d51a52949"}, {"operator": 36, "G_columns": [1, 2, 8, 16, 31, 51, 90, 256, 402], "handoff_exact_monomial_sha256": "fe18b6b1d93e1bd2dfc42c93ae0f3b7bd5b64f1dfe76c105c99b5597fbb23988", "full_exit_exact_monomial_sha256": "7ebe71197c980ded084c48963fe498382794bf3f57de6b9b3bca235d51a52949"}, {"operator": 37, "G_columns": [1, 2, 8, 16, 31, 51, 90, 256, 402], "handoff_exact_monomial_sha256": "fe18b6b1d93e1bd2dfc42c93ae0f3b7bd5b64f1dfe76c105c99b5597fbb23988", "full_exit_exact_monomial_sha256": "7ebe71197c980ded084c48963fe498382794bf3f57de6b9b3bca235d51a52949"}, {"operator": 38, "G_columns": [1, 2, 4, 128, 140, 148, 163, 256, 326], "handoff_exact_monomial_sha256": "62f2562e12a18ef2d8c268d2fdd1bfcb34684cea2dae09b217ac34110135c735", "full_exit_exact_monomial_sha256": "756453b9cc6e61dba03533c817ce262eac13900257fc69e640eef93a3201a200"}, {"operator": 39, "G_columns": [1, 2, 4, 128, 142, 148, 256, 166, 192], "handoff_exact_monomial_sha256": "dad763c2edceec567f5f9316d842bbf96789bfe7471a71c20ee14efc9c051875", "full_exit_exact_monomial_sha256": "f42354bd2ebea83322169e5e018eecdfb2e8dec803e0e8e0136da6153f96df36"}, {"operator": 40, "G_columns": [1, 2, 4, 128, 142, 148, 256, 166, 192], "handoff_exact_monomial_sha256": "dad763c2edceec567f5f9316d842bbf96789bfe7471a71c20ee14efc9c051875", "full_exit_exact_monomial_sha256": "f42354bd2ebea83322169e5e018eecdfb2e8dec803e0e8e0136da6153f96df36"}, {"operator": 41, "G_columns": [1, 2, 4, 128, 142, 148, 256, 166, 192], "handoff_exact_monomial_sha256": "dad763c2edceec567f5f9316d842bbf96789bfe7471a71c20ee14efc9c051875", "full_exit_exact_monomial_sha256": "f42354bd2ebea83322169e5e018eecdfb2e8dec803e0e8e0136da6153f96df36"}, {"operator": 2, "G_columns": [1, 2, 4, 32, 128, 47, 145, 68, 483], "handoff_exact_monomial_sha256": "274ab0dc9326a464b10185c96fbf4733d6d8a71072edc6177751f18c0bade9a0", "full_exit_exact_monomial_sha256": "4128f5981c0da1da48b95f9448451412b037a42ef0b87a20799e18afe86b2a84"}, {"operator": 3, "G_columns": [1, 2, 4, 12, 32, 23, 68, 128, 326], "handoff_exact_monomial_sha256": "3cbf1001720666131788bfaff5a9170b32261c3a1838ee8bf1cfcd065c79c8d2", "full_exit_exact_monomial_sha256": "716f8283675093de63d721830e4fad12fd8a39d2ffe7c752f05d21f3e4a33571"}, {"operator": 4, "G_columns": [1, 2, 4, 12, 32, 23, 68, 128, 326], "handoff_exact_monomial_sha256": "3cbf1001720666131788bfaff5a9170b32261c3a1838ee8bf1cfcd065c79c8d2", "full_exit_exact_monomial_sha256": "716f8283675093de63d721830e4fad12fd8a39d2ffe7c752f05d21f3e4a33571"}, {"operator": 29, "G_columns": [1, 2, 4, 12, 32, 23, 68, 128, 326], "handoff_exact_monomial_sha256": "3cbf1001720666131788bfaff5a9170b32261c3a1838ee8bf1cfcd065c79c8d2", "full_exit_exact_monomial_sha256": "716f8283675093de63d721830e4fad12fd8a39d2ffe7c752f05d21f3e4a33571"}, {"operator": 7, "G_columns": [1, 2, 8, 15, 27, 74, 163, 32, 424], "handoff_exact_monomial_sha256": "b5719508324b12420b01f10070d9158b8cda290715f4d7a263d45f2d68f6aa7c", "full_exit_exact_monomial_sha256": "fb97b382c57cbe403e5945283d28cfe1f1bb7ea8bd235f4872765e1f46b4c7fa"}, {"operator": 30, "G_columns": [1, 2, 8, 14, 26, 75, 32, 128, 416], "handoff_exact_monomial_sha256": "6efb2a4bb882d4c98dd8979c02bbc8c9954582b8f1ec1ec64c700c9d2c0de8f4", "full_exit_exact_monomial_sha256": "78a5a89545b60921ef7211cc049206a47f9ae3c28afdb53c9f25ec14b619335d"}, {"operator": 42, "G_columns": [1, 2, 4, 8, 23, 70, 32, 172, 396], "handoff_exact_monomial_sha256": "da2efaf833906b554c722a17cc7f074d87b909a8486423ffdc53e04b65372de0", "full_exit_exact_monomial_sha256": "b3633f1dfc8d6ad0d8eac3b953ba2cc217a83e681e4ac93aa41849460ecbeac9"}, {"operator": 43, "G_columns": [1, 2, 8, 15, 27, 74, 32, 129, 394], "handoff_exact_monomial_sha256": "230e6fecbc94c0cf2da12903787af836f323ad381aa32674d22233c107069db3", "full_exit_exact_monomial_sha256": "31d703f818e3e52a4c2768d30af947358093673cab0005d4c82a33accee62192"}, {"operator": 5, "G_columns": [1, 2, 8, 32, 44, 128, 59, 66, 489], "handoff_exact_monomial_sha256": "1058f8b951102c293951a04e36ad83b3e0ad7c4b372b8ecef8035dad5a18e1bf", "full_exit_exact_monomial_sha256": "f10368763cbdc46b83fb478fd50c2dc8391757e01f040fe67aae7e0020ce9860"}, {"operator": 6, "G_columns": [1, 2, 8, 32, 44, 48, 66, 128, 330], "handoff_exact_monomial_sha256": "09ec6b3f9fa181cdd0dac78d2c35b4594723a305960e8eb75e1ec3ee22cf2693", "full_exit_exact_monomial_sha256": "e93033cf83683623d8e52ed40b2429c2ef15523b61700441b88758d1af77ee30"}, {"operator": 27, "G_columns": [1, 2, 8, 32, 128, 47, 145, 105, 450], "handoff_exact_monomial_sha256": "94122f9a3de80d451b243e2e6473a8bc0f56d5c3625f0154cd99ab50fbbf022e", "full_exit_exact_monomial_sha256": "035484c8054886881108ee0cccb238df6bc0a3c1f785486ff9d3f419ce1f7dec"}, {"operator": 28, "G_columns": [1, 2, 8, 12, 32, 27, 105, 128, 363], "handoff_exact_monomial_sha256": "9950407ae3dafcbbb524121019a731b0bb3ea637a121bae2230499c8135296c7", "full_exit_exact_monomial_sha256": "fed181a27b1767b27418eda196bc3f8c9971d270783d0ecaec54547400e8a1ff"}, {"operator": 23, "G_columns": [1, 4, 8, 6, 57, 68, 16, 128, 325], "handoff_exact_monomial_sha256": "2dfc1e190b74d747165f8b25691dc73760c41f5a81d14c11f3b6fcdaacbf84a9", "full_exit_exact_monomial_sha256": "3a285b1adc2256fba3abc2bfd6fd2af9cbb1e623058268e950e49d3731d4b25b"}, {"operator": 24, "G_columns": [1, 4, 8, 6, 57, 68, 16, 128, 325], "handoff_exact_monomial_sha256": "2dfc1e190b74d747165f8b25691dc73760c41f5a81d14c11f3b6fcdaacbf84a9", "full_exit_exact_monomial_sha256": "3a285b1adc2256fba3abc2bfd6fd2af9cbb1e623058268e950e49d3731d4b25b"}, {"operator": 25, "G_columns": [1, 4, 8, 6, 57, 68, 16, 128, 325], "handoff_exact_monomial_sha256": "2dfc1e190b74d747165f8b25691dc73760c41f5a81d14c11f3b6fcdaacbf84a9", "full_exit_exact_monomial_sha256": "3a285b1adc2256fba3abc2bfd6fd2af9cbb1e623058268e950e49d3731d4b25b"}, {"operator": 26, "G_columns": [1, 4, 8, 16, 128, 26, 185, 65, 476], "handoff_exact_monomial_sha256": "313bb2ad48197e123504a494e7261c4f16f8345b61502472a505f5e8a4ffeed2", "full_exit_exact_monomial_sha256": "5183b631ae214ae8fcd40bb479ba34be715ba2bc497e4974afd327fd9422e099"}, {"operator": 8, "G_columns": [1, 2, 4, 16, 27, 53, 81, 128, 337], "handoff_exact_monomial_sha256": "1f0bc88ef72044371a1b248bf457df6baaf719b79f0b68f5b6344f882ab4279a", "full_exit_exact_monomial_sha256": "3f70bc24f57a78fedd30541c26a2ce7ae0bb03ef5c3d83848efb3bc3f790ea13"}, {"operator": 9, "G_columns": [1, 2, 4, 16, 27, 53, 81, 128, 337], "handoff_exact_monomial_sha256": "1f0bc88ef72044371a1b248bf457df6baaf719b79f0b68f5b6344f882ab4279a", "full_exit_exact_monomial_sha256": "3f70bc24f57a78fedd30541c26a2ce7ae0bb03ef5c3d83848efb3bc3f790ea13"}, {"operator": 21, "G_columns": [1, 2, 4, 16, 128, 138, 55, 65, 470], "handoff_exact_monomial_sha256": "9aac5012d2e6559816243a71a3d2242f9ab1fd5c93999852154b17d7016246b1", "full_exit_exact_monomial_sha256": "fe67c87c4305ec4904f7b1caff4270da969cbec68b30396419d56ad034bb077a"}, {"operator": 22, "G_columns": [1, 2, 4, 10, 33, 68, 16, 128, 325], "handoff_exact_monomial_sha256": "ff04b6e08be7b0eecc02fe682db07c8443be8d8ccfc01acd954bf9d340a23725", "full_exit_exact_monomial_sha256": "9cac0ebf245216aa73aef54a6b1f2819dd58890566e175330b89efaa55081010"}, {"operator": 15, "G_columns": [1, 2, 4, 40, 86, 8, 132, 16, 408], "handoff_exact_monomial_sha256": "cec7ff0123251549c69eaeb589fa79562a842ecf40de40aecc761bdf043c4fd2", "full_exit_exact_monomial_sha256": "40efcad72e80e65e7f8a29c26622bcfba6ebbfced1ba108478c5cb79f016afe4"}, {"operator": 18, "G_columns": [1, 2, 4, 8, 43, 80, 129, 16, 408], "handoff_exact_monomial_sha256": "542bcfe937ce79a4f3132048c70c7899637044e281e6156d0429de47515c75e2", "full_exit_exact_monomial_sha256": "cd610342e99dd286b5604c783a53b18f9e8805b700d2a2ab1f2a69f38998664a"}, {"operator": 19, "G_columns": [1, 2, 4, 8, 43, 80, 129, 16, 408], "handoff_exact_monomial_sha256": "542bcfe937ce79a4f3132048c70c7899637044e281e6156d0429de47515c75e2", "full_exit_exact_monomial_sha256": "cd610342e99dd286b5604c783a53b18f9e8805b700d2a2ab1f2a69f38998664a"}, {"operator": 20, "G_columns": [1, 2, 4, 8, 16, 62, 94, 129, 387], "handoff_exact_monomial_sha256": "1d151f1d9ddc9aed0a277c1d756e1deb703f2c5b4be38cdbb598cbe428de3dfb", "full_exit_exact_monomial_sha256": "07afa8d5a0aec069987438247c55b91ed85c84d71e6bfbd636da943e937120d7"}, {"operator": 10, "G_columns": [1, 2, 4, 64, 128, 143, 151, 160, 326], "handoff_exact_monomial_sha256": "7c58ca977f777b8a9c2e9708aa59f53ca850db9ca068470c1079bba62cc15191", "full_exit_exact_monomial_sha256": "416ddf0788d10d7a1b3304dad5c801688b1fd8bddc6e08cff90f5a02bb764f6b"}, {"operator": 11, "G_columns": [1, 2, 4, 64, 128, 143, 151, 160, 326], "handoff_exact_monomial_sha256": "7c58ca977f777b8a9c2e9708aa59f53ca850db9ca068470c1079bba62cc15191", "full_exit_exact_monomial_sha256": "416ddf0788d10d7a1b3304dad5c801688b1fd8bddc6e08cff90f5a02bb764f6b"}, {"operator": 12, "G_columns": [1, 2, 4, 64, 74, 86, 99, 128, 326], "handoff_exact_monomial_sha256": "4483ff575eb4cbc74feb2e8d95c414bf361bbae7df79d88a16c821e72b829429", "full_exit_exact_monomial_sha256": "b1417ab0cf194f64c94a9a5d584e7fe22beccea88e65d7a0ca8ece5c3b32b77e"}, {"operator": 13, "G_columns": [1, 2, 4, 64, 74, 128, 81, 99, 389], "handoff_exact_monomial_sha256": "4c210d00727ae6d8766019b938ee502095a23011211d32929689c043538eb19c", "full_exit_exact_monomial_sha256": "df2e2ec142b4b4fc1b4726e7f2b381e9231672788a4c440ff372587ddcf02720"}]}} \ No newline at end of file diff --git a/research/t74-low-alias-borrowing/price-input-ext80.json b/research/t74-low-alias-borrowing/price-input-ext80.json new file mode 100644 index 0000000000..c813a37fb7 --- /dev/null +++ b/research/t74-low-alias-borrowing/price-input-ext80.json @@ -0,0 +1,30 @@ +{ + "family": "T74", + "label": "CONSTRUCTED BORROW-WORD-80{base,extra} (48 high + 32 low aliases); local profiles recounted by check_ext.py; idle refill MODELLED (owner fill not rebuilt)", + "providers": { + "extra": { + "helper_width_sum": 3408, + "helpers": 400, + "profile": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + } + }, + "gauge44": { + "helper_width_sum": 3408, + "helpers": 400, + "profile": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + } + } + } +} diff --git a/research/t74-low-alias-borrowing/price_ext.all.receipt.json b/research/t74-low-alias-borrowing/price_ext.all.receipt.json new file mode 100644 index 0000000000..2ce13a97dc --- /dev/null +++ b/research/t74-low-alias-borrowing/price_ext.all.receipt.json @@ -0,0 +1,469 @@ +{ + "controls": { + "calibration": { + "C": { + "E_ref": 138198, + "in_sample": "PR2269 pre-borrow idle {48:22748} + E_ref under C = PR2269 realized idle exactly", + "shares": { + "1": "3996/23033", + "3": "8673/46066", + "48": "13848/23033", + "5": "1355/46066", + "7": "175/23033" + }, + "top_share": 0.6012243303086875 + }, + "C8": { + "E_ref": 19080, + "delta_mass": { + "1": 1639, + "12": -156, + "16": -528, + "19": -19, + "2": -152, + "20": -40, + "28": -112, + "3": -459, + "32": -1632, + "36": -36, + "39": 273, + "40": -40, + "44": -264, + "48": 9792, + "5": 7345, + "6": 108, + "7": 3409, + "8": -48 + }, + "note": "R492 parent residues (ranks 2..44) were repacked away; net top-rank share kept", + "shares": { + "1": "70477/1128370", + "39": "11739/1128370", + "48": "136/265", + "5": "63167/225674", + "6": "2322/564185", + "7": "146587/1128370" + }, + "top_share": 0.5132075471698113 + } + }, + "compositions": "T74: 249 P_g + 417 P_e + idle = PR2269 B.json profile; T8: 72 P + idle = PR2260 EXPECTED profile; pre states (PR2269 pre-borrow, R492 parent) have mass m W - D; local mass = 1856 + helper widths in all four states", + "elapsed_s": 4.6, + "evaluator": "log2 two formulas overlap; exp(log 2) encloses 2; truncation without remainder is caught", + "negative_controls": [ + { + "name": "one idle 48 -> 47 + 1: PR2269 b no longer admissible", + "ok": true, + "rejected_by": "moment.accept" + }, + { + "name": "PR2269 complex_lower + 1e-90 claimed admissible", + "ok": true, + "rejected_by": "moment.accept" + }, + { + "name": "idle with one extra rank-48 child (mass identity)", + "ok": true, + "rejected_by": "compose.mass" + }, + { + "name": "W off by one", + "ok": true, + "rejected_by": "compose.mass" + }, + { + "name": "local mass != 1856 + widths", + "ok": true, + "rejected_by": "local.identity" + }, + { + "name": "48 rank-52 children replace 52 rank-48 children (halving guard 2*52^2 > 73^2)", + "ok": true, + "rejected_by": "compose.halving" + }, + { + "name": "explicit idle with the wrong mass", + "ok": true, + "rejected_by": "compose.mass" + } + ], + "out_of_sample": { + "T74": { + "E": 138198, + "models": { + "C": { + "b": "0.0016962471390584742207696225394800943861", + "fraction_of_realized_gain_over_pre": "1.0000", + "minus_realized": "0" + }, + "C8": { + "b": "0.0016985683481814001130001349768856017636", + "fraction_of_realized_gain_over_pre": "1.1400", + "minus_realized": "928483649170356892204974962202951/400000000000000000000000000000000000000" + }, + "F": { + "b": "0.0017179343748109897999540913070267178655", + "fraction_of_realized_gain_over_pre": "2.3084", + "minus_realized": "108436178762577895922343837733117397/5000000000000000000000000000000000000000" + }, + "P": { + "b": "0.0016536954596193558629070622431148614171", + "fraction_of_realized_gain_over_pre": "-1.5672", + "minus_realized": "-42551679439118357862560296365232969/1000000000000000000000000000000000000000" + } + }, + "predecessor_b": "0.0016796717955047376215420758089648538525", + "realized_b": "0.0016962471390584742207696225394800943861", + "start": "PR2269 pre-borrow (top-level SPEC.json, 480 helpers; stale assembly, 1e-24 endpoint)", + "target": "PR2269 realized (43 high aliases, 437 helpers, window-exact owner fill)" + }, + "T8": { + "E": 19080, + "models": { + "C": { + "b": "0.0016854237962255183965805921001940048938", + "fraction_of_realized_gain_over_pre": "1.0645", + "minus_realized": "5028012014781495956654212580729601/2500000000000000000000000000000000000000" + }, + "C8": { + "b": "0.0016885917759833641906873140760084475527", + "fraction_of_realized_gain_over_pre": "1.1660", + "minus_realized": "51791845637583924893836608467344993/10000000000000000000000000000000000000000" + }, + "F": { + "b": "0.0017130702907503100752557179018212026951", + "fraction_of_realized_gain_over_pre": "1.9505", + "minus_realized": "296576993307042770577874866594896417/10000000000000000000000000000000000000000" + }, + "P": { + "b": "0.0016323380736247241790559234493734262889", + "fraction_of_realized_gain_over_pre": "-0.6368", + "minus_realized": "-102149035589763238284013931576573529/2000000000000000000000000000000000000000" + } + }, + "predecessor_b": "0.0016522089943684118249476894444598958005", + "realized_b": "0.0016834125914196057981979304151617130534", + "start": "PR2260 actual hosted parent R492 (owners/inputs/HOSTED-PARENT.json.gz)", + "target": "PR2260 realized (44 high aliases, 436 helpers, multi-bin repacking)" + } + }, + "pr2260": { + "b_40": "0.0016834125914196057981979304151617130534", + "equals": "PR2260 arithmetic/EXPECTED.json certified_complex_saving 8417/5000000", + "floor_7_root_conservative": "0.0016834", + "floor_7_root_native": "0.0016834" + }, + "pr2269": { + "bisection_steps": 292, + "derived_b": "floor_90(root) - 1e-100 = PR2269 outer/B.json b exactly", + "floor_90_root": "0.001696247139058474220769622539480094386128460370682171660721081525827226194556117859271672" + }, + "pr2269_models_E0": "F, C, C8, P with PR2269 own profiles: E = 0, idle unchanged, b_30 = floor_30(b) for all", + "pr2269_preborrow": { + "equals": "PR2269 SPEC.json / evidence/ASSEMBLY.json complex_lower (stale pre-borrow assembly)", + "floor_24_root": "0.001679671795504737621542" + } + }, + "credits": "PR2226 Cinna Davis / 1337isnot1337 (anticipatory dirty borrowing, 80-alias T8 word); PR2269 Jeremy Kothe / jeremykothe2 (T74 borrow43 words, fill, b); PR2260 Dugongue (T8 44-high supplier, fill); PR2312 (reference claim only); T74 lineage PR1319/PR1297 (Rohan Arun), PR1625 (mdumitrean), pivot-554 kernel; PR547/548/559 moment engines. Evaluator adapted from our own iteration-3 price_check.py (fork commit 4a2f20ea). Prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0.", + "demo_t74_proxy": { + "base": "PR2269 realized (43 high aliases, 437 helpers, window-exact owner fill)", + "digits": 40, + "extra_freed_mass": 72594, + "family": "T74", + "helpers": { + "extra": 401, + "gauge44": 401 + }, + "idle_mass": 1302696, + "label": "PROXY: T8 transfer delta (PR2226 80-alias word minus PR2260 44-high word) applied to both PR2269 T74 words; not a constructed word", + "local_mass": { + "extra": 5276, + "gauge44": 5276 + }, + "local_profiles": { + "extra": { + "1": 2297, + "2": 536, + "3": 395, + "4": 112, + "5": 42, + "8": 8 + }, + "gauge44": { + "1": 2309, + "2": 528, + "3": 391, + "4": 116, + "5": 42, + "8": 8 + } + }, + "models": [ + { + "b": "0.0017218366992355269771124747258848462552", + "bisection_steps": 126, + "bit_bound": false, + "gain_vs_pr2269": "2.5589560177052756342E-5", + "gain_vs_pr2269_pct": "+1.5086%", + "gain_vs_pr2312": "2.4945631993908977112E-5", + "gain_vs_pr2312_pct": "+1.4701%", + "global_children": 2318340, + "idle": { + "1": 23976, + "18": 1, + "3": 8673, + "48": 25991, + "5": 813, + "7": 150 + }, + "idle_children": 59604, + "max_child": 48, + "model": "F", + "text": "favorable: base idle + all extra mass in rank-48 children (+ one remainder child)" + }, + { + "b": "0.0017103172480541537909827271624895096611", + "bisection_steps": 126, + "bit_bound": false, + "gain_vs_pr2269": "1.4070108995679570213E-5", + "gain_vs_pr2269_pct": "+0.8295%", + "gain_vs_pr2312": "1.3426180812535790982E-5", + "gain_vs_pr2312_pct": "+0.7912%", + "global_children": 2335412, + "idle": { + "1": 36592, + "3": 13228, + "48": 25388, + "5": 1240, + "7": 228 + }, + "idle_children": 76676, + "max_child": 48, + "model": "C", + "text": "calibrated on T74 (PR2269 pre-borrow {48:22748} -> PR2269 realized idle split by rank)" + }, + { + "b": "0.0017115683222828929235466373825296556943", + "bisection_steps": 127, + "bit_bound": false, + "gain_vs_pr2269": "1.5321183224418702777E-5", + "gain_vs_pr2269_pct": "+0.9032%", + "gain_vs_pr2312": "1.4677255041274923546E-5", + "gain_vs_pr2312_pct": "+0.8649%", + "global_children": 2327648, + "idle": { + "1": 28543, + "3": 8673, + "39": 19, + "48": 25255, + "5": 4876, + "6": 49, + "7": 1497 + }, + "idle_children": 68912, + "max_child": 48, + "model": "C8", + "text": "sensitivity: calibrated on T8 (R492 hosted parent -> PR2260 realized idle, net top-rank share)" + }, + { + "b": "0.0016873289910183340236296230287693352781", + "bisection_steps": 127, + "bit_bound": false, + "gain_vs_pr2269": "-8.9181480401401971399E-6", + "gain_vs_pr2269_pct": "-0.5258%", + "gain_vs_pr2312": "-9.5620762232839763703E-6", + "gain_vs_pr2312_pct": "-0.5635%", + "global_children": 2389421, + "idle": { + "1": 96570, + "3": 8673, + "48": 24479, + "5": 813, + "7": 150 + }, + "idle_children": 130685, + "max_child": 48, + "model": "P", + "text": "pessimistic: base idle + all extra mass in rank-1 children" + } + ] + }, + "demo_t8_pr2226": { + "base": "PR2260 realized (44 high aliases, 436 helpers, multi-bin repacking)", + "digits": 40, + "extra_freed_mass": 7848, + "family": "T8", + "gain_vs_pr2260_realized": { + "C": "1.3790943116751707048E-5", + "C8": "1.4878227578232000775E-5", + "F": "2.5184297008484224506E-5", + "P": "-8.7839191939722229764E-6" + }, + "helpers": { + "gauge44": 400 + }, + "idle_mass": 140832, + "label": "PR2226 actual 80-alias T8 word priced on PR2260 realized fill (model)", + "local_mass": { + "gauge44": 5276 + }, + "local_profiles": { + "gauge44": { + "1": 2382, + "2": 445, + "3": 406, + "4": 128, + "5": 42, + "8": 8 + } + }, + "models": [ + { + "b": "0.0017085968884280900227042764728291650410", + "bisection_steps": 127, + "bit_bound": false, + "gain_vs_pr2269": "1.2349749369615801934E-5", + "gain_vs_pr2269_pct": "+0.7281%", + "gain_vs_pr2312": "1.1705821186472022704E-5", + "gain_vs_pr2312_pct": "+0.6898%", + "global_children": 251992, + "idle": { + "1": 1724, + "24": 1, + "3": 20, + "32": 11, + "39": 7, + "48": 2656, + "5": 1469, + "6": 18, + "7": 494 + }, + "idle_children": 6400, + "max_child": 48, + "model": "F", + "text": "favorable: base idle + all extra mass in rank-48 children (+ one remainder child)" + }, + { + "b": "0.0016972035345363575052465493608079996758", + "bisection_steps": 126, + "bit_bound": false, + "gain_vs_pr2269": "9.5639547788328447692E-7", + "gain_vs_pr2269_pct": "+0.0564%", + "gain_vs_pr2312": "3.1246729473950524654E-7", + "gain_vs_pr2312_pct": "+0.0184%", + "global_children": 253854, + "idle": { + "1": 3106, + "3": 512, + "32": 11, + "39": 7, + "48": 2591, + "5": 1515, + "6": 18, + "7": 502 + }, + "idle_children": 8262, + "max_child": 48, + "model": "C", + "text": "calibrated on T74 (PR2269 pre-borrow {48:22748} -> PR2269 realized idle split by rank)" + }, + { + "b": "0.0016982908189978377989731806688655597489", + "bisection_steps": 126, + "bit_bound": false, + "gain_vs_pr2269": "2.0436799393635782035E-6", + "gain_vs_pr2269_pct": "+0.1205%", + "gain_vs_pr2312": "1.3997517562197989731E-6", + "gain_vs_pr2312_pct": "+0.0825%", + "global_children": 253048, + "idle": { + "1": 2270, + "3": 20, + "32": 11, + "39": 9, + "48": 2576, + "5": 1908, + "6": 23, + "7": 639 + }, + "idle_children": 7456, + "max_child": 48, + "model": "C8", + "text": "sensitivity: calibrated on T8 (R492 hosted parent -> PR2260 realized idle, net top-rank share)" + }, + { + "b": "0.0016746286722256335752215090736504007219", + "bisection_steps": 126, + "bit_bound": false, + "gain_vs_pr2269": "-2.1618466832840645548E-5", + "gain_vs_pr2269_pct": "-1.2745%", + "gain_vs_pr2312": "-2.2262395015984424778E-5", + "gain_vs_pr2312_pct": "-1.3120%", + "global_children": 259676, + "idle": { + "1": 9572, + "3": 20, + "32": 11, + "39": 7, + "48": 2493, + "5": 1469, + "6": 18, + "7": 494 + }, + "idle_children": 14084, + "max_child": 48, + "model": "P", + "text": "pessimistic: base idle + all extra mass in rank-1 children" + } + ] + }, + "elapsed_s": 6.9, + "model": "1. Composition (as in PR2269 code/assemble.py and PR2260 arithmetic/verify.py):\n H = sum_p calls_p * P_p + idle, T74: 249 P_gauge44 + 417 P_extra + idle, T8: 72 P + idle.\n 2. Mass identity: mass(H) = m W - D is invariant (T74: 73*66304 - 23680 = 4816512; T8: 73*7168 - 2560\n = 520704). Hence idle mass' = (m W - D) - sum_p calls_p mass(P_p'), and the extra freed mass relative\n to the realized base is E = idle mass' - idle mass(base). If helper_width_sum is given, the local\n identity mass(P) = 1856 + sum of helper widths is checked (it holds for PR2269, PR2260, PR2226 and\n the R492 parent).\n 3. Idle-refill models (base = the realized idle of the record being extended; for T74 that is\n PR2269's {1:23976, 3:8673, 5:813, 7:150, 48:24479}). For E >= 0:\n F favorable: base + floor(E/48) children of rank 48 + one child of rank E mod 48 (if nonzero).\n C calibrated: shares s_r derived exactly from a realized (pre, post) idle pair:\n delta_r = r (post_r - pre_r), E_ref = sum_r delta_r, s_48 = delta_48 / E_ref,\n small ranks r < 48 with delta_r > 0 share 1 - s_48 in proportion to delta_r.\n (For T74, pre = {48:22748} = PR2269's pre-borrow idle, every delta_r >= 0 and\n s_r = delta_r / E_ref exactly: s_48 = 83088/138198, s_1 = 23976/138198,\n s_3 = 26019/138198, s_5 = 4065/138198, s_7 = 1050/138198.)\n Allocation: n_r += floor(E s_r / r); the leftover mass (< 64) becomes rank-1\n children (conservative rounding). With E = E_ref on the pre base this reproduces\n the post profile exactly (control).\n C8 sensitivity: same rule calibrated on the T8 transition R492 hosted parent -> PR2260\n (net top-rank share 9792/19080; the parent's small residues were repacked).\n P pessimistic: base + E children of rank 1.\n For E < 0 (supplier heavier than the base): F removes mass from the smallest idle children first,\n P from the rank-48 children first (shrinking the last touched child), C/C8 remove ceil(|E| s_r / r)\n children per rank where present, take any shortfall from the largest children and return any\n over-removed mass as rank-1 children.\n Not modelled: changes of the window/owner geometry, the 76 private cleanup zero buffers per call\n (outside the moment under PR2269's dedicated-family charge), any re-optimised fill.\n 4. Moment (native complex side, no surcharge; the side of PR2269 outer/B.json b and PR2260 b):\n mu(a) = sum_r n_r (r/m)^(1-a) / W; root rho: the unique a > 0 with mu(a) = 1.\n Optional conservative side (--conservative): mu(a) + 32 m N m^a / (10^16 W), N = number of children.\n b_D(H) := floor of rho on the decimal grid 10^-D, certified by mu(b_D) < 1 < mu(b_D + 10^-D).\n PR2269 packages b = b_90 - 10^-100; PR2260 packages b = 8417/5000000 (accepted on both sides).\n 5. Certified evaluation (exact integers on the grid 2^-PREC, directed rounding; iteration-3 evaluator):\n log via atanh series with the remainder bound z^(2N+1)/((2N+1)(1-z^2)); exp by its Taylor series with\n the remainder bound x^N/N! (N+1)/(N+1-x); comparisons with 1 are exact rational comparisons.\n 6. Gains are b_D(model) - reference, an exact rational known to lie within 10^-D below the model's root\n gain. References: PR2269 claimed b (= complex_lower - 1e-100; its outer-ledger kappa differs from b\n by about 2e-100) and the PR2312 claimed kappa 0.001696891067241618 (reference value only, not\n re-derived). The bit endpoint 0.001733427039589844234749 (PR2269 ledger) caps any kappa: a model\n b above it would be bit-bound (flagged, never the case in the demo).", + "prec_bits": 800, + "python": "3.14.4", + "references": { + "bit_lower": "1733427039589844234749/1000000000000000000000000", + "pr2269_b": "0.0016962471390584742207696225394800943861284603706821716607210815258272261945561178592716719999999999", + "pr2312_kappa": "848445533620809/500000000000000000" + }, + "result": "PASS_T74_EXT_PRICE_HARNESS", + "sources": { + "blobs": { + "b479fc55:research/gmx-t74-borrow43/SPEC.json": { + "git_blob": "5158049eeff8240d59528441d3f1fcfd8f420783", + "sha256": "da49a85190eac2b553fe982ed295b15fcde6d2dd449d976b503de25c277f2029" + }, + "b479fc55:research/gmx-t74-borrow43/new/SPEC.json": { + "git_blob": "2431d1cebbb2e155356d2da160d60808498bc33d", + "sha256": "bd091ed9e7f4939d06abb467d0d2c56ce0f34ba800d74132669f7b667e125d2d" + }, + "b479fc55:research/gmx-t74-borrow43/outer/B.json": { + "git_blob": "a66501df3178012477b4c54fb6888e986b52a25e", + "sha256": "631d89563be62a156c2b0119f9d4ba5a31cbf36380768bf8748825cf361bb525" + }, + "dacaf3d8:research/anticipatory-dirty-borrowing/RESULT.json": { + "git_blob": "081e326e91c172a9426245712cb9087997edd1bf", + "sha256": "f03f05fe272e0df991edc81874fe32a417c2571fc082a3e8166890be9e1fc7ec" + }, + "fde6b107:research/selective-borrowing-kappa/arithmetic/EXPECTED.json": { + "git_blob": "e904b407023b13ce6c9b462a00db77c34240cc29", + "sha256": "f7e7548796b8888baea2ede61f95bc383aa32242bf669637fe19fcbe829ad614" + }, + "fde6b107:research/selective-borrowing-kappa/local/data/forward.json": { + "git_blob": "63c20f0bd59d712744b46ebea6b1cd12659c3ef5", + "sha256": "a9d513bc1d85eb11184d73242a4016119f3968bb2a1ff9b365e78109778c17ee" + }, + "fde6b107:research/selective-borrowing-kappa/owners/EXPECTED.json": { + "git_blob": "4997a677bae7528dcfddde9141e0446fb92e4dfa", + "sha256": "c4ad5debab3f3bd5cba68b91e28a6a8fa64febcbeb892b1fd1d27e3977a76cb1" + }, + "fde6b107:research/selective-borrowing-kappa/owners/inputs/HOSTED-PARENT.json.gz": { + "git_blob": "424c2df489364ea5b29e0df9841e6fe91a517df4", + "sha256": "f713f8e66aaeaebb8202fe72bf36c7d23497152497342c27892e0fda3092f95b" + } + }, + "repo": "", + "result": "every hard-coded constant equals the pinned PR blobs" + }, + "tool": "price_ext.py" +} diff --git a/research/t74-low-alias-borrowing/price_ext.ext80.receipt.json b/research/t74-low-alias-borrowing/price_ext.ext80.receipt.json new file mode 100644 index 0000000000..bec19b8e2c --- /dev/null +++ b/research/t74-low-alias-borrowing/price_ext.ext80.receipt.json @@ -0,0 +1,141 @@ +{ + "credits": "PR2226 Cinna Davis / 1337isnot1337 (anticipatory dirty borrowing, 80-alias T8 word); PR2269 Jeremy Kothe / jeremykothe2 (T74 borrow43 words, fill, b); PR2260 Dugongue (T8 44-high supplier, fill); PR2312 (reference claim only); T74 lineage PR1319/PR1297 (Rohan Arun), PR1625 (mdumitrean), pivot-554 kernel; PR547/548/559 moment engines. Evaluator adapted from our own iteration-3 price_check.py (fork commit 4a2f20ea). Prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0.", + "elapsed_s": 1.5, + "model": "1. Composition (as in PR2269 code/assemble.py and PR2260 arithmetic/verify.py):\n H = sum_p calls_p * P_p + idle, T74: 249 P_gauge44 + 417 P_extra + idle, T8: 72 P + idle.\n 2. Mass identity: mass(H) = m W - D is invariant (T74: 73*66304 - 23680 = 4816512; T8: 73*7168 - 2560\n = 520704). Hence idle mass' = (m W - D) - sum_p calls_p mass(P_p'), and the extra freed mass relative\n to the realized base is E = idle mass' - idle mass(base). If helper_width_sum is given, the local\n identity mass(P) = 1856 + sum of helper widths is checked (it holds for PR2269, PR2260, PR2226 and\n the R492 parent).\n 3. Idle-refill models (base = the realized idle of the record being extended; for T74 that is\n PR2269's {1:23976, 3:8673, 5:813, 7:150, 48:24479}). For E >= 0:\n F favorable: base + floor(E/48) children of rank 48 + one child of rank E mod 48 (if nonzero).\n C calibrated: shares s_r derived exactly from a realized (pre, post) idle pair:\n delta_r = r (post_r - pre_r), E_ref = sum_r delta_r, s_48 = delta_48 / E_ref,\n small ranks r < 48 with delta_r > 0 share 1 - s_48 in proportion to delta_r.\n (For T74, pre = {48:22748} = PR2269's pre-borrow idle, every delta_r >= 0 and\n s_r = delta_r / E_ref exactly: s_48 = 83088/138198, s_1 = 23976/138198,\n s_3 = 26019/138198, s_5 = 4065/138198, s_7 = 1050/138198.)\n Allocation: n_r += floor(E s_r / r); the leftover mass (< 64) becomes rank-1\n children (conservative rounding). With E = E_ref on the pre base this reproduces\n the post profile exactly (control).\n C8 sensitivity: same rule calibrated on the T8 transition R492 hosted parent -> PR2260\n (net top-rank share 9792/19080; the parent's small residues were repacked).\n P pessimistic: base + E children of rank 1.\n For E < 0 (supplier heavier than the base): F removes mass from the smallest idle children first,\n P from the rank-48 children first (shrinking the last touched child), C/C8 remove ceil(|E| s_r / r)\n children per rank where present, take any shortfall from the largest children and return any\n over-removed mass as rank-1 children.\n Not modelled: changes of the window/owner geometry, the 76 private cleanup zero buffers per call\n (outside the moment under PR2269's dedicated-family charge), any re-optimised fill.\n 4. Moment (native complex side, no surcharge; the side of PR2269 outer/B.json b and PR2260 b):\n mu(a) = sum_r n_r (r/m)^(1-a) / W; root rho: the unique a > 0 with mu(a) = 1.\n Optional conservative side (--conservative): mu(a) + 32 m N m^a / (10^16 W), N = number of children.\n b_D(H) := floor of rho on the decimal grid 10^-D, certified by mu(b_D) < 1 < mu(b_D + 10^-D).\n PR2269 packages b = b_90 - 10^-100; PR2260 packages b = 8417/5000000 (accepted on both sides).\n 5. Certified evaluation (exact integers on the grid 2^-PREC, directed rounding; iteration-3 evaluator):\n log via atanh series with the remainder bound z^(2N+1)/((2N+1)(1-z^2)); exp by its Taylor series with\n the remainder bound x^N/N! (N+1)/(N+1-x); comparisons with 1 are exact rational comparisons.\n 6. Gains are b_D(model) - reference, an exact rational known to lie within 10^-D below the model's root\n gain. References: PR2269 claimed b (= complex_lower - 1e-100; its outer-ledger kappa differs from b\n by about 2e-100) and the PR2312 claimed kappa 0.001696891067241618 (reference value only, not\n re-derived). The bit endpoint 0.001733427039589844234749 (PR2269 ledger) caps any kappa: a model\n b above it would be bit-bound (flagged, never the case in the demo).", + "prec_bits": 800, + "price": { + "base": "PR2269 realized (43 high aliases, 437 helpers, window-exact owner fill)", + "digits": 40, + "extra_freed_mass": 80586, + "family": "T74", + "helpers": { + "extra": 400, + "gauge44": 400 + }, + "idle_mass": 1310688, + "label": "CONSTRUCTED BORROW-WORD-80{base,extra} (48 high + 32 low aliases); local profiles recounted by check_ext.py; idle refill MODELLED (owner fill not rebuilt)", + "local_mass": { + "extra": 5264, + "gauge44": 5264 + }, + "local_profiles": { + "extra": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "gauge44": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + } + }, + "models": [ + { + "b": "0.0017255088890837212072813976419618582057", + "b_conservative": "0.0017255088861992047617724230796997597019", + "bisection_steps": 126, + "bit_bound": false, + "gain_vs_pr2269": "2.9261750025246986511E-5", + "gain_vs_pr2269_pct": "+1.7251%", + "gain_vs_pr2312": "2.8617821842103207281E-5", + "gain_vs_pr2312_pct": "+1.6865%", + "global_children": 2311510, + "idle": { + "1": 23976, + "3": 8673, + "42": 1, + "48": 26157, + "5": 813, + "7": 150 + }, + "idle_children": 59770, + "max_child": 48, + "model": "F", + "text": "favorable: base idle + all extra mass in rank-48 children (+ one remainder child)" + }, + { + "b": "0.0017126737497248571464349222053077804286", + "b_conservative": "0.0017126737468384233802906688749666422316", + "bisection_steps": 126, + "bit_bound": false, + "gain_vs_pr2269": "1.6426610666382925665E-5", + "gain_vs_pr2269_pct": "+0.9684%", + "gain_vs_pr2312": "1.5782682483239146434E-5", + "gain_vs_pr2312_pct": "+0.9301%", + "global_children": 2330462, + "idle": { + "1": 37980, + "3": 13730, + "48": 25488, + "5": 1287, + "7": 237 + }, + "idle_children": 78722, + "max_child": 48, + "model": "C", + "text": "calibrated on T74 (PR2269 pre-borrow {48:22748} -> PR2269 realized idle split by rank)" + }, + { + "b": "0.0017140567316684824711264204715713101470", + "b_conservative": "0.0017140567287903532610785433539703089262", + "bisection_steps": 126, + "bit_bound": false, + "gain_vs_pr2269": "1.7809592610008250356E-5", + "gain_vs_pr2269_pct": "+1.0499%", + "gain_vs_pr2312": "1.7165664426864471126E-5", + "gain_vs_pr2312_pct": "+1.0116%", + "global_children": 2321863, + "idle": { + "1": 29065, + "3": 8673, + "39": 21, + "48": 25340, + "5": 5324, + "6": 55, + "7": 1645 + }, + "idle_children": 70123, + "max_child": 48, + "model": "C8", + "text": "sensitivity: calibrated on T8 (R492 hosted parent -> PR2260 realized idle, net top-rank share)" + }, + { + "b": "0.0016871233700042746562989725665814138063", + "b_conservative": "0.0016871233670879834795804369952323227555", + "bisection_steps": 127, + "bit_bound": false, + "gain_vs_pr2269": "-9.1237690541995644706E-6", + "gain_vs_pr2269_pct": "-0.5379%", + "gain_vs_pr2312": "-9.7676972373433437010E-6", + "gain_vs_pr2312_pct": "-0.5756%", + "global_children": 2390417, + "idle": { + "1": 104562, + "3": 8673, + "48": 24479, + "5": 813, + "7": 150 + }, + "idle_children": 138677, + "max_child": 48, + "model": "P", + "text": "pessimistic: base idle + all extra mass in rank-1 children" + } + ] + }, + "python": "3.14.4", + "references": { + "bit_lower": "1733427039589844234749/1000000000000000000000000", + "pr2269_b": "0.0016962471390584742207696225394800943861284603706821716607210815258272261945561178592716719999999999", + "pr2312_kappa": "848445533620809/500000000000000000" + }, + "result": "PASS_T74_EXT_PRICE_HARNESS", + "tool": "price_ext.py" +} diff --git a/research/t74-low-alias-borrowing/price_ext.py b/research/t74-low-alias-borrowing/price_ext.py new file mode 100644 index 0000000000..59ef458967 --- /dev/null +++ b/research/t74-low-alias-borrowing/price_ext.py @@ -0,0 +1,961 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Pricing harness for an extended T74 (or T8) complex supplier under explicit idle-refill models. + +Question it answers: if the two T74 pivot-566+554 borrow words of PR2269 (gauge44 and extra) are +replaced by extended words P_gauge44', P_extra' (for example with PR2226-style LOW / anticipatory +aliases added), what complex saving b does the native moment certify, given that the owner fill +(and hence the idle remainder profile) has NOT been rebuilt? The idle profile is therefore modelled, +not constructed. Every number printed for a model is a MODEL PRICE, not a certified supplier and +not a kappa claim. Only the positive controls price realized (constructed) profiles. + +Credit: PR2226 (Cinna Davis / 1337isnot1337, with OpenAI Codex) for anticipatory dirty borrowing and +the 80-alias (48 high + 32 low) T8 word whose profile defines the demo delta; PR2269 (Jeremy Kothe / +jeremykothe2) for the T74 borrow43 words, fill, profile and the claimed b; PR2260 (Dugongue) for the +T8 44-high selective-borrowing supplier, its fill and profile; PR2312 for the current top open claim +used as a reference value only; the T74 lineage (PR1319/PR1297 Rohan Arun, PR1625 mdumitrean, +pivot-554 kernel) and the retained PR547/PR548/PR559 moment engines. The certified evaluator is +adapted from our own iteration-3 checker (fork commit 4a2f20ea339e30348448096ca789d0efe55df9bb, +research/t74-borrow43-independent-check/price_check.py, Apache-2.0, same authors). No PR code is +imported or run; PR constants are written here and can be re-checked against the pinned PR blobs +with the `sources` subcommand. + +Prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0. + +Usage (Python 3.10+, standard library only): + python3 -I -B price_ext.py controls [--out] positive/negative controls (exact reproduction) + python3 -I -B price_ext.py price INPUT.json [--digits D] [--out] + python3 -I -B price_ext.py demo [--digits D] [--out] T8-transferred delta proxy on both T74 words + python3 -I -B price_ext.py sources [--repo PATH] re-read every hard-coded PR constant from git + python3 -I -B price_ext.py all [--out] sources + controls + demo + +INPUT.json (see demo-t8-delta-proxy.json): + {"family": "T74" | "T8", "label": "...", + "providers": {"gauge44": {"profile": {"1": n1, ...}, "helpers": h, "helper_width_sum": w}, "extra": {...}}} + or, instead of explicit profiles, "delta": {"1": d1, ...} (applied to every base word) or + "delta": {"gauge44": {...}, "extra": {...}}; "helpers" may then be given per provider or once. + Optional "idle": {...}: an explicitly constructed idle profile, priced as model X (no modelling). + +MODEL (stated precisely; also written to receipts). + 1. Composition (as in PR2269 code/assemble.py and PR2260 arithmetic/verify.py): + H = sum_p calls_p * P_p + idle, T74: 249 P_gauge44 + 417 P_extra + idle, T8: 72 P + idle. + 2. Mass identity: mass(H) = m W - D is invariant (T74: 73*66304 - 23680 = 4816512; T8: 73*7168 - 2560 + = 520704). Hence idle mass' = (m W - D) - sum_p calls_p mass(P_p'), and the extra freed mass relative + to the realized base is E = idle mass' - idle mass(base). If helper_width_sum is given, the local + identity mass(P) = 1856 + sum of helper widths is checked (it holds for PR2269, PR2260, PR2226 and + the R492 parent). + 3. Idle-refill models (base = the realized idle of the record being extended; for T74 that is + PR2269's {1:23976, 3:8673, 5:813, 7:150, 48:24479}). For E >= 0: + F favorable: base + floor(E/48) children of rank 48 + one child of rank E mod 48 (if nonzero). + C calibrated: shares s_r derived exactly from a realized (pre, post) idle pair: + delta_r = r (post_r - pre_r), E_ref = sum_r delta_r, s_48 = delta_48 / E_ref, + small ranks r < 48 with delta_r > 0 share 1 - s_48 in proportion to delta_r. + (For T74, pre = {48:22748} = PR2269's pre-borrow idle, every delta_r >= 0 and + s_r = delta_r / E_ref exactly: s_48 = 83088/138198, s_1 = 23976/138198, + s_3 = 26019/138198, s_5 = 4065/138198, s_7 = 1050/138198.) + Allocation: n_r += floor(E s_r / r); the leftover mass (< 64) becomes rank-1 + children (conservative rounding). With E = E_ref on the pre base this reproduces + the post profile exactly (control). + C8 sensitivity: same rule calibrated on the T8 transition R492 hosted parent -> PR2260 + (net top-rank share 9792/19080; the parent's small residues were repacked). + P pessimistic: base + E children of rank 1. + For E < 0 (supplier heavier than the base): F removes mass from the smallest idle children first, + P from the rank-48 children first (shrinking the last touched child), C/C8 remove ceil(|E| s_r / r) + children per rank where present, take any shortfall from the largest children and return any + over-removed mass as rank-1 children. + Not modelled: changes of the window/owner geometry, the 76 private cleanup zero buffers per call + (outside the moment under PR2269's dedicated-family charge), any re-optimised fill. + 4. Moment (native complex side, no surcharge; the side of PR2269 outer/B.json b and PR2260 b): + mu(a) = sum_r n_r (r/m)^(1-a) / W; root rho: the unique a > 0 with mu(a) = 1. + Optional conservative side (--conservative): mu(a) + 32 m N m^a / (10^16 W), N = number of children. + b_D(H) := floor of rho on the decimal grid 10^-D, certified by mu(b_D) < 1 < mu(b_D + 10^-D). + PR2269 packages b = b_90 - 10^-100; PR2260 packages b = 8417/5000000 (accepted on both sides). + 5. Certified evaluation (exact integers on the grid 2^-PREC, directed rounding; iteration-3 evaluator): + log via atanh series with the remainder bound z^(2N+1)/((2N+1)(1-z^2)); exp by its Taylor series with + the remainder bound x^N/N! (N+1)/(N+1-x); comparisons with 1 are exact rational comparisons. + 6. Gains are b_D(model) - reference, an exact rational known to lie within 10^-D below the model's root + gain. References: PR2269 claimed b (= complex_lower - 1e-100; its outer-ledger kappa differs from b + by about 2e-100) and the PR2312 claimed kappa 0.001696891067241618 (reference value only, not + re-derived). The bit endpoint 0.001733427039589844234749 (PR2269 ledger) caps any kappa: a model + b above it would be bit-bound (flagged, never the case in the demo). +""" + +import sys + +if sys.flags.optimize: + sys.stdout.write('refusing to run under python -O\n') + sys.exit(2) + +import argparse +import gzip +import hashlib +import json +import os +import subprocess +import time +from fractions import Fraction + +HERE = os.path.dirname(os.path.abspath(__file__)) +DEFAULT_REPO = os.path.dirname(os.path.dirname(HERE)) +PASS_LINE = 'PASS_T74_EXT_PRICE_HARNESS' +FAIL_LINE = 'FAIL_T74_EXT_PRICE_HARNESS' +CREDITS = ('PR2226 Cinna Davis / 1337isnot1337 (anticipatory dirty borrowing, 80-alias T8 word); PR2269 ' + 'Jeremy Kothe / jeremykothe2 (T74 borrow43 words, fill, b); PR2260 Dugongue (T8 44-high supplier, fill); ' + 'PR2312 (reference claim only); T74 lineage PR1319/PR1297 (Rohan Arun), PR1625 (mdumitrean), pivot-554 ' + 'kernel; PR547/548/559 moment engines. Evaluator adapted from our own iteration-3 price_check.py ' + '(fork commit 4a2f20ea). Prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0.') + + +class HarnessError(Exception): + def __init__(self, check, msg): + Exception.__init__(self, '[%s] %s' % (check, msg)) + self.check = check + self.msg = msg + + +def need(cond, check, msg): + if not cond: + raise HarnessError(check, msg) + + +# ---------------------------------------------------------------------------- +# PR constants (written from the PR packages; `sources` re-reads every one of them from git) +# ---------------------------------------------------------------------------- + +PR2269_COMMIT = 'b479fc5567bc09ab9185bffe89b62594f36d74e5' +PR2269_PKG = 'research/gmx-t74-borrow43/' +PR2260_COMMIT = 'fde6b107e26a14da5bac5b66913c914708ea6901' +PR2260_PKG = 'research/selective-borrowing-kappa/' +PR2226_COMMIT = 'dacaf3d81f1936bb55b8454b1244e5d014272754' +PR2226_PKG = 'research/anticipatory-dirty-borrowing/' + +B_2269 = Fraction('16962471390584742207696225394800943861284603706821716607210815258272261945561178592716719999999999/' + '1' + '0' * 100) +COMPLEX_LOWER_2269 = Fraction('212030892382309277596202817435011798266057546335271457590135190728403274319514732408959/' + '125' + '0' * 87) +KAPPA_2312 = Fraction('0.001696891067241618') +BIT_LOWER = Fraction('1733427039589844234749/1' + '0' * 24) + +FAMILIES = { + 'T74': dict( + name='T74', source='PR2269 head %s, %s' % (PR2269_COMMIT[:8], PR2269_PKG), + m=73, W=66304, deficit=23680, calls={'gauge44': 249, 'extra': 417}, fixed_per_call=1856, top=48, + base=dict(label='PR2269 realized (43 high aliases, 437 helpers, window-exact owner fill)', + local={'gauge44': {1: 2351, 2: 501, 3: 414, 4: 129, 5: 42, 8: 8}, + 'extra': {1: 2339, 2: 509, 3: 418, 4: 125, 5: 42, 8: 8}}, + helpers={'gauge44': 437, 'extra': 437}, width_sum={'gauge44': 3529, 'extra': 3529}, + idle={1: 23976, 3: 8673, 5: 813, 7: 150, 48: 24479}), + pre=dict(label='PR2269 pre-borrow (top-level SPEC.json, 480 helpers; stale assembly, 1e-24 endpoint)', + local={'gauge44': {1: 2346, 2: 504, 3: 414, 4: 130, 5: 82, 8: 8}, + 'extra': {1: 2338, 2: 512, 3: 418, 4: 126, 5: 82, 8: 8}}, + helpers={'gauge44': 480, 'extra': 480}, width_sum={'gauge44': 3734, 'extra': 3738}, + idle={48: 22748}, + complex_lower=Fraction('839835897752368810771/5' + '0' * 23), grid=24), + claim=dict(b=B_2269, complex_lower=COMPLEX_LOWER_2269, grid=90, + global_profile={1: 1584738, 2: 337002, 3: 286065, 4: 84246, 5: 28785, 7: 150, 8: 5328, + 48: 24479})), + 'T8': dict( + name='T8', source='PR2260 head %s, %s' % (PR2260_COMMIT[:8], PR2260_PKG), + m=73, W=7168, deficit=2560, calls={'gauge44': 72}, fixed_per_call=1856, top=48, + base=dict(label='PR2260 realized (44 high aliases, 436 helpers, multi-bin repacking)', + local={'gauge44': {1: 2424, 2: 418, 3: 429, 4: 141, 5: 42, 8: 8}}, + helpers={'gauge44': 436}, width_sum={'gauge44': 3529}, + idle={1: 1724, 3: 20, 5: 1469, 6: 18, 7: 494, 32: 11, 39: 7, 48: 2493}), + pre=dict(label='PR2260 actual hosted parent R492 (owners/inputs/HOSTED-PARENT.json.gz)', + local={'gauge44': {1: 2514, 2: 404, 3: 448, 4: 160, 5: 56, 8: 8}}, + helpers={'gauge44': 492}, width_sum={'gauge44': 3794}, + idle={1: 85, 2: 76, 3: 173, 7: 7, 8: 6, 12: 13, 16: 33, 19: 1, 20: 2, 28: 4, 32: 62, 36: 1, + 40: 1, 44: 6, 48: 2289}), + claim=dict(b=Fraction(8417, 5000000), grid=7, + global_profile={1: 176252, 2: 30096, 3: 30908, 4: 10152, 5: 4493, 6: 18, 7: 494, 8: 576, + 32: 11, 39: 7, 48: 2493})), +} + +# PR2226 (T8, 80 aliases = 48 high + 32 low, 400 helpers): RESULT.json replay.local_profile +PR2226_LOCAL = {1: 2382, 2: 445, 3: 406, 4: 128, 5: 42, 8: 8} +PR2226_HELPERS = 400 +# T8 transfer delta = PR2226 - PR2260 local profile (both on the selected T8 word) +T8_DELTA = {1: -42, 2: 27, 3: -23, 4: -13} + +CALIBRATIONS = {'C': 'T74', 'C8': 'T8'} # model name -> family whose (pre -> base) idle transition calibrates it +MODEL_ORDER = ['F', 'C', 'C8', 'P'] +MODEL_TEXT = { + 'F': 'favorable: base idle + all extra mass in rank-48 children (+ one remainder child)', + 'C': 'calibrated on T74 (PR2269 pre-borrow {48:22748} -> PR2269 realized idle split by rank)', + 'C8': 'sensitivity: calibrated on T8 (R492 hosted parent -> PR2260 realized idle, net top-rank share)', + 'P': 'pessimistic: base idle + all extra mass in rank-1 children', + 'X': 'explicit idle profile supplied by the input (constructed fill, no modelling)', +} + + +# ---------------------------------------------------------------------------- +# Profiles +# ---------------------------------------------------------------------------- + +def clean(prof): + return dict((r, prof[r]) for r in sorted(prof) if prof[r]) + + +def plain(prof): + return dict((str(r), prof[r]) for r in sorted(prof) if prof[r]) + + +def mass_of(prof): + return sum(r * n for r, n in prof.items()) + + +def int_profile(mapping, what, allow_negative=False): + out = {} + need(isinstance(mapping, dict), 'input', what + ': profile must be a JSON object') + for k, v in mapping.items(): + need(str(int(k)) == str(k).strip() and int(k) > 0, 'input', '%s: bad rank %r' % (what, k)) + need(type(v) is int and (allow_negative or v >= 0), 'input', '%s: bad count %r for rank %s' % (what, v, k)) + out[int(k)] = out.get(int(k), 0) + v + return out + + +def add_profiles(*terms): + out = {} + for coef, prof in terms: + for r, n in prof.items(): + out[r] = out.get(r, 0) + coef * n + return clean(out) + + +def compose(fam, local, idle): + terms = [(fam['calls'][p], local[p]) for p in sorted(fam['calls'])] + return add_profiles(*(terms + [(1, idle)])) + + +def total_mass(fam): + return fam['m'] * fam['W'] - fam['deficit'] + + +def check_global(fam, H, what): + m = fam['m'] + need(all(type(r) is int and 0 < r < m and type(n) is int and n > 0 for r, n in H.items()), 'compose', + what + ': every child must have 0 < rank < m and positive count') + need(mass_of(H) == total_mass(fam), 'compose.mass', '%s: mass %d != m W - D = %d' % ( + what, mass_of(H), total_mass(fam))) + need(m * m > 2 * max(H) ** 2, 'compose.halving', what + ': halving guard m^2 > 2 maxchild^2 fails') + + +# ---------------------------------------------------------------------------- +# Idle-refill models +# ---------------------------------------------------------------------------- + +def calibration_shares(pre, post, top): + """Exact rank shares of the freed mass realized between two idle profiles (rule in MODEL 3).""" + ranks = sorted(set(pre) | set(post)) + delta = dict((r, r * (post.get(r, 0) - pre.get(r, 0))) for r in ranks) + e_ref = sum(delta.values()) + need(e_ref > 0, 'calibration', 'calibration pair frees no mass') + need(all(delta[r] == 0 for r in ranks if r > top), 'calibration', 'idle child above the top rank') + s_top = Fraction(delta.get(top, 0), e_ref) + pos = dict((r, delta[r]) for r in ranks if r < top and delta[r] > 0) + tot = sum(pos.values()) + shares = {top: s_top} + for r, d in pos.items(): + shares[r] = (1 - s_top) * Fraction(d, tot) + need(sum(shares.values()) == 1 and all(s >= 0 for s in shares.values()), 'calibration', 'shares do not sum to 1') + exact = all(delta[r] >= 0 for r in ranks) + return dict(shares=clean(shares), E_ref=e_ref, delta_mass=clean(delta), all_increments_nonnegative=exact, + top_share=s_top) + + +def remove_mass(idle, amount, ascending): + """Remove `amount` mass from idle children, smallest (ascending) or largest ranks first.""" + out = dict(idle) + left = amount + for r in sorted(out, reverse=not ascending): + while left > 0 and out.get(r, 0) > 0: + out[r] -= 1 + if r <= left: + left -= r + else: + out[r - left] = out.get(r - left, 0) + 1 + left = 0 + if left == 0: + break + need(left == 0, 'model', 'not enough idle mass to absorb a heavier supplier') + return clean(out) + + +def model_idle(name, base_idle, E, top, shares=None): + idle = dict(base_idle) + if name == 'F': + if E >= 0: + q, rem = divmod(E, top) + idle[top] = idle.get(top, 0) + q + if rem: + idle[rem] = idle.get(rem, 0) + 1 + return clean(idle) + return remove_mass(idle, -E, ascending=True) + if name == 'P': + if E >= 0: + idle[1] = idle.get(1, 0) + E + return clean(idle) + return remove_mass(idle, -E, ascending=False) + if name in ('C', 'C8'): + need(shares is not None, 'model', 'calibrated model without shares') + if E >= 0: + placed = 0 + for r, s in shares.items(): + t = E * s / r + k = t.numerator // t.denominator # place at most E s_r in rank r + idle[r] = idle.get(r, 0) + k + placed += r * k + leftover = E - placed + need(0 <= leftover, 'model', 'calibrated allocation overshoots') + idle[1] = idle.get(1, 0) + leftover # rounding remainder -> rank 1 (conservative) + return clean(idle) + removed = 0 + for r, s in shares.items(): # remove at least |E| s_r per rank where present + t = -E * s / r + k = min(-(-t.numerator // t.denominator), idle.get(r, 0)) + idle[r] = idle.get(r, 0) - k + removed += r * k + if removed < -E: # shortfall (rank absent in the base): top ranks first + return remove_mass(clean(idle), -E - removed, ascending=False) + idle[1] = idle.get(1, 0) + (removed + E) # over-removed mass returned as rank-1 children + return clean(idle) + raise HarnessError('model', 'unknown model ' + name) + + +# ---------------------------------------------------------------------------- +# Certified rational enclosures (adapted from our iteration-3 price_check.py) +# ---------------------------------------------------------------------------- + +PREC = 800 +ONE = 1 << PREC +MAX_TERMS = 4 * PREC + + +def cdiv(a, b): + return -((-a) // b) + + +def atanh_enclosure(p, q, terms=None, tail=True): + """Integers (lo, hi) with lo <= 2^PREC atanh(p/q) <= hi, for 0 <= p/q <= 1/3 (positive series + remainder).""" + need(q > 0 and 0 <= 3 * p <= q, 'evaluator', 'atanh argument outside [0, 1/3]') + if p == 0: + return 0, 0 + p2, q2 = p * p, q * q + pl, pu = (ONE * p) // q, cdiv(ONE * p, q) + sl = su = 0 + j = 0 + while (pl > 0) if terms is None else (j < terms): + need(j < MAX_TERMS, 'evaluator', 'atanh series did not terminate') + sl += pl // (2 * j + 1) + su += cdiv(pu, 2 * j + 1) + pl = (pl * p2) // q2 + pu = cdiv(pu * p2, q2) + j += 1 + if tail: + su += cdiv(pu * q2, (2 * j + 1) * (q2 - p2)) + return sl, su + + +_LOG2 = [] + + +def log2_enclosure(): + if not _LOG2: + lo, hi = atanh_enclosure(1, 3) + _LOG2.append((2 * lo, 2 * hi)) + return _LOG2[0] + + +def log_enclosure(p, q): + """Integers (lo, hi) enclosing 2^PREC log(p/q) for p/q >= 1.""" + need(p >= q > 0, 'evaluator', 'log argument below 1') + k = (p // q).bit_length() - 1 + a, b = p, q << k + zl, zu = atanh_enclosure(a - b, a + b) + l2l, l2u = log2_enclosure() + return k * l2l + 2 * zl, k * l2u + 2 * zu + + +def exp_enclosure(xl, xu, terms=None, tail=True): + """Integers (lo, hi) with lo <= 2^PREC exp(x) <= hi on [xl, xu] / 2^PREC, 0 <= xl <= xu < 2^PREC.""" + need(0 <= xl <= xu < ONE, 'evaluator', 'exp argument outside [0, 1)') + t = s = ONE + j = 1 + while (t > 0) if terms is None else (j < terms): + need(j < MAX_TERMS, 'evaluator', 'exp series did not terminate') + t = ((t * xl) >> PREC) // j + s += t + j += 1 + lo = s + t = s = ONE + j = 1 + while True: + need(j < MAX_TERMS, 'evaluator', 'exp series did not terminate') + t = cdiv(cdiv(t * xu, ONE), j) + if (t <= 1) if terms is None else (j >= terms): + break + s += t + j += 1 + if tail: + s += cdiv(t * (j + 1) * ONE, (j + 1) * ONE - xu) + return lo, s + + +_LOGS = {} + + +def log_m_over_r(m, r): + key = (m, r) + if key not in _LOGS: + _LOGS[key] = log_enclosure(m, r) + return _LOGS[key] + + +class Moment(object): + """Certified enclosures of mu(a) for one global profile.""" + + def __init__(self, H, m, W, surcharge=False): + need(all(type(r) is int and 0 < r < m and type(n) is int and n > 0 for r, n in H.items()), 'moment', + 'every child must have 0 < rank < m') + self.H, self.m, self.W, self.surcharge = dict(H), m, W, surcharge + self.N = sum(H.values()) + + def bounds(self, a): + a = Fraction(a) + need(a >= 0, 'moment', 'negative saving') + an, ad = a.numerator, a.denominator + slo = shi = 0 + for r in sorted(self.H): + ll, lu = log_m_over_r(self.m, r) + el, eu = exp_enclosure((an * ll) // ad, cdiv(an * lu, ad)) + slo += self.H[r] * r * el + shi += self.H[r] * r * eu + lo = Fraction(slo, self.m * self.W * ONE) + hi = Fraction(shi, self.m * self.W * ONE) + if self.surcharge: + ll, lu = log_m_over_r(self.m, 1) + el, eu = exp_enclosure((an * ll) // ad, cdiv(an * lu, ad)) + c = 32 * self.m * self.N + lo += Fraction(c * el, 10 ** 16 * self.W * ONE) + hi += Fraction(c * eu, 10 ** 16 * self.W * ONE) + need(lo <= hi, 'evaluator', 'empty enclosure') + return lo, hi + + def side(self, a): + lo, hi = self.bounds(a) + if hi < 1: + return -1 + if lo > 1: + return 1 + return 0 + + def floor_root(self, digits, hint=None): + """(b_D, steps): b_D on the grid 10^-digits with mu(b_D) < 1 < mu(b_D + 10^-digits), both certified. + A hint (any rational) only narrows the starting bracket after it is itself certified.""" + scale = 10 ** digits + lo, hi = 0, scale // 100 + need(self.side(Fraction(lo, scale)) < 0, 'moment', 'mu(0) >= 1: no positive saving') + need(self.side(Fraction(hi, scale)) > 0, 'moment', 'mu(1/100) <= 1') + steps = 0 + if hint is not None: + for w in (10 ** max(0, digits - 12), 10 ** max(0, digits - 6)): + c = int(Fraction(hint) * scale) + a, b = max(lo, c - w), min(hi, c + w) + if a < b and self.side(Fraction(a, scale)) < 0 and self.side(Fraction(b, scale)) > 0: + lo, hi = a, b + steps += 2 + break + while hi - lo > 1: + mid = (lo + hi) // 2 + s = self.side(Fraction(mid, scale)) + steps += 1 + need(s != 0, 'moment.bracket', 'undecided at 10^-%d grid point (raise PREC)' % digits) + if s < 0: + lo = mid + else: + hi = mid + return Fraction(lo, scale), steps + + +def require_side(ev, a, want, what): + lo, hi = ev.bounds(a) + if want < 0: + need(hi < 1, 'moment.accept', '%s: mu(a) < 1 not certified' % what) + else: + need(lo > 1, 'moment.reject', '%s: mu(a) > 1 not certified' % what) + return lo, hi + + +# ---------------------------------------------------------------------------- +# Display (display only) +# ---------------------------------------------------------------------------- + +def sci(x, sig=20): + x = Fraction(x) + if x == 0: + return '0' + neg = x < 0 + ax = -x if neg else x + e = len(str(ax.numerator)) - len(str(ax.denominator)) + while ax < Fraction(10) ** e: + e -= 1 + while ax >= Fraction(10) ** (e + 1): + e += 1 + y = ax * Fraction(10) ** (sig - 1 - e) + k = y.numerator // y.denominator + ds = str(k) + e += len(ds) - sig + return '%s%s.%sE%+d' % ('-' if neg else '', ds[0], ds[1:sig], e) + + +def dec(x, digits): + y = Fraction(x) * 10 ** digits + need(y.denominator == 1, 'display', 'not on the decimal grid') + n = y.numerator + s = str(abs(n)).rjust(digits + 1, '0') + return ('-' if n < 0 else '') + s[:-digits] + '.' + s[-digits:] + + +def pct(x, ref): + return '%+.4f%%' % float(100 * Fraction(x) / ref) + + +# ---------------------------------------------------------------------------- +# Pricing +# ---------------------------------------------------------------------------- + +def base_check(fam): + for state in ('base', 'pre'): + st = fam[state] + H = compose(fam, st['local'], st['idle']) + check_global(fam, H, '%s %s' % (fam['name'], state)) + for p in fam['calls']: + need(mass_of(st['local'][p]) == fam['fixed_per_call'] + st['width_sum'][p], 'local.identity', + '%s %s %s: local mass != 1856 + helper widths' % (fam['name'], state, p)) + need(compose(fam, fam['base']['local'], fam['base']['idle']) == fam['claim']['global_profile'], 'compose', + fam['name'] + ': base composition differs from the claimed global profile') + + +def all_shares(): + out = {} + for model, fname in CALIBRATIONS.items(): + f = FAMILIES[fname] + out[model] = calibration_shares(f['pre']['idle'], f['base']['idle'], f['top']) + return out + + +def resolve_input(spec): + """Normalise an input spec to (family, local profiles, helpers, width sums, explicit idle, label).""" + fname = spec.get('family', 'T74') + need(fname in FAMILIES, 'input', 'family must be T74 or T8') + fam = FAMILIES[fname] + base = fam['base'] + local, helpers, widths = {}, {}, {} + if 'delta' in spec: + d = spec['delta'] + per = dict((p, int_profile(d[p], 'delta ' + p, True)) for p in fam['calls']) if all( + p in d for p in fam['calls']) else dict((p, int_profile(d, 'delta', True)) for p in fam['calls']) + for p in fam['calls']: + local[p] = add_profiles((1, base['local'][p]), (1, per[p])) + need(all(n >= 0 for n in local[p].values()), 'input', 'delta makes a count negative for ' + p) + hp = spec.get('helpers') + for p in fam['calls']: + helpers[p] = hp.get(p) if isinstance(hp, dict) else hp + else: + prov = spec.get('providers', {}) + need(set(prov) == set(fam['calls']), 'input', 'providers must be exactly %s' % sorted(fam['calls'])) + for p in fam['calls']: + local[p] = clean(int_profile(prov[p]['profile'], 'profile ' + p)) + helpers[p] = prov[p].get('helpers') + if 'helper_width_sum' in prov[p]: + widths[p] = prov[p]['helper_width_sum'] + for p in fam['calls']: + need(all(0 < r < fam['m'] for r in local[p]), 'input', 'local rank outside (0, m) for ' + p) + if p in widths: + need(mass_of(local[p]) == fam['fixed_per_call'] + widths[p], 'local.identity', + '%s: local mass %d != %d + helper widths %d' % (p, mass_of(local[p]), fam['fixed_per_call'], widths[p])) + idle = clean(int_profile(spec['idle'], 'idle')) if 'idle' in spec else None + return fam, local, helpers, widths, idle, spec.get('label', '(unlabelled)') + + +def price_profiles(fam, local, digits, models=None, base=None, explicit_idle=None, conservative=False, + shares=None, hint=None): + """Price new local profiles on `base` (default: the family's realized base) under each model.""" + base = fam['base'] if base is None else base + models = MODEL_ORDER if models is None else models + shares = all_shares() if shares is None else shares + local_mass = sum(fam['calls'][p] * mass_of(local[p]) for p in fam['calls']) + idle_mass = total_mass(fam) - local_mass + need(idle_mass >= 0, 'compose.mass', 'local words pay more than m W - D') + E = idle_mass - mass_of(base['idle']) + rows = [] + todo = [(mn, None) for mn in models] + if explicit_idle is not None: + need(mass_of(explicit_idle) == idle_mass, 'compose.mass', 'explicit idle mass %d != required %d' % ( + mass_of(explicit_idle), idle_mass)) + todo.append(('X', explicit_idle)) + for mn, given in todo: + idle = given if given is not None else model_idle(mn, base['idle'], E, fam['top'], + shares[mn]['shares'] if mn in shares else None) + H = compose(fam, local, idle) + check_global(fam, H, '%s model %s' % (fam['name'], mn)) + ev = Moment(H, fam['m'], fam['W']) + b, steps = ev.floor_root(digits, hint) + row = dict(model=mn, text=MODEL_TEXT[mn], idle=plain(idle), idle_children=sum(idle.values()), + global_children=sum(H.values()), max_child=max(H), b=dec(b, digits), b_rational=b, + bisection_steps=steps, bit_bound=b >= BIT_LOWER) + if conservative: + cb, _ = Moment(H, fam['m'], fam['W'], surcharge=True).floor_root(digits, hint) + row['b_conservative'] = dec(cb, digits) + rows.append(row) + return dict(local_mass_total=local_mass, idle_mass=idle_mass, extra_freed_mass=E, rows=rows, + base_label=base['label']) + + +def gain_lines(rows, digits): + out = [] + for row in rows: + b = row['b_rational'] + g69, g12 = b - B_2269, b - KAPPA_2312 + row['gain_vs_pr2269'] = sci(g69) + row['gain_vs_pr2269_pct'] = pct(g69, B_2269) + row['gain_vs_pr2312'] = sci(g12) + row['gain_vs_pr2312_pct'] = pct(g12, KAPPA_2312) + out.append(' %-2s b_%d = %s gain vs #2269 %s (%s) vs #2312 %s (%s)%s' % ( + row['model'], digits, row['b'][:2 + min(digits, 24)] + ('...' if digits > 24 else ''), + sci(g69, 8), row['gain_vs_pr2269_pct'], sci(g12, 8), + row['gain_vs_pr2312_pct'], ' [BIT-BOUND]' if row['bit_bound'] else '')) + return out + + +def strip(rows): + return [dict((k, v) for k, v in r.items() if k != 'b_rational') for r in rows] + + +# ---------------------------------------------------------------------------- +# Subcommands +# ---------------------------------------------------------------------------- + +def git_blob(repo, commit, path): + got = subprocess.run(['git', '-C', repo, 'show', '%s:%s' % (commit, path)], stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + need(got.returncode == 0, 'sources', 'cannot read %s:%s in %s' % (commit[:8], path, repo)) + data = got.stdout + h = hashlib.sha1(b'blob %d\0' % len(data)) + h.update(data) + return data, h.hexdigest() + + +def run_sources(repo, receipt): + """Re-read every hard-coded PR constant from the pinned PR commits.""" + rec = {} + + def load(commit, pkg, rel, gz=False): + data, blob = git_blob(repo, commit, pkg + rel) + rec['%s:%s%s' % (commit[:8], pkg, rel)] = dict(git_blob=blob, sha256=hashlib.sha256(data).hexdigest()) + return json.loads(gzip.decompress(data) if gz else data) + + def ip(x): + return clean(dict((int(k), v) for k, v in x.items())) + + T74, T8 = FAMILIES['T74'], FAMILIES['T8'] + spec = load(PR2269_COMMIT, PR2269_PKG, 'new/SPEC.json') + Bj = load(PR2269_COMMIT, PR2269_PKG, 'outer/B.json') + top = load(PR2269_COMMIT, PR2269_PKG, 'SPEC.json') + X = spec['expected'] + need(Fraction(Bj['b']) == B_2269 and Fraction(X['complex_lower']) == COMPLEX_LOWER_2269, 'sources', 'PR2269 b') + need(ip(Bj['profile']) == T74['claim']['global_profile'] == ip(X['global_profile']), 'sources', 'PR2269 profile') + need(ip(X['idle_remainder_profile']) == T74['base']['idle'], 'sources', 'PR2269 idle') + need(X['provider_counts'] == T74['calls'] and X['rank_mass'] == total_mass(T74) and X['live'] == T74['W'] == + Bj['live'] and spec['geometry']['dimension'] == T74['m'], 'sources', 'PR2269 geometry') + for p in T74['calls']: + cc = spec['providers'][p]['complete_contract'] + need(ip(spec['providers'][p]['expected_profile']) == T74['base']['local'][p] == ip(cc['paid_profile']), + 'sources', 'PR2269 local ' + p) + need(cc['helpers'] == T74['base']['helpers'][p] and sum(cc['widths']) == T74['base']['width_sum'][p], + 'sources', 'PR2269 helpers ' + p) + TX = top['expected'] + need(ip(TX['idle_remainder_profile']) == T74['pre']['idle'] and Fraction(TX['complex_lower']) == + T74['pre']['complex_lower'], 'sources', 'PR2269 pre-borrow idle / endpoint') + for p in T74['calls']: + need(ip(top['providers'][p]['expected_profile']) == T74['pre']['local'][p] and + top['providers'][p]['complete_contract']['helpers'] == 480 and + sum(top['providers'][p]['complete_contract']['widths']) == T74['pre']['width_sum'][p], 'sources', + 'PR2269 pre-borrow local ' + p) + ar = load(PR2260_COMMIT, PR2260_PKG, 'arithmetic/EXPECTED.json') + ow = load(PR2260_COMMIT, PR2260_PKG, 'owners/EXPECTED.json') + fw = load(PR2260_COMMIT, PR2260_PKG, 'local/data/forward.json') + hp = load(PR2260_COMMIT, PR2260_PKG, 'owners/inputs/HOSTED-PARENT.json.gz', gz=True) + need(Fraction(ar['certified_complex_saving']) == T8['claim']['b'], 'sources', 'PR2260 b') + need(ip(ar['profile']) == T8['claim']['global_profile'] == ip(ow['profile']), 'sources', 'PR2260 profile') + need(ip(ow['idle']) == T8['base']['idle'], 'sources', 'PR2260 idle') + need(ar['calls'] == T8['calls']['gauge44'] and ar['live'] == T8['W'] and ar['rank_mass'] == total_mass(T8) and + ar['deficit'] == T8['deficit'] and ar['helpers_per_call'] == T8['base']['helpers']['gauge44'], + 'sources', 'PR2260 geometry') + need(ip(fw['local_profile']) == T8['base']['local']['gauge44'] and len(fw['helper_widths']) == 436 and + sum(fw['helper_widths'].values()) == T8['base']['width_sum']['gauge44'], 'sources', 'PR2260 local') + g = hp['local_providers']['gauge44'] + pidle = {} + for c in hp['idle_children']: + pidle[c['rank']] = pidle.get(c['rank'], 0) + c.get('replicas', 1) + need(clean(pidle) == T8['pre']['idle'], 'sources', 'R492 parent idle') + for o in ('forward', 'backward'): + need(ip(g['local_program_checks'][o]['paid_profile']) == T8['pre']['local']['gauge44'], 'sources', + 'R492 parent local ' + o) + need(int(g['R']) == len(g['widths']) == 492 and sum(g['widths']) == T8['pre']['width_sum']['gauge44'] and + hp['live'] == T8['W'] and hp['m'] == T8['m'], 'sources', 'R492 parent helpers') + res = load(PR2226_COMMIT, PR2226_PKG, 'RESULT.json') + need(ip(res['replay']['local_profile']) == PR2226_LOCAL and res['replay']['local_mass'] == mass_of(PR2226_LOCAL) + and res['audit']['aliases'] == 80 and res['audit']['low_aliases'] == 32, 'sources', 'PR2226 local') + need(add_profiles((1, PR2226_LOCAL), (-1, T8['base']['local']['gauge44'])) == T8_DELTA, 'sources', 'T8 delta') + receipt['sources'] = dict(repo='', blobs=rec, result='every hard-coded constant equals the pinned PR blobs') + print('sources: %d PR blobs read at pinned commits; all hard-coded constants agree' % len(rec), flush=True) + + +def run_controls(receipt, digits_model=40): + t0 = time.time() + res = {} + # evaluator self-tests (from iteration 3) + l2 = log2_enclosure() + a1, a2, a3 = atanh_enclosure(1, 26), atanh_enclosure(1, 4801), atanh_enclosure(1, 8749) + l2b = (18 * a1[0] - 2 * a2[1] + 8 * a3[0], 18 * a1[1] - 2 * a2[0] + 8 * a3[1]) + need(max(l2[0], l2b[0]) <= min(l2[1], l2b[1]), 'evaluator', 'two log 2 enclosures are disjoint') + e2 = exp_enclosure(l2[0], l2[1]) + need(e2[0] <= 2 * ONE <= e2[1], 'evaluator', 'exp(log 2) misses 2') + bad = tuple(2 * v for v in atanh_enclosure(1, 3, terms=10, tail=False)) + need(not max(bad[0], l2b[0]) <= min(bad[1], l2b[1]), 'evaluator', 'truncated log 2 without remainder not caught') + res['evaluator'] = 'log2 two formulas overlap; exp(log 2) encloses 2; truncation without remainder is caught' + for fname in ('T74', 'T8'): + base_check(FAMILIES[fname]) + res['compositions'] = ('T74: 249 P_g + 417 P_e + idle = PR2269 B.json profile; T8: 72 P + idle = PR2260 ' + 'EXPECTED profile; pre states (PR2269 pre-borrow, R492 parent) have mass m W - D; ' + 'local mass = 1856 + helper widths in all four states') + print('controls: evaluator self-tests and exact compositions PASS', flush=True) + + # (1) PR2269 claimed b reproduced exactly: b = floor_90(root) - 1e-100 + T74 = FAMILIES['T74'] + H = compose(T74, T74['base']['local'], T74['base']['idle']) + ev = Moment(H, T74['m'], T74['W']) + b90, steps = ev.floor_root(90) + need(b90 == COMPLEX_LOWER_2269, 'control.pr2269', 'floor_90(root) %s != PR2269 complex_lower' % dec(b90, 90)) + need(b90 - Fraction(1, 10 ** 100) == B_2269, 'control.pr2269', 'derived b != PR2269 b') + require_side(ev, B_2269, -1, 'PR2269 b') + require_side(ev, B_2269 + Fraction(1, 10 ** 15), 1, 'PR2269 b + 1e-15') + res['pr2269'] = dict(floor_90_root=dec(b90, 90), derived_b='floor_90(root) - 1e-100 = PR2269 outer/B.json b ' + 'exactly', bisection_steps=steps) + print('control PR2269: floor_1e-90(root) = complex_lower, so b = %s... reproduced exactly (%d steps)' % ( + dec(B_2269, 100)[:40], steps), flush=True) + # every model with the base profiles has E = 0 and returns the realized idle + for mn in MODEL_ORDER: + idle = model_idle(mn, T74['base']['idle'], 0, 48, all_shares()[mn]['shares'] if mn in CALIBRATIONS else None) + need(idle == T74['base']['idle'], 'control.models', 'model %s changes the idle at E = 0' % mn) + pr = price_profiles(T74, T74['base']['local'], 30) + need(all(r['b_rational'] == Fraction((COMPLEX_LOWER_2269 * 10 ** 30).__floor__(), 10 ** 30) for r in pr['rows']), + 'control.models', 'models with PR2269 own profiles do not reproduce its b') + res['pr2269_models_E0'] = 'F, C, C8, P with PR2269 own profiles: E = 0, idle unchanged, b_30 = floor_30(b) for all' + print('control PR2269 via the CLI path: E = 0 for F/C/C8/P and b_30 = %s for all' % pr['rows'][0]['b'], flush=True) + + # (2) PR2269 pre-borrow stale assembly endpoint (1e-24 grid) + Hpre = compose(T74, T74['pre']['local'], T74['pre']['idle']) + bpre, _ = Moment(Hpre, T74['m'], T74['W']).floor_root(24) + need(bpre == T74['pre']['complex_lower'], 'control.preborrow', 'pre-borrow 1e-24 endpoint not reproduced') + res['pr2269_preborrow'] = dict(floor_24_root=dec(bpre, 24), equals='PR2269 SPEC.json / evidence/ASSEMBLY.json ' + 'complex_lower (stale pre-borrow assembly)') + print('control PR2269 pre-borrow: floor_1e-24(root) = %s = stale ASSEMBLY complex_lower' % dec(bpre, 24), flush=True) + + # (3) PR2260 b = 0.0016834 = floor_7(root), native and conservative + T8 = FAMILIES['T8'] + H8 = compose(T8, T8['base']['local'], T8['base']['idle']) + ev8 = Moment(H8, T8['m'], T8['W']) + ev8c = Moment(H8, T8['m'], T8['W'], surcharge=True) + b7, _ = ev8.floor_root(7) + b7c, _ = ev8c.floor_root(7) + need(b7 == T8['claim']['b'] == b7c, 'control.pr2260', 'floor_7(root) %s / conservative %s != 0.0016834' % ( + dec(b7, 7), dec(b7c, 7))) + r8, _ = ev8.floor_root(40) + res['pr2260'] = dict(floor_7_root_native=dec(b7, 7), floor_7_root_conservative=dec(b7c, 7), + b_40=dec(r8, 40), equals='PR2260 arithmetic/EXPECTED.json certified_complex_saving 8417/5000000') + print('control PR2260: floor_1e-7(root) = %s (native and conservative) = claimed b; b_40 = %s' % ( + dec(b7, 7), dec(r8, 40)), flush=True) + + # (4) calibrated model in-sample identity: PR2269 pre-borrow base + PR2269 local -> PR2269 idle exactly + sh = all_shares() + need(sh['C']['all_increments_nonnegative'], 'control.calibration', 'T74 split has a negative increment') + E_t74 = total_mass(T74) - sum(T74['calls'][p] * mass_of(T74['base']['local'][p]) for p in T74['calls']) - \ + mass_of(T74['pre']['idle']) + need(E_t74 == sh['C']['E_ref'] == 138198, 'control.calibration', 'E_ref') + idle_c = model_idle('C', T74['pre']['idle'], E_t74, 48, sh['C']['shares']) + need(idle_c == T74['base']['idle'], 'control.calibration', 'C does not reproduce PR2269 idle in-sample') + res['calibration'] = dict( + C=dict(E_ref=sh['C']['E_ref'], shares=dict((str(r), str(s)) for r, s in sh['C']['shares'].items()), + top_share=float(sh['C']['top_share']), + in_sample='PR2269 pre-borrow idle {48:22748} + E_ref under C = PR2269 realized idle exactly'), + C8=dict(E_ref=sh['C8']['E_ref'], shares=dict((str(r), str(s)) for r, s in sh['C8']['shares'].items()), + top_share=float(sh['C8']['top_share']), delta_mass=plain(sh['C8']['delta_mass']), + note='R492 parent residues (ranks 2..44) were repacked away; net top-rank share kept')) + print('control calibration: T74 shares s48=%s (%.4f), C reproduces PR2269 idle in-sample exactly; T8 top share ' + '%s (%.4f)' % (sh['C']['top_share'], float(sh['C']['top_share']), sh['C8']['top_share'], + float(sh['C8']['top_share'])), flush=True) + + # (5) out-of-sample model check: predict each realized record from its own predecessor + oos = {} + for fname in ('T74', 'T8'): + fam = FAMILIES[fname] + pr = price_profiles(fam, fam['base']['local'], digits_model, base=fam['pre']) + Hr = compose(fam, fam['base']['local'], fam['base']['idle']) + rb, _ = Moment(Hr, fam['m'], fam['W']).floor_root(digits_model) + rows = {} + for row in pr['rows']: + rows[row['model']] = dict(b=row['b'], minus_realized=str(row['b_rational'] - rb), + fraction_of_realized_gain_over_pre=None) + pre_b, _ = Moment(compose(fam, fam['pre']['local'], fam['pre']['idle']), fam['m'], fam['W']).floor_root( + digits_model) + for row in pr['rows']: + rows[row['model']]['fraction_of_realized_gain_over_pre'] = '%.4f' % float( + (row['b_rational'] - pre_b) / (rb - pre_b)) + oos[fname] = dict(start=fam['pre']['label'], target=fam['base']['label'], E=pr['extra_freed_mass'], + realized_b=dec(rb, digits_model), predecessor_b=dec(pre_b, digits_model), models=rows) + print('out-of-sample %s (%s -> realized, E=%d): realized b %s' % ( + fname, fam['pre']['label'].split(' (')[0], pr['extra_freed_mass'], dec(rb, digits_model)[:24]), flush=True) + for mn in MODEL_ORDER: + print(' %-2s model b %s (model - realized %s; share of realized gain %s)' % ( + mn, rows[mn]['b'][:24], sci(Fraction(rows[mn]['minus_realized']), 6), rows[mn]['fraction_of_realized_gain_over_pre']), + flush=True) + res['out_of_sample'] = oos + + # (6) negative controls + neg = [] + + def expect(name, target, fn): + try: + fn() + except HarnessError as e: + neg.append(dict(name=name, rejected_by=e.check, ok=e.check == target)) + return + neg.append(dict(name=name, rejected_by=None, ok=False)) + + split = dict(H) + split[48] -= 1 + split[47] = 1 + split[1] += 1 + expect('one idle 48 -> 47 + 1: PR2269 b no longer admissible', 'moment.accept', + lambda: require_side(Moment(clean(split), 73, 66304), B_2269, -1, 'split')) + expect('PR2269 complex_lower + 1e-90 claimed admissible', 'moment.accept', + lambda: require_side(ev, COMPLEX_LOWER_2269 + Fraction(1, 10 ** 90), -1, 'endpoint + 1e-90')) + bad_idle = dict(T74['base']['idle']) + bad_idle[48] += 1 + expect('idle with one extra rank-48 child (mass identity)', 'compose.mass', + lambda: check_global(T74, compose(T74, T74['base']['local'], bad_idle), 'tampered')) + expect('W off by one', 'compose.mass', lambda: check_global(dict(T74, W=66305), H, 'W+1')) + expect('local mass != 1856 + widths', 'local.identity', + lambda: resolve_input({'family': 'T74', 'providers': { + 'gauge44': {'profile': plain(T74['base']['local']['gauge44']), 'helper_width_sum': 3528}, + 'extra': {'profile': plain(T74['base']['local']['extra'])}}})) + expect('48 rank-52 children replace 52 rank-48 children (halving guard 2*52^2 > 73^2)', 'compose.halving', + lambda: check_global(T74, add_profiles((1, H), (1, {52: 48}), (-1, {48: 52})), 'rank52')) + expect('explicit idle with the wrong mass', 'compose.mass', + lambda: price_profiles(T74, T74['base']['local'], 8, models=[], explicit_idle={48: 1})) + ok = all(x['ok'] for x in neg) + res['negative_controls'] = neg + print('negative controls: %d/%d rejected by their targeted checks' % (sum(x['ok'] for x in neg), len(neg)), + flush=True) + need(ok, 'controls', 'a negative control was not rejected by its target: %r' % neg) + res['elapsed_s'] = round(time.time() - t0, 1) + receipt['controls'] = res + + +def report_price(spec, digits, conservative, receipt, key): + fam, local, helpers, widths, idle, label = resolve_input(spec) + pr = price_profiles(fam, local, digits, explicit_idle=idle, conservative=conservative) + print('%s [%s]: %s' % (key, fam['name'], label), flush=True) + for p in sorted(fam['calls']): + print(' %s x%d: profile %s mass %d helpers %s' % (p, fam['calls'][p], plain(local[p]), mass_of(local[p]), + helpers.get(p)), flush=True) + print(' idle mass %d, extra freed mass vs %s: E = %d' % (pr['idle_mass'], pr['base_label'].split(' (')[0], + pr['extra_freed_mass']), flush=True) + lines = gain_lines(pr['rows'], digits) + for ln in lines: + print(ln, flush=True) + if fam['name'] == 'T8': + print(' (T8 gains are printed against the T74 references only for orientation; compare with the T8 base ' + 'b instead)', flush=True) + receipt[key] = dict(family=fam['name'], label=label, local_profiles=dict((p, plain(local[p])) for p in local), + local_mass=dict((p, mass_of(local[p])) for p in local), helpers=helpers, + idle_mass=pr['idle_mass'], extra_freed_mass=pr['extra_freed_mass'], digits=digits, + base=pr['base_label'], models=strip(pr['rows'])) + return pr + + +def demo_spec(): + return {'family': 'T74', 'label': 'PROXY: T8 transfer delta (PR2226 80-alias word minus PR2260 44-high word) ' + 'applied to both PR2269 T74 words; not a constructed word', + 'delta': plain(T8_DELTA), 'helpers': {'gauge44': 401, 'extra': 401}} + + +def run_demo(digits, conservative, receipt): + spec = demo_spec() + with open(os.path.join(HERE, 'demo-t8-delta-proxy.json'), 'w') as fh: + json.dump(spec, fh, indent=1, sort_keys=True) + fh.write('\n') + report_price(spec, digits, conservative, receipt, 'demo_t74_proxy') + # T8 analogue: PR2226's actual word on PR2260's realized fill (same models; still a model price) + t8 = {'family': 'T8', 'label': 'PR2226 actual 80-alias T8 word priced on PR2260 realized fill (model)', + 'providers': {'gauge44': {'profile': plain(PR2226_LOCAL), 'helpers': PR2226_HELPERS, + 'helper_width_sum': mass_of(PR2226_LOCAL) - 1856}}} + pr = report_price(t8, digits, conservative, receipt, 'demo_t8_pr2226') + T8 = FAMILIES['T8'] + b8, _ = Moment(compose(T8, T8['base']['local'], T8['base']['idle']), 73, 7168).floor_root(digits) + for row in pr['rows']: + row_t8 = '%s (%s)' % (sci(row['b_rational'] - b8, 8), pct(row['b_rational'] - b8, b8)) + print(' %-2s T8 gain over PR2260 realized b: %s' % (row['model'], row_t8), flush=True) + receipt['demo_t8_pr2226']['gain_vs_pr2260_realized'] = dict( + (row['model'], sci(row['b_rational'] - b8)) for row in pr['rows']) + + +def main(): + ap = argparse.ArgumentParser(description='Extended T74/T8 supplier pricing under explicit idle-refill models') + ap.add_argument('cmd', choices=['controls', 'price', 'demo', 'sources', 'all']) + ap.add_argument('input', nargs='?', help='profiles JSON for `price`') + ap.add_argument('--digits', type=int, default=40, help='decimal grid 10^-D for model prices (default 40)') + ap.add_argument('--conservative', action='store_true', help='also price the surcharge (conservative) side') + ap.add_argument('--repo', default=DEFAULT_REPO, help='git checkout holding the pinned PR commits (sources)') + ap.add_argument('--out', nargs='?', const='', default=None, + help='write a JSON receipt next to this script (default price_ext..receipt.json)') + args = ap.parse_args() + need(8 <= args.digits <= 200, 'input', '--digits must be in [8, 200]') + receipt = dict(tool='price_ext.py', python=sys.version.split()[0], prec_bits=PREC, credits=CREDITS, + model=__doc__.split('MODEL (stated precisely; also written to receipts).')[1].strip(), + references=dict(pr2269_b=dec(B_2269, 100), pr2312_kappa=str(KAPPA_2312), bit_lower=str(BIT_LOWER))) + t0 = time.time() + ok = True + try: + if args.cmd in ('sources', 'all'): + run_sources(args.repo, receipt) + if args.cmd in ('controls', 'all'): + run_controls(receipt) + if args.cmd in ('demo', 'all'): + run_demo(args.digits, args.conservative, receipt) + if args.cmd == 'price': + need(args.input is not None, 'input', 'price needs an INPUT.json') + with open(args.input) as fh: + spec = json.load(fh) + report_price(spec, args.digits, args.conservative, receipt, 'price') + except HarnessError as e: + ok = False + receipt['failure'] = str(e) + print('FAILED: %s' % e, flush=True) + receipt['result'] = PASS_LINE if ok else FAIL_LINE + receipt['elapsed_s'] = round(time.time() - t0, 1) + if args.out is not None: + path = args.out or os.path.join(HERE, 'price_ext.%s.receipt.json' % args.cmd) + with open(path, 'w') as fh: + json.dump(receipt, fh, indent=1, sort_keys=True, default=str) + fh.write('\n') + print('receipt written: %s' % path) + print('elapsed %.1f s' % (time.time() - t0)) + print(PASS_LINE if ok else FAIL_LINE) + return 0 if ok else 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/research/t74-low-alias-borrowing/receipts/AUDIT-80base.json b/research/t74-low-alias-borrowing/receipts/AUDIT-80base.json new file mode 100644 index 0000000000..fc16634cfd --- /dev/null +++ b/research/t74-low-alias-borrowing/receipts/AUDIT-80base.json @@ -0,0 +1,43 @@ +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "BORROW-WORD-80base.json.gz", + "content_sha256": "16d864123e3357ed02ff4c96f2eddef31eeb41b8b56becd1720533b0b517a4ce", + "compressed_sha256": "61290abffd8c8225e0abb3958c1506674e256de688fc4cdf358bbe7c981df493", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 80, + "independent_inputs": 624, + "warps": 80, + "corrections": 64, + "restored_cold": 44, + "zero_buffers": 44, + "entering": 112, + "local_profile": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "local_mass": 5264, + "width_inventory": { + "4": 4, + "5": 4, + "7": 36, + "8": 84, + "9": 272 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": { + "base_sha256": "65c6d17ffee2eacf27bff438f37fc549c9ed0c909cbc7a52976cc75cf2d15b91", + "sections_match_minus_removed": true + }, + "checked_columns": 624, + "elapsed_seconds": 0.8755109640005685, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} diff --git a/research/t74-low-alias-borrowing/receipts/AUDIT-80extra.json b/research/t74-low-alias-borrowing/receipts/AUDIT-80extra.json new file mode 100644 index 0000000000..b1b0c4d69e --- /dev/null +++ b/research/t74-low-alias-borrowing/receipts/AUDIT-80extra.json @@ -0,0 +1,43 @@ +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "BORROW-WORD-80extra.json.gz", + "content_sha256": "a77502a685a6b8bb4b5d36803f3369aaabf9b9d199f86e91e6109c3298e7cf72", + "compressed_sha256": "1dd2d6f2ae5b5a27b5f89fb830203f0cca7a78d0323a7845e85e1e80f8f6d1a5", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 80, + "independent_inputs": 624, + "warps": 80, + "corrections": 64, + "restored_cold": 44, + "zero_buffers": 44, + "entering": 112, + "local_profile": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "local_mass": 5264, + "width_inventory": { + "4": 4, + "5": 4, + "7": 36, + "8": 84, + "9": 272 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": { + "base_sha256": "d7e48dcbafa236a2e1e41f7958244211506f7c7630fe6a2d43d2bdf17b7ae015", + "sections_match_minus_removed": true + }, + "checked_columns": 624, + "elapsed_seconds": 0.8318211419973522, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} diff --git a/research/t74-low-alias-borrowing/receipts/BUILD.json b/research/t74-low-alias-borrowing/receipts/BUILD.json new file mode 100644 index 0000000000..795b11a7f5 --- /dev/null +++ b/research/t74-low-alias-borrowing/receipts/BUILD.json @@ -0,0 +1,1674 @@ +{ + "pins_git_blob": { + "PR2226-WITNESS.json": "62edbcce166f7cf388231078c2cd7f75939b97e2", + "blocks.json": "c683574b3861678081fd5c5944dbd7a47309f6fd", + "extra.canonical.json.gz": "e0d670d4351229ce6921ecfbecf180070b17616b", + "gauge44.canonical.json.gz": "4abb6e28f02c95b41ed345d4e4401d16d58ae791", + "witness_43_base.json": "9f4b93f3bc52d4f4ffaa128cfd7ae574fd36c462", + "witness_43_extra.json": "864ba533f50c2f1f639a6a3559b185bd321b923a" + }, + "seconds": 48.6, + "status": "PASS_T74_LOW_ALIAS_EXTENSION", + "words": { + "extra": { + "base_43": { + "helpers": 437, + "local_mass": 5385, + "local_profile": { + "1": 2339, + "2": 509, + "3": 418, + "4": 125, + "5": 42, + "8": 8 + } + }, + "controls_rc": 0, + "ext80": { + "controls": "omitted compensation and one flipped sign rejected", + "helpers": 400, + "independent_input_columns": 624, + "initial_corrections": 64, + "local_mass": 5264, + "local_profile": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "low": 32, + "pairs": 80, + "zero_FULL_cleanup_buffers": 44 + }, + "high5": { + "controls": "n/a", + "helpers": 432, + "independent_input_columns": 656, + "initial_corrections": 0, + "local_mass": 5360, + "local_profile": { + "1": 2339, + "2": 509, + "3": 418, + "4": 125, + "5": 37, + "8": 8 + }, + "low": 0, + "pairs": 48, + "zero_FULL_cleanup_buffers": 76 + }, + "independent_audit": { + "corrections": 64, + "independent_inputs": 624, + "local_mass": 5264, + "local_profile": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "orientations": { + "dual": "PASS", + "forward": "PASS" + }, + "removed_helpers": 80, + "restored_cold": 44, + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "warps": 80, + "width_inventory": { + "4": 4, + "5": 4, + "7": 36, + "8": 84, + "9": 272 + } + }, + "low32": { + "controls": "omitted compensation and one flipped sign rejected", + "helpers": 405, + "independent_input_columns": 629, + "initial_corrections": 64, + "local_mass": 5289, + "local_profile": { + "1": 2287, + "2": 535, + "3": 386, + "4": 125, + "5": 42, + "8": 8 + }, + "low": 32, + "pairs": 75, + "zero_FULL_cleanup_buffers": 44 + }, + "low_candidates": { + "592": { + "deleted_prefix_indices": [ + 56, + 57, + 58, + 59 + ], + "early_prefix_rewrites": {}, + "lender": 298, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "593": { + "deleted_prefix_indices": [ + 60, + 61, + 62, + 63 + ], + "early_prefix_rewrites": {}, + "lender": 291, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "594": { + "deleted_prefix_indices": [ + 64, + 65, + 66, + 67 + ], + "early_prefix_rewrites": {}, + "lender": 289, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "596": { + "deleted_prefix_indices": [ + 68, + 69, + 70, + 71 + ], + "early_prefix_rewrites": {}, + "lender": 314, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "600": { + "deleted_prefix_indices": [ + 72, + 73, + 74, + 75 + ], + "early_prefix_rewrites": {}, + "lender": 305, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "601": { + "deleted_prefix_indices": [ + 76, + 77, + 78, + 79 + ], + "early_prefix_rewrites": {}, + "lender": 325, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "602": { + "deleted_prefix_indices": [ + 80, + 81, + 82, + 83 + ], + "early_prefix_rewrites": {}, + "lender": 330, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "604": { + "deleted_prefix_indices": [ + 84, + 85, + 86, + 87 + ], + "early_prefix_rewrites": {}, + "lender": 323, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "608": { + "deleted_prefix_indices": [ + 88, + 89, + 90, + 91 + ], + "early_prefix_rewrites": {}, + "lender": 346, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "609": { + "deleted_prefix_indices": [ + 92, + 93, + 94, + 95 + ], + "early_prefix_rewrites": {}, + "lender": 339, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "610": { + "deleted_prefix_indices": [ + 96, + 97, + 98, + 99 + ], + "early_prefix_rewrites": {}, + "lender": 337, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "612": { + "deleted_prefix_indices": [ + 100, + 101, + 102, + 103 + ], + "early_prefix_rewrites": {}, + "lender": 362, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "624": { + "deleted_prefix_indices": [ + 122, + 123, + 124, + 125 + ], + "early_prefix_rewrites": {}, + "lender": 378, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "625": { + "deleted_prefix_indices": [ + 126, + 127, + 128, + 129 + ], + "early_prefix_rewrites": {}, + "lender": 371, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "626": { + "deleted_prefix_indices": [ + 130, + 131, + 132, + 133 + ], + "early_prefix_rewrites": {}, + "lender": 369, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "628": { + "deleted_prefix_indices": [ + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141 + ], + "early_prefix_rewrites": { + "136": [ + [ + "add", + 214, + 566, + -1, + 1, + 3 + ] + ], + "140": [ + [ + "add", + 151, + 567, + 1, + 1, + 3 + ] + ] + }, + "lender": 394, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "632": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 142, + 143, + 144, + 145 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "633": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 146, + 147, + 148, + 149 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "634": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 150, + 151, + 152, + 153 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "636": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "640": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 162, + 163, + 164, + 165 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "641": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "642": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 174, + 175, + 176, + 177 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "644": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 178, + 179, + 180, + 181 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "648": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 182, + 183, + 184, + 185 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "649": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 186, + 187, + 188, + 189 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "650": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 190, + 191, + 192, + 193 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "652": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 194, + 195, + 196, + 197 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "656": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 198, + 199, + 200, + 201 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "657": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 202, + 203, + 204, + 205 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "658": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 206, + 207, + 208, + 209 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "660": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 210, + 211, + 212, + 213 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "672": { + "deleted_prefix_indices": [ + 6, + 230, + 231, + 232, + 233, + 234 + ], + "early_prefix_rewrites": { + "230": [ + [ + "add", + 117, + 566, + 1, + 1, + 3 + ] + ], + "231": [ + [ + "add", + 181, + 566, + -1, + 1, + 3 + ] + ] + }, + "lender": 385, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "673": { + "deleted_prefix_indices": [ + 235, + 236, + 237, + 238 + ], + "early_prefix_rewrites": {}, + "lender": 387, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "674": { + "deleted_prefix_indices": [ + 239, + 240, + 241, + 242 + ], + "early_prefix_rewrites": {}, + "lender": 389, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "676": { + "deleted_prefix_indices": [ + 243, + 244, + 245, + 246, + 247, + 248 + ], + "early_prefix_rewrites": { + "245": [ + [ + "add", + 181, + 566, + 1, + 1, + 3 + ] + ] + }, + "lender": 373, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "680": { + "deleted_prefix_indices": [ + 249, + 250, + 251, + 252 + ], + "early_prefix_rewrites": {}, + "lender": 353, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "681": { + "deleted_prefix_indices": [ + 253, + 254, + 255, + 256 + ], + "early_prefix_rewrites": {}, + "lender": 355, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "682": { + "deleted_prefix_indices": [ + 257, + 258, + 259, + 260 + ], + "early_prefix_rewrites": {}, + "lender": 357, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "684": { + "deleted_prefix_indices": [ + 261, + 262, + 263, + 264 + ], + "early_prefix_rewrites": {}, + "lender": 341, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "688": { + "deleted_prefix_indices": [ + 265, + 266, + 267, + 268 + ], + "early_prefix_rewrites": {}, + "lender": 321, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "689": { + "deleted_prefix_indices": [ + 269, + 270, + 271, + 272 + ], + "early_prefix_rewrites": {}, + "lender": 277, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "690": { + "deleted_prefix_indices": [ + 273, + 274, + 275, + 276 + ], + "early_prefix_rewrites": {}, + "lender": 282, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "692": { + "deleted_prefix_indices": [ + 277, + 278, + 279, + 280 + ], + "early_prefix_rewrites": {}, + "lender": 307, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "696": { + "deleted_prefix_indices": [ + 281, + 282, + 283, + 284 + ], + "early_prefix_rewrites": {}, + "lender": 275, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "697": { + "deleted_prefix_indices": [ + 285, + 286, + 287, + 288 + ], + "early_prefix_rewrites": {}, + "lender": 273, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "698": { + "deleted_prefix_indices": [ + 289, + 290, + 291, + 292 + ], + "early_prefix_rewrites": {}, + "lender": 309, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "700": { + "deleted_prefix_indices": [ + 293, + 294, + 295, + 296 + ], + "early_prefix_rewrites": {}, + "lender": 293, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + } + }, + "low_lender_pool": [ + 273, + 275, + 277, + 282, + 289, + 291, + 293, + 298, + 305, + 307, + 309, + 314, + 321, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394 + ], + "mass_identity_1856_plus_width_sum": true, + "omitted_high": { + "606": { + "T8_lender": 395, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 12, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 13 + }, + "635": { + "T8_lender": 363, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 6, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 14 + }, + "637": { + "T8_lender": 530, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 31, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 12 + }, + "638": { + "T8_lender": 331, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 4, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 15 + }, + "639": { + "T8_lender": 299, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 1, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 16 + } + }, + "width_sum": 3408, + "word": { + "content_sha256": "a77502a685a6b8bb4b5d36803f3369aaabf9b9d199f86e91e6109c3298e7cf72", + "path": "words/BORROW-WORD-80extra.json.gz" + } + }, + "gauge44": { + "base_43": { + "helpers": 437, + "local_mass": 5385, + "local_profile": { + "1": 2351, + "2": 501, + "3": 414, + "4": 129, + "5": 42, + "8": 8 + } + }, + "controls_rc": 0, + "ext80": { + "controls": "omitted compensation and one flipped sign rejected", + "helpers": 400, + "independent_input_columns": 624, + "initial_corrections": 64, + "local_mass": 5264, + "local_profile": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "low": 32, + "pairs": 80, + "zero_FULL_cleanup_buffers": 44 + }, + "high5": { + "controls": "n/a", + "helpers": 432, + "independent_input_columns": 656, + "initial_corrections": 0, + "local_mass": 5360, + "local_profile": { + "1": 2351, + "2": 501, + "3": 414, + "4": 129, + "5": 37, + "8": 8 + }, + "low": 0, + "pairs": 48, + "zero_FULL_cleanup_buffers": 76 + }, + "independent_audit": { + "corrections": 64, + "independent_inputs": 624, + "local_mass": 5264, + "local_profile": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 37, + "8": 8 + }, + "orientations": { + "dual": "PASS", + "forward": "PASS" + }, + "removed_helpers": 80, + "restored_cold": 44, + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "warps": 80, + "width_inventory": { + "4": 4, + "5": 4, + "7": 36, + "8": 84, + "9": 272 + } + }, + "low32": { + "controls": "omitted compensation and one flipped sign rejected", + "helpers": 405, + "independent_input_columns": 629, + "initial_corrections": 64, + "local_mass": 5289, + "local_profile": { + "1": 2303, + "2": 527, + "3": 386, + "4": 125, + "5": 42, + "8": 8 + }, + "low": 32, + "pairs": 75, + "zero_FULL_cleanup_buffers": 44 + }, + "low_candidates": { + "592": { + "deleted_prefix_indices": [ + 56, + 57, + 58, + 59 + ], + "early_prefix_rewrites": {}, + "lender": 298, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "593": { + "deleted_prefix_indices": [ + 60, + 61, + 62, + 63 + ], + "early_prefix_rewrites": {}, + "lender": 291, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "594": { + "deleted_prefix_indices": [ + 64, + 65, + 66, + 67 + ], + "early_prefix_rewrites": {}, + "lender": 289, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "596": { + "deleted_prefix_indices": [ + 68, + 69, + 70, + 71 + ], + "early_prefix_rewrites": {}, + "lender": 314, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "600": { + "deleted_prefix_indices": [ + 72, + 73, + 74, + 75 + ], + "early_prefix_rewrites": {}, + "lender": 305, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "601": { + "deleted_prefix_indices": [ + 76, + 77, + 78, + 79 + ], + "early_prefix_rewrites": {}, + "lender": 325, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "602": { + "deleted_prefix_indices": [ + 80, + 81, + 82, + 83 + ], + "early_prefix_rewrites": {}, + "lender": 330, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "604": { + "deleted_prefix_indices": [ + 84, + 85, + 86, + 87 + ], + "early_prefix_rewrites": {}, + "lender": 323, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "608": { + "deleted_prefix_indices": [ + 88, + 89, + 90, + 91 + ], + "early_prefix_rewrites": {}, + "lender": 346, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "609": { + "deleted_prefix_indices": [ + 92, + 93, + 94, + 95 + ], + "early_prefix_rewrites": {}, + "lender": 339, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "610": { + "deleted_prefix_indices": [ + 96, + 97, + 98, + 99 + ], + "early_prefix_rewrites": {}, + "lender": 337, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "612": { + "deleted_prefix_indices": [ + 100, + 101, + 102, + 103 + ], + "early_prefix_rewrites": {}, + "lender": 362, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "624": { + "deleted_prefix_indices": [ + 122, + 123, + 124, + 125 + ], + "early_prefix_rewrites": {}, + "lender": 378, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "625": { + "deleted_prefix_indices": [ + 126, + 127, + 128, + 129 + ], + "early_prefix_rewrites": {}, + "lender": 371, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "626": { + "deleted_prefix_indices": [ + 130, + 131, + 132, + 133 + ], + "early_prefix_rewrites": {}, + "lender": 369, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "628": { + "deleted_prefix_indices": [ + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141 + ], + "early_prefix_rewrites": { + "136": [ + [ + "add", + 214, + 566, + -1, + 1, + 3 + ] + ], + "140": [ + [ + "add", + 151, + 567, + 1, + 1, + 3 + ] + ] + }, + "lender": 394, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "632": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 142, + 143, + 144, + 145 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "633": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 146, + 147, + 148, + 149 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "634": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 150, + 151, + 152, + 153 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "636": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "640": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 162, + 163, + 164, + 165 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "641": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "642": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 174, + 175, + 176, + 177 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "644": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 178, + 179, + 180, + 181 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "648": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 182, + 183, + 184, + 185 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "649": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 186, + 187, + 188, + 189 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "650": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 190, + 191, + 192, + 193 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "652": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 194, + 195, + 196, + 197 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "656": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 198, + 199, + 200, + 201 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "657": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 202, + 203, + 204, + 205 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "658": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 206, + 207, + 208, + 209 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "660": { + "blocker": "no eligible lender: the set of non-target registers that are retired before the handoff, have a zero-dimensional entrance frame (so K_G z is free to read into the frame-zero target) and equal their own initial dirty input at the handoff has exactly 32 members at every one of the 12 handoffs; all 32 are consumed by the 32 transferred low aliases (free now: 0)", + "prefix_events_deleted": [ + 210, + 211, + 212, + 213 + ], + "prefix_plan_legal": true, + "status": "BLOCKED" + }, + "672": { + "deleted_prefix_indices": [ + 6, + 230, + 231, + 232, + 233, + 234 + ], + "early_prefix_rewrites": { + "230": [ + [ + "add", + 117, + 566, + 1, + 1, + 3 + ] + ], + "231": [ + [ + "add", + 181, + 566, + -1, + 1, + 3 + ] + ] + }, + "lender": 385, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "673": { + "deleted_prefix_indices": [ + 235, + 236, + 237, + 238 + ], + "early_prefix_rewrites": {}, + "lender": 387, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "674": { + "deleted_prefix_indices": [ + 239, + 240, + 241, + 242 + ], + "early_prefix_rewrites": {}, + "lender": 389, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "676": { + "deleted_prefix_indices": [ + 243, + 244, + 245, + 246, + 247, + 248 + ], + "early_prefix_rewrites": { + "245": [ + [ + "add", + 181, + 566, + 1, + 1, + 3 + ] + ] + }, + "lender": 373, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "680": { + "deleted_prefix_indices": [ + 249, + 250, + 251, + 252 + ], + "early_prefix_rewrites": {}, + "lender": 353, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "681": { + "deleted_prefix_indices": [ + 253, + 254, + 255, + 256 + ], + "early_prefix_rewrites": {}, + "lender": 355, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "682": { + "deleted_prefix_indices": [ + 257, + 258, + 259, + 260 + ], + "early_prefix_rewrites": {}, + "lender": 357, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "684": { + "deleted_prefix_indices": [ + 261, + 262, + 263, + 264 + ], + "early_prefix_rewrites": {}, + "lender": 341, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "688": { + "deleted_prefix_indices": [ + 265, + 266, + 267, + 268 + ], + "early_prefix_rewrites": {}, + "lender": 321, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "689": { + "deleted_prefix_indices": [ + 269, + 270, + 271, + 272 + ], + "early_prefix_rewrites": {}, + "lender": 277, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "690": { + "deleted_prefix_indices": [ + 273, + 274, + 275, + 276 + ], + "early_prefix_rewrites": {}, + "lender": 282, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "692": { + "deleted_prefix_indices": [ + 277, + 278, + 279, + 280 + ], + "early_prefix_rewrites": {}, + "lender": 307, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "696": { + "deleted_prefix_indices": [ + 281, + 282, + 283, + 284 + ], + "early_prefix_rewrites": {}, + "lender": 275, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "697": { + "deleted_prefix_indices": [ + 285, + 286, + 287, + 288 + ], + "early_prefix_rewrites": {}, + "lender": 273, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "698": { + "deleted_prefix_indices": [ + 289, + 290, + 291, + 292 + ], + "early_prefix_rewrites": {}, + "lender": 309, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + }, + "700": { + "deleted_prefix_indices": [ + 293, + 294, + 295, + 296 + ], + "early_prefix_rewrites": {}, + "lender": 293, + "lender_source": "PR2226 lender transfers", + "status": "ALIASED" + } + }, + "low_lender_pool": [ + 273, + 275, + 277, + 282, + 289, + 291, + 293, + 298, + 305, + 307, + 309, + 314, + 321, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394 + ], + "mass_identity_1856_plus_width_sum": true, + "omitted_high": { + "606": { + "T8_lender": 395, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 12, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 13 + }, + "635": { + "T8_lender": 363, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 6, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 14 + }, + "637": { + "T8_lender": 530, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 31, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 12 + }, + "638": { + "T8_lender": 331, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 4, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 15 + }, + "639": { + "T8_lender": 299, + "T8_lender_blocker": "paid dimension-drop handoff 5->4 (outside PR2226 rank-zero scope)", + "T8_lender_dim_at_handoff": 5, + "helper_entrance_dim_T74": 4, + "helper_first_frame_dim_T74": 4, + "lender": 1, + "lender_dim_at_handoff": 4, + "lender_final_dim": 9, + "status": "ALIASED", + "zero_rank_candidates": 16 + } + }, + "width_sum": 3408, + "word": { + "content_sha256": "16d864123e3357ed02ff4c96f2eddef31eeb41b8b56becd1720533b0b517a4ce", + "path": "words/BORROW-WORD-80base.json.gz" + } + } + } +} diff --git a/research/t74-low-alias-borrowing/receipts/CONTROLS-80base.json b/research/t74-low-alias-borrowing/receipts/CONTROLS-80base.json new file mode 100644 index 0000000000..9c6a9e8dc0 --- /dev/null +++ b/research/t74-low-alias-borrowing/receipts/CONTROLS-80base.json @@ -0,0 +1,148 @@ +{ + "all_controls_rejected_for_expected_reason": true, + "controls": [ + { + "control": "unmutated", + "rejected": false, + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD" + }, + { + "control": "wrong G (invertible, G(from)!=to)", + "rejected": true, + "reason": "G(from)!=to", + "expected_reason_match": true + }, + { + "control": "non-invertible G", + "rejected": true, + "reason": "G not invertible", + "expected_reason_match": true + }, + { + "control": "non-invertible G (zero column)", + "rejected": true, + "reason": "G not invertible", + "expected_reason_match": true + }, + { + "control": "frame mismatch (from frame differs from current)", + "rejected": true, + "reason": "G(from)!=to", + "expected_reason_match": true + }, + { + "control": "frame mismatch (consistent G, from frame differs from lender current frame)", + "rejected": true, + "reason": "warp frame mismatch (1, 243, (261, 133, 85, 45), (260, 133, 85, 45))", + "expected_reason_match": true + }, + { + "control": "frame mismatch (warp moved to a position where the lender frame differs)", + "rejected": true, + "reason": "frame not monotone (243, (261, 133, 85, 45), (320, 192, 45, 30))", + "expected_reason_match": true + }, + { + "control": "missing inverse warp in cleanup", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "all inverse warps missing", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "algebra without inverse warps does not restore inputs", + "failed_inputs": 190, + "rejected": true + }, + { + "control": "dim(from)!=dim(to)", + "rejected": true, + "reason": "dim(from)!=dim(to)", + "expected_reason_match": true + }, + { + "control": "inverse warp not at FULL", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "cleanup uses real restored input instead of private buffer", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "restoration gate dropped (derived cleanup)", + "rejected": true, + "reason": "paid profile mismatch {1: 2303, 2: 525, 3: 386, 4: 126, 5: 37, 8: 8}", + "expected_reason_match": true + }, + { + "control": "false cold-restoration claim (register not restored)", + "rejected": true, + "reason": "frame not monotone (273, (257, 128, 64, 33, 16, 8, 4, 2), (1,))", + "expected_reason_match": true + }, + { + "control": "restoration gate dropped", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "gate on removed helper", + "rejected": true, + "reason": "register out of range or removed helper referenced", + "expected_reason_match": true + }, + { + "control": "initial correction omitted", + "rejected": true, + "reason": "target map failed 2", + "expected_reason_match": true + }, + { + "control": "initial correction sign flipped", + "rejected": true, + "reason": "target map failed 2", + "expected_reason_match": true + }, + { + "control": "initial correction reads a non-lender", + "rejected": true, + "reason": "correction source is not the lender of its operator", + "expected_reason_match": true + }, + { + "control": "initial correction reads an entering helper", + "rejected": true, + "reason": "correction source has nonzero entrance frame", + "expected_reason_match": true + }, + { + "control": "wrong claimed profile", + "rejected": true, + "reason": "paid profile mismatch {1: 2303, 2: 527, 3: 386, 4: 125, 5: 37, 8: 8}", + "expected_reason_match": true + }, + { + "control": "wrong claimed width inventory", + "rejected": true, + "reason": "width inventory mismatch {4: 4, 5: 4, 7: 36, 8: 84, 9: 272}", + "expected_reason_match": true + }, + { + "control": "frame chain not monotone", + "rejected": true, + "reason": "frame not monotone (641, (30,), ())", + "expected_reason_match": true + } + ], + "seconds": 26783.436781504 +} diff --git a/research/t74-low-alias-borrowing/receipts/CONTROLS-80extra.json b/research/t74-low-alias-borrowing/receipts/CONTROLS-80extra.json new file mode 100644 index 0000000000..e090679cf9 --- /dev/null +++ b/research/t74-low-alias-borrowing/receipts/CONTROLS-80extra.json @@ -0,0 +1,148 @@ +{ + "all_controls_rejected_for_expected_reason": true, + "controls": [ + { + "control": "unmutated", + "rejected": false, + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD" + }, + { + "control": "wrong G (invertible, G(from)!=to)", + "rejected": true, + "reason": "G(from)!=to", + "expected_reason_match": true + }, + { + "control": "non-invertible G", + "rejected": true, + "reason": "G not invertible", + "expected_reason_match": true + }, + { + "control": "non-invertible G (zero column)", + "rejected": true, + "reason": "G not invertible", + "expected_reason_match": true + }, + { + "control": "frame mismatch (from frame differs from current)", + "rejected": true, + "reason": "G(from)!=to", + "expected_reason_match": true + }, + { + "control": "frame mismatch (consistent G, from frame differs from lender current frame)", + "rejected": true, + "reason": "warp frame mismatch (1, 243, (261, 133, 85, 45), (260, 133, 85, 45))", + "expected_reason_match": true + }, + { + "control": "frame mismatch (warp moved to a position where the lender frame differs)", + "rejected": true, + "reason": "frame not monotone (243, (261, 133, 85, 45), (320, 192, 45, 30))", + "expected_reason_match": true + }, + { + "control": "missing inverse warp in cleanup", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "all inverse warps missing", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "algebra without inverse warps does not restore inputs", + "failed_inputs": 190, + "rejected": true + }, + { + "control": "dim(from)!=dim(to)", + "rejected": true, + "reason": "dim(from)!=dim(to)", + "expected_reason_match": true + }, + { + "control": "inverse warp not at FULL", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "cleanup uses real restored input instead of private buffer", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "restoration gate dropped (derived cleanup)", + "rejected": true, + "reason": "paid profile mismatch {1: 2287, 2: 533, 3: 386, 4: 126, 5: 37, 8: 8}", + "expected_reason_match": true + }, + { + "control": "false cold-restoration claim (register not restored)", + "rejected": true, + "reason": "frame not monotone (273, (257, 128, 64, 33, 16, 8, 4, 2), (1,))", + "expected_reason_match": true + }, + { + "control": "restoration gate dropped", + "rejected": true, + "reason": "explicit cleanup differs from derived inverse-reverse at FULL", + "expected_reason_match": true + }, + { + "control": "gate on removed helper", + "rejected": true, + "reason": "register out of range or removed helper referenced", + "expected_reason_match": true + }, + { + "control": "initial correction omitted", + "rejected": true, + "reason": "target map failed 2", + "expected_reason_match": true + }, + { + "control": "initial correction sign flipped", + "rejected": true, + "reason": "target map failed 2", + "expected_reason_match": true + }, + { + "control": "initial correction reads a non-lender", + "rejected": true, + "reason": "correction source is not the lender of its operator", + "expected_reason_match": true + }, + { + "control": "initial correction reads an entering helper", + "rejected": true, + "reason": "correction source has nonzero entrance frame", + "expected_reason_match": true + }, + { + "control": "wrong claimed profile", + "rejected": true, + "reason": "paid profile mismatch {1: 2287, 2: 535, 3: 386, 4: 125, 5: 37, 8: 8}", + "expected_reason_match": true + }, + { + "control": "wrong claimed width inventory", + "rejected": true, + "reason": "width inventory mismatch {4: 4, 5: 4, 7: 36, 8: 84, 9: 272}", + "expected_reason_match": true + }, + { + "control": "frame chain not monotone", + "rejected": true, + "reason": "frame not monotone (641, (30,), ())", + "expected_reason_match": true + } + ], + "seconds": 26806.408921092 +} diff --git a/research/t74-low-alias-borrowing/replay_core.py b/research/t74-low-alias-borrowing/replay_core.py new file mode 100644 index 0000000000..fc6a894f01 --- /dev/null +++ b/research/t74-low-alias-borrowing/replay_core.py @@ -0,0 +1,344 @@ +#!/usr/bin/env python3 +"""Exact free-operator replay of an anticipatory dirty-borrowing witness (function form). + +This is the replay of PR2226 "anticipatory dirty borrowing" (Cinna Davis, @1337isnot1337, +with OpenAI Codex assistance; research/anticipatory-dirty-borrowing/replay.py, Apache-2.0), +as vendored byte-identically by PR2269 (Jeremy Kothe, research/gmx-t74-borrow43/new/code/ +borrow/vendor/pr2226_replay.py). The semantics are unchanged. The only differences are: + + * it is a function returning a dict instead of a CLI writing a file; + * the PR2226-specific assertion ``len(pairs)==80 and sum(low)==32`` is replaced by + caller-supplied expected counts (PR2269's T74 witnesses carry 43 pairs); + * when ``diagnose=True`` the Y-row residuals (actual minus Y+X) are returned instead of + raising, so that a construction script can read off the late target response of a + nominated alias. The verification mode (``diagnose=False``) raises exactly as PR2226. + +Every low-pair condition of PR2226 is enforced verbatim: + - initial corrections: target in Y, source active, not in Y, source entrance frame of + dimension zero, operator words in range, dyadic coefficient; + - low lender is exactly its restored initial input at the handoff; + - retirement_B_event < handoff_B; handoff_paid_rank equals the frame-dimension gap; + - deleted prefix indices / early prefix rewrites are applied only for low pairs; + - every climb is nested (frame chronology), Y'=Y+X over the free operator algebra, + full inverse cleanup with private zero buffers restores every non-target input, and the + omitted-inverse-warp negative control must fail. + +Adaptation prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0. +Credits: PR2226 (Cinna Davis), PR2269 (Jeremy Kothe), PR2260 (Dugongue). +""" +from collections import Counter +from fractions import Fraction as Q + + +def span(basis): + s = {0} + for x in basis: + s |= {t ^ x for t in s.copy()} + return frozenset(s) + + +def incident(e): + return e[1:3] if e[0] == 'add' else e[1:2] + + +def add(dst, src, c): + for key, value in list(src.items()): + z = dst.get(key, Q(0)) + c * value + if z: + dst[key] = z + elif key in dst: + del dst[key] + + +def warp(row, op): + out = {} + for (var, word), value in row.items(): + word = word[1:] if word and word[0] == -op else (op,) + word + out[var, word] = value + return out + + +def frame_basis(F): + b = {} + for x in F: + while x: + j = x.bit_length() + if j not in b: + b[j] = x + break + x ^= b[j] + return [b[j] for j in sorted(b, reverse=True)] + + +class ReplayError(ValueError): + pass + + +def replay(w, blocks, inv, *, recover_cold=True, diagnose=False, expect_pairs=None, + expect_low=None, stop_after_B=False, trace_handoff=None, probe=None): + pairs = inv['pairs'] + if expect_pairs is not None: + assert len(pairs) == expect_pairs, (len(pairs), expect_pairs) + if expect_low is not None: + assert sum(x['low'] for x in pairs) == expect_low + v = w['v']; n = 2 * v + w['R']; full = span([1 << i for i in range(w['h'])]) + frames = list(map(span, w['frames'])) + removed = {x['register'] for x in pairs} + assert len(removed) == len(pairs), 'duplicate removed register' + active = [r for r in range(n) if r not in removed] + val = {r: {(r, ()): Q(1)} for r in active} + cur = {r: frames[w['start'][r]] for r in active} + anticipation = inv['initial_corrections'] + for term in anticipation: + target = term['target']; source = term['source']; word = tuple(term['operator_word']) + coefficient = Q(term['coefficient']) + assert v <= target < 2 * v and source in active and not (v <= source < 2 * v) + assert len(w['frames'][w['start'][source]]) == 0 + assert all(1 <= abs(op) <= len(pairs) for op in word) + assert coefficient.denominator & (coefficient.denominator - 1) == 0 + add(val[target], {(source, word): Q(1)}, coefficient) + mapping = {}; profile = Counter(); reverse = []; warps = [] + lender_check = [] + + def resolve(r): + return mapping.get(r, r) + + def climb(r, f): + if not cur[r] <= f: + raise ReplayError(('nonnested climb', r, len(cur[r]), len(f))) + d = (len(f).bit_length() - 1) - (len(cur[r]).bit_length() - 1) + if d: + profile[d] += 1 + cur[r] = f + + def scalar(e, framed=True, record=True): + rs = [resolve(r) for r in incident(e)] + if any(r not in val for r in rs): + raise ReplayError(('unallocated borrowed field', e)) + if framed: + for r in rs: + climb(r, frames[e[-1]]) + if e[0] == 'add': + c = Q(e[3], e[4]); add(val[rs[0]], val[rs[1]], c) + if record and not (v <= rs[0] < 2 * v): + reverse.append(('add', rs[0], rs[1], c)) + else: + c = Q(e[2], e[3]); val[rs[0]] = {k: c * x for k, x in val[rs[0]].items()} + if record and not (v <= rs[0] < 2 * v): + reverse.append(('scale', rs[0], c)) + + original_target_levels = {r: w['start'][r] for r in range(v, 2 * v)} + for e in w['precondition'] + w['compensation']: + for r in incident(e): + if v <= r < 2 * v: + original_target_levels[r] = e[-1] + if e[0] == 'add' and e[2] in removed: + continue + scalar(e, record=False) + for e in w['A']: + scalar(e) + for r, f in original_target_levels.items(): + climb(r, frames[f]) + for r, f in zip(w['centers'], w['center_frames']): + assert cur[r] == frames[f] + profile[len(w['frames'][f])] += 1 + for e in w['cut']: + scalar(e, framed=False, record=False) + deferred = {}; skip = set() + for b in blocks: + ss = set(b['helpers']); part = [] + for i in range(b['first_correction'], b['first_input']): + e = w['B'][i] + if set(incident(e)) <= ss: + part.append(e); skip.add(i) + deferred[b['first_input']] = part + starts = {} + for i, x in enumerate(pairs): + starts.setdefault(x.get('handoff_B', x['deadline']), []).append((i + 1, x)) + removed_early_echoes = {i for x in pairs if x['low'] + for i in x.get('deleted_prefix_indices', x['deleted_echo_indices'])} + early_rewrites = {} + for x in pairs: + if x['low']: + for i, gates in x.get('early_prefix_rewrites', {}).items(): + assert int(i) not in early_rewrites, ('two rewrites at one index', i) + early_rewrites[int(i)] = gates + early_tail = {} + for e in inv.get('early_tail_events', []): + early_tail.setdefault(e['before_B'], []).append(e['gate']) + for i, e in enumerate(w['B']): + for t in early_tail.get(i, []): + scalar(t) + if probe is not None and i in probe: + probe[i] = {'pristine': {r for r in active if val[r] == {(r, ()): Q(1)}}, + 'cur': {r: frame_basis(cur[r]) for r in active}} + if i in starts: + for op, x in starts[i]: + old = x['borrow_from']; new = x['register'] + assert x['retirement_B_event'] < i + if x['low']: + ok = val[old] == {(old, ()): Q(1)} + lender_check.append((op, old, ok)) + if not ok and not diagnose: + raise ReplayError(('low lender is not its restored initial input', op, old)) + if trace_handoff is not None: + trace_handoff.append((op, old, new, i, dict(val[old]), frame_basis(cur[old]))) + E_basis = x.get('handoff_basis', x['common_basis'][:x['retirement_dimension']]) + E = span(E_basis) + paid = abs(len(E_basis) - (len(cur[old]).bit_length() - 1)) + assert paid == x.get('handoff_paid_rank', 0), ('paid handoff', op, paid) + if paid: + profile[paid] += 1 + val[old] = warp(val[old], op); reverse.append(('warp', old, op)); cur[old] = E + mapping[new] = old + warps.append({'operator': op, 'borrow_from': old, 'removed': new, + 'from_basis': w['frames'][x['retirement_frame']] if 'retirement_frame' in x else None, + 'to_basis': E_basis, 'physical_handoff_rank': paid}) + assert not x.get('handoff_echo_coefficients') + for d in deferred.get(i, []): + scalar(d) + for d in early_rewrites.get(i, []): + scalar(d) + if i not in skip and i not in removed_early_echoes: + scalar(e) + for t in early_tail.get(len(w['B']), []): + scalar(t) + for r in range(v, 2 * v): + climb(r, frames[w['final'][r]]) + residual = {} + for r in range(v, 2 * v): + expected = {(r, ()): Q(1), (r - v, ()): Q(1)} + if val[r] != expected: + d = dict(val[r]); add(d, expected, Q(-1)); residual[r] = d + if residual and not diagnose: + raise ReplayError(('output map failed in exact free operator algebra', sorted(residual)[:12])) + if diagnose: + return {'residual': residual, 'lender_check': lender_check, 'profile': dict(profile), + 'val': val, 'cur': cur, 'active': active, 'mapping': mapping} + # ---- cold restoration + full inverse cleanup (verbatim PR2226 semantics) ---- + cold = [r for r in active if not (v <= r < 2 * v) and len(w['frames'][w['final'][r]]) < w['h']] + prime = 65521; modular_cache = {}; cold_clearable = [] + for c in cold: + V = frames[w['final'][c]] + pool = tuple(r for r in active if not (v <= r < 2 * v) and cur[r] <= V <= frames[w['final'][r]]) + if pool not in modular_cache: + piv = {} + for r in pool: + x = {k: (q.numerator * pow(q.denominator, -1, prime)) % prime for k, q in val[r].items()} + while x: + j = min(x) + if j not in piv: + z = pow(x[j], -1, prime); piv[j] = {k: t * z % prime for k, t in x.items()}; break + z = x[j] + for k, t in piv[j].items(): + y = (x.get(k, 0) - z * t) % prime + if y: + x[k] = y + elif k in x: + del x[k] + modular_cache[pool] = piv + x = {(c, ()): 1}; piv = modular_cache[pool] + while x: + j = min(x) + if j not in piv: + break + z = x[j] + for k, t in piv[j].items(): + y = (x.get(k, 0) - z * t) % prime + if y: + x[k] = y + elif k in x: + del x[k] + if not x: + dependents = [r for r in active if not (v <= r < 2 * v) and any(var == c for var, word in val[r])] + if all(cur[r] <= V and all(not word for var, word in val[r] if var == c) for r in dependents): + cold_clearable.append(c) + restored = []; cold_witnesses = [] + + def exact_combination(pool, goal): + piv = {} + for r in pool: + x = dict(val[r]); code = {r: Q(1)} + while x: + j = min(x) + if j not in piv: + z = x[j]; piv[j] = ({k: t / z for k, t in x.items()}, {k: t / z for k, t in code.items()}); break + row, coeff = piv[j]; z = x[j]; add(x, row, -z); add(code, coeff, -z) + x = dict(goal); code = {} + while x: + j = min(x) + if j not in piv: + return None + row, coeff = piv[j]; z = x[j]; add(x, row, -z); add(code, coeff, z) + return code + + def dyadic(q): + return q.denominator & (q.denominator - 1) == 0 + + def unit(q): + return q and dyadic(q) and abs(q.numerator) & (abs(q.numerator) - 1) == 0 + + def cleanup_add(d, s, c, V): + climb(d, V); climb(s, V); add(val[d], val[s], c); reverse.append(('add', d, s, c)) + + if recover_cold: + for c in sorted(cold_clearable, key=lambda r: (len(frames[w['final'][r]]), r)): + V = frames[w['final'][c]] + pool = [r for r in active if not (v <= r < 2 * v) and r not in restored and cur[r] <= V] + solution = exact_combination(pool, {(c, ()): Q(1)}) + if solution is None or not all(dyadic(z) for z in solution.values()): + continue + pivot = c if unit(solution.get(c, Q(0))) else next((r for r, z in solution.items() if unit(z)), None) + if pivot is None: + continue + for r in set(solution) | {c}: + climb(r, V) + factor = solution[pivot] + if factor != 1: + val[pivot] = {k: factor * z for k, z in val[pivot].items()}; reverse.append(('scale', pivot, factor)) + for r, z in solution.items(): + if r != pivot: + cleanup_add(pivot, r, z, V) + if pivot != c: + val[c], val[pivot] = val[pivot], val[c]; reverse.append(('swap', c, pivot)) + assert val[c] == {(c, ()): Q(1)} + for r in active: + if v <= r < 2 * v or r == c: + continue + assert all(not word for var, word in val[r] if var == c) + z = val[r].get((c, ()), Q(0)) + if z: + cleanup_add(r, c, -z, V) + assert all(not any(var == c for var, word in val[r]) for r in active if not (v <= r < 2 * v) and r != c) + restored.append(c) + cold_witnesses.append({'register': c, 'frame': w['final'][c], + 'preparation': {str(r): str(z) for r, z in solution.items()}}) + for r in active: + if not (v <= r < 2 * v) and r not in restored: + climb(r, full) + work = {r: ({} if r in restored else dict(row)) for r, row in val.items()} + negative = {r: dict(work[r]) for r in active if not (v <= r < 2 * v)} + for e in reversed(reverse): + if e[0] == 'add': + _, d, s, c = e; add(work[d], work[s], -c); add(negative[d], negative[s], -c) + elif e[0] == 'scale': + _, d, c = e; work[d] = {k: x / c for k, x in work[d].items()} + negative[d] = {k: x / c for k, x in negative[d].items()} + elif e[0] == 'swap': + _, d, s = e; work[d], work[s] = work[s], work[d]; negative[d], negative[s] = negative[s], negative[d] + else: + _, d, op = e; work[d] = warp(work[d], -op) + for r in active: + if not (v <= r < 2 * v) and work[r] != ({} if r in restored else {(r, ()): Q(1)}): + raise ReplayError(('cleanup failed', r)) + rejected = [r for r, row in negative.items() if row != ({} if r in restored else {(r, ()): Q(1)})] + if warps and not rejected: + raise ReplayError('missing inverse warp negative control did not fail') + mass = sum(r * c for r, c in profile.items()) + return {'status': 'PASS_EXACT_FREE_OPERATOR_BORROWING_REPLAY', 'original_registers': n, + 'remaining_registers': len(active), 'removed_helper_registers': len(removed), + 'independent_input_columns': len(active), 'symbolic_warps': warps, 'target_map': 'Y+=X', + 'omitted_inverse_warps_rejected_registers': len(rejected), + 'zero_FULL_cleanup_buffers': len(restored), 'exact_cold_restoration': cold_witnesses, + 'lender_check': lender_check, + 'local_profile': dict(sorted(profile.items())), 'local_mass': mass} diff --git a/research/t74-low-alias-borrowing/run_all.py b/research/t74-low-alias-borrowing/run_all.py new file mode 100644 index 0000000000..6e8cfbe4cc --- /dev/null +++ b/research/t74-low-alias-borrowing/run_all.py @@ -0,0 +1,258 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Run the independent word check and the model pricing of the extended T74 borrow words; print one PASS line. + +Steps (each child runs as `python3 -I -B`, and its last stdout line must be its PASS line): + 0. (optional, --build) build_ext.py --controls, the construction with its own oracle, PR2269's auditor and + PR2226 Gaussian products. Needs numpy on PYTHONPATH (--numpy-site DIR). The pinned words/ and witness/ + files must come out byte-identical (determinism); otherwise the run fails. + 1. check_ext.py --out: independent check of BORROW-WORD-80{base,extra} (no PR or construction code). + 2. price_ext.py sources, price_ext.py controls: the pricing harness re-reads its PR constants from git and + runs its positive/negative controls. + 3. price-input-ext80.json is written from the profiles RECOUNTED by check_ext.py (not from the word reports), + then priced: price_ext.py price price-input-ext80.json --digits 40 --conservative --out + price_ext.ext80.receipt.json. Models F (favourable), C (calibrated on PR2269's realized refill), + C8 (calibrated on the T8 PR2260 refill) and P (pessimistic). These are MODEL prices of an idle refill + that has NOT been constructed: not a supplier, not a kappa claim. + 4. Cross-checks here: the priced local profiles equal the recount; every model's composed global profile + 249 P_gauge44 + 417 P_extra + idle has mass m W - D = 4816512; a plain float bisection of + mu(a) = sum_r n_r (r/m)^(1-a) / W = 1 agrees with each certified b to 1e-12. + 5. Runner negative controls: a price input whose width sum breaks mass = 1856 + widths, and a check_ext + receipt whose recount differs from the priced profile, must both be rejected. + +Credit: PR2226 (Cinna Davis / @1337isnot1337, with OpenAI Codex) anticipatory dirty borrowing; PR2269 +(Jeremy Kothe / jeremykothe2) T74 borrow43 words, fill and b; PR2260 (Dugongue) T8 44-high supplier and fill; +PR2312 reference claim only. Prepared with substantial AI assistance (Claude Code, Anthropic); Apache-2.0. + +Usage: python3 -I -B run_all.py [--out] [--build --numpy-site DIR] +Final line: PASS_T74_LOW_ALIAS_RUN_ALL ... or FAIL_T74_LOW_ALIAS_RUN_ALL ... +""" + +import sys + +if sys.flags.optimize: + sys.stdout.write('refusing to run under python -O\nFAIL_T74_LOW_ALIAS_RUN_ALL\n') + sys.exit(2) + +import argparse +import hashlib +import json +import math +import os +import subprocess +import tempfile +import time + +HERE = os.path.dirname(os.path.abspath(__file__)) +PASS_LINE = 'PASS_T74_LOW_ALIAS_RUN_ALL' +FAIL_LINE = 'FAIL_T74_LOW_ALIAS_RUN_ALL' +PRICE_INPUT = 'price-input-ext80.json' +PRICE_RECEIPT = 'price_ext.ext80.receipt.json' +CHECK_RECEIPT = 'check_ext.receipt.json' +PINNED_OUTPUTS = { # same pins as check_ext.LOCAL_PINS (sha256) + 'words/BORROW-WORD-80base.json.gz': '61290abffd8c8225e0abb3958c1506674e256de688fc4cdf358bbe7c981df493', + 'words/BORROW-WORD-80extra.json.gz': '1dd2d6f2ae5b5a27b5f89fb830203f0cca7a78d0323a7845e85e1e80f8f6d1a5', + 'witness/witness_80_base.json': '9380f74c032b0616d5b13e8ef94b6d9f80cac36239e329357e7d5fcab5283ad0', + 'witness/witness_80_extra.json': '6737072dcca47c6e6526bd62a41585dd09026549550c9e62eb53e64b265a6709', +} +T74 = dict(m=73, W=66304, D=23680, calls={'gauge44': 249, 'extra': 417}) + + +def run(argv, env=None, timeout=1800): + t0 = time.time() + got = subprocess.run([sys.executable, '-I', '-B'] + argv, cwd=HERE, capture_output=True, text=True, + env=env, timeout=timeout) + lines = got.stdout.strip().splitlines() + return got.returncode, lines, got.stderr, round(time.time() - t0, 1) + + +def sha(path): + with open(os.path.join(HERE, path), 'rb') as fh: + return hashlib.sha256(fh.read()).hexdigest() + + +def step(name, argv, token, failures, log, env=None): + rc, lines, err, dt = run(argv, env=env) + last = lines[-1] if lines else '' + ok = rc == 0 and last.startswith(token) + log[name] = dict(argv=argv, rc=rc, last_line=last, seconds=dt) + print('[%s] %s (rc=%d, %.1f s): %s' % (name, 'PASS' if ok else 'FAIL', rc, dt, last), flush=True) + if not ok: + failures.append('%s:%d:%s' % (name, rc, last[:80])) + for ln in (lines[-15:] + err.strip().splitlines()[-10:]): + print(' | ' + ln) + return ok, lines + + +def float_root(H, m, W): + """Plain float bisection of mu(a) = sum n_r (r/m)^(1-a) / W = 1 (cross-check only, not certified).""" + mu = lambda a: sum(n * math.exp((1 - a) * math.log(r / m)) for r, n in H.items()) / W + lo, hi = 0.0, 0.01 + assert mu(lo) < 1 < mu(hi) + for _ in range(200): + mid = (lo + hi) / 2 + if mu(mid) < 1: + lo = mid + else: + hi = mid + return lo + + +def crosscheck(pr, recount): + """Priced profiles == recount; composed global mass == m W - D; float root == certified b (1e-12).""" + out, bad = [], [] + if pr['local_profiles'] != dict((p, recount[p]['profile']) for p in ('gauge44', 'extra')): + bad.append('crosscheck:priced profiles != recount') + total = T74['m'] * T74['W'] - T74['D'] + for row in pr['models']: + H = {} + for p, c in T74['calls'].items(): + for r, n in recount[p]['profile'].items(): + H[int(r)] = H.get(int(r), 0) + c * n + for r, n in row['idle'].items(): + H[int(r)] = H.get(int(r), 0) + n + mass = sum(r * n for r, n in H.items()) + froot = float_root(H, T74['m'], T74['W']) + good = mass == total and abs(froot - float(row['b'])) < 1e-12 + out.append(dict(model=row['model'], b=row['b'], b_conservative=row.get('b_conservative'), + gain_vs_pr2269=row['gain_vs_pr2269'], gain_vs_pr2269_pct=row['gain_vs_pr2269_pct'], + gain_vs_pr2312=row['gain_vs_pr2312'], gain_vs_pr2312_pct=row['gain_vs_pr2312_pct'], + idle=row['idle'], global_mass=mass, float_root=repr(froot), crosscheck_ok=good, + bit_bound=row['bit_bound'])) + if not good: + bad.append('crosscheck:%s mass=%d float=%r' % (row['model'], mass, froot)) + return out, bad + + +FETCH_URL = 'https://github.com/CrocSwap/integer-mult-bounds' +FETCH_PRS = {2269: 'b479fc5567bc09ab9185bffe89b62594f36d74e5', 2226: 'dacaf3d81f1936bb55b8454b1244e5d014272754', + 2260: 'fde6b107e26a14da5bac5b66913c914708ea6901'} + + +def fetch_missing(): + repo = os.path.dirname(os.path.dirname(HERE)) + for pr, commit in sorted(FETCH_PRS.items()): + have = subprocess.run(['git', '-C', repo, 'cat-file', '-t', commit], capture_output=True, text=True) + if have.returncode == 0 and have.stdout.strip() == 'commit': + continue + print('fetching refs/pull/%d/head (commit %s absent)' % (pr, commit[:8]), flush=True) + got = subprocess.run(['git', '-C', repo, 'fetch', '--no-tags', '--quiet', FETCH_URL, 'refs/pull/%d/head' % pr], + capture_output=True, text=True) + if got.returncode != 0: + print('fetch of #%d failed: %s' % (pr, got.stderr.strip())) + + +def main(): + ap = argparse.ArgumentParser(description='Run check_ext.py and the model pricing; print one PASS line') + ap.add_argument('--out', action='store_true', help='write run_all.receipt.json next to this script') + ap.add_argument('--build', action='store_true', help='first re-run build_ext.py --controls (needs numpy)') + ap.add_argument('--numpy-site', default=None, help='directory to put on PYTHONPATH for build_ext.py') + ap.add_argument('--fetch', action='store_true', + help='fetch refs/pull/{2269,2226,2260}/head from %s if their pinned commits are absent ' + '(every input blob is still verified against its pin)' % FETCH_URL) + args = ap.parse_args() + if args.fetch: + fetch_missing() + t0 = time.time() + failures, log = [], {} + summary = {} + try: + if args.build: + before = dict((p, sha(p)) for p in PINNED_OUTPUTS) + env = dict(os.environ) + if args.numpy_site: + env['PYTHONPATH'] = args.numpy_site + # build_ext.py imports replay_core/vendor modules from its own directory, so it is run without -I + t1 = time.time() + got = subprocess.run([sys.executable, '-B', 'build_ext.py', '--controls'], cwd=HERE, capture_output=True, + text=True, env=env, timeout=3600) + lines = got.stdout.strip().splitlines() + ok = got.returncode == 0 and any('PASS_T74_LOW_ALIAS_EXTENSION' in ln for ln in lines[-5:]) + after = dict((p, sha(p)) for p in PINNED_OUTPUTS) + same = after == before == PINNED_OUTPUTS + log['build'] = dict(rc=got.returncode, last_line=lines[-1] if lines else '', deterministic=same, + seconds=round(time.time() - t1, 1)) + print('[build] %s (rc=%d): outputs byte-identical to pins: %s' % ('PASS' if ok else 'FAIL', got.returncode, + same), flush=True) + if not (ok and same): + failures.append('build:%d:deterministic=%s' % (got.returncode, same)) + else: + mism = [p for p in PINNED_OUTPUTS if sha(p) != PINNED_OUTPUTS[p]] + if mism: + failures.append('pins:%s' % ','.join(mism)) + ok1, _ = step('check_ext', ['check_ext.py', '--out'], 'PASS_T74_LOW_ALIAS_WORDS_INDEPENDENT', failures, log) + ok2, _ = step('price_sources', ['price_ext.py', 'sources'], 'PASS_T74_EXT_PRICE_HARNESS', failures, log) + ok3, _ = step('price_controls', ['price_ext.py', 'controls'], 'PASS_T74_EXT_PRICE_HARNESS', failures, log) + if ok1: + with open(os.path.join(HERE, CHECK_RECEIPT)) as fh: + rec = json.load(fh) + recount = rec['recounted'] + spec = {'family': 'T74', + 'label': 'CONSTRUCTED BORROW-WORD-80{base,extra} (48 high + 32 low aliases); local profiles recounted ' + 'by check_ext.py; idle refill MODELLED (owner fill not rebuilt)', + 'providers': dict((p, dict(profile=recount[p]['profile'], helpers=recount[p]['helpers'], + helper_width_sum=recount[p]['helper_width_sum'])) for p in ('gauge44', 'extra'))} + with open(os.path.join(HERE, PRICE_INPUT), 'w') as fh: + json.dump(spec, fh, indent=1, sort_keys=True) + fh.write('\n') + ok4, lines = step('price_ext80', ['price_ext.py', 'price', PRICE_INPUT, '--digits', '40', '--conservative', + '--out', PRICE_RECEIPT], + 'PASS_T74_EXT_PRICE_HARNESS', failures, log) + if ok4: + for ln in lines: + if ln.startswith(' ') and ('b_40' in ln or 'idle mass' in ln or 'x249' in ln or 'x417' in ln): + print(ln) + with open(os.path.join(HERE, PRICE_RECEIPT)) as fh: + pr = json.load(fh)['price'] + xc, bad_xc = crosscheck(pr, recount) + failures.extend(bad_xc) + summary = dict(extra_freed_mass=pr['extra_freed_mass'], idle_mass=pr['idle_mass'], models=xc) + print('[crosscheck] %s: priced profiles = recount; global mass = %d for every model; float roots agree ' + 'with certified b to 1e-12' % ('FAIL' if bad_xc else 'PASS', T74['m'] * T74['W'] - T74['D']), + flush=True) + # runner negative controls + nc = [] + with tempfile.TemporaryDirectory() as td: + bad = json.loads(json.dumps(spec)) + bad['providers']['extra']['helper_width_sum'] += 1 + path = os.path.join(td, 'bad.json') + with open(path, 'w') as fh: + json.dump(bad, fh) + rc, lines, _, _ = run(['price_ext.py', 'price', path, '--digits', '12']) + nc.append(dict(control='price input with helper_width_sum + 1 (breaks mass = 1856 + widths)', + rejected=rc != 0 and lines[-1].startswith('FAIL') and + any('local.identity' in ln for ln in lines))) + if ok4: + moved = json.loads(json.dumps(recount)) + moved['gauge44']['profile']['1'] -= 1 + moved['gauge44']['profile']['2'] += 1 + _, bad_xc = crosscheck(pr, moved) + nc.append(dict(control='crosscheck with a recount that moves one rank-1 child to rank 2', + rejected=bool(bad_xc), by=bad_xc[:2])) + for c in nc: + print('[runner control] %-80s %s' % (c['control'], 'REJECTED-OK' if c['rejected'] else 'NOT-OK')) + if not c['rejected']: + failures.append('runner_control:%s' % c['control'][:40]) + log['runner_controls'] = nc + except Exception as e: # noqa: BLE001 - report any runner error as a failure line + failures.append('runner:%s' % e) + elapsed = round(time.time() - t0, 1) + if failures: + line = '%s failures=%s' % (FAIL_LINE, ';'.join(failures)) + else: + models = ','.join('%s:%s' % (x['model'], x['b'][:14]) for x in summary['models']) + line = '%s check=PASS price=PASS crosscheck=PASS runner_controls=%d E=%d b_40[%s]' % ( + PASS_LINE, len(log['runner_controls']), summary['extra_freed_mass'], models) + if args.out: + with open(os.path.join(HERE, 'run_all.receipt.json'), 'w') as fh: + json.dump(dict(runner='run_all.py', python=sys.version.split()[0], steps=log, pricing=summary, + note='Model prices of a modelled idle refill; no owner fill was rebuilt; no kappa claim.', + elapsed_s=elapsed, result=line), fh, indent=1, sort_keys=True) + fh.write('\n') + print('elapsed %.1f s' % elapsed) + print(line) + return 0 if not failures else 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/research/t74-low-alias-borrowing/run_all.receipt.json b/research/t74-low-alias-borrowing/run_all.receipt.json new file mode 100644 index 0000000000..be6a0345bb --- /dev/null +++ b/research/t74-low-alias-borrowing/run_all.receipt.json @@ -0,0 +1,154 @@ +{ + "elapsed_s": 22.0, + "note": "Model prices of a modelled idle refill; no owner fill was rebuilt; no kappa claim.", + "pricing": { + "extra_freed_mass": 80586, + "idle_mass": 1310688, + "models": [ + { + "b": "0.0017255088890837212072813976419618582057", + "b_conservative": "0.0017255088861992047617724230796997597019", + "bit_bound": false, + "crosscheck_ok": true, + "float_root": "0.001725508889083682", + "gain_vs_pr2269": "2.9261750025246986511E-5", + "gain_vs_pr2269_pct": "+1.7251%", + "gain_vs_pr2312": "2.8617821842103207281E-5", + "gain_vs_pr2312_pct": "+1.6865%", + "global_mass": 4816512, + "idle": { + "1": 23976, + "3": 8673, + "42": 1, + "48": 26157, + "5": 813, + "7": 150 + }, + "model": "F" + }, + { + "b": "0.0017126737497248571464349222053077804286", + "b_conservative": "0.0017126737468384233802906688749666422316", + "bit_bound": false, + "crosscheck_ok": true, + "float_root": "0.0017126737497248912", + "gain_vs_pr2269": "1.6426610666382925665E-5", + "gain_vs_pr2269_pct": "+0.9684%", + "gain_vs_pr2312": "1.5782682483239146434E-5", + "gain_vs_pr2312_pct": "+0.9301%", + "global_mass": 4816512, + "idle": { + "1": 37980, + "3": 13730, + "48": 25488, + "5": 1287, + "7": 237 + }, + "model": "C" + }, + { + "b": "0.0017140567316684824711264204715713101470", + "b_conservative": "0.0017140567287903532610785433539703089262", + "bit_bound": false, + "crosscheck_ok": true, + "float_root": "0.0017140567316684117", + "gain_vs_pr2269": "1.7809592610008250356E-5", + "gain_vs_pr2269_pct": "+1.0499%", + "gain_vs_pr2312": "1.7165664426864471126E-5", + "gain_vs_pr2312_pct": "+1.0116%", + "global_mass": 4816512, + "idle": { + "1": 29065, + "3": 8673, + "39": 21, + "48": 25340, + "5": 5324, + "6": 55, + "7": 1645 + }, + "model": "C8" + }, + { + "b": "0.0016871233700042746562989725665814138063", + "b_conservative": "0.0016871233670879834795804369952323227555", + "bit_bound": false, + "crosscheck_ok": true, + "float_root": "0.001687123370004262", + "gain_vs_pr2269": "-9.1237690541995644706E-6", + "gain_vs_pr2269_pct": "-0.5379%", + "gain_vs_pr2312": "-9.7676972373433437010E-6", + "gain_vs_pr2312_pct": "-0.5756%", + "global_mass": 4816512, + "idle": { + "1": 104562, + "3": 8673, + "48": 24479, + "5": 813, + "7": 150 + }, + "model": "P" + } + ] + }, + "python": "3.14.4", + "result": "PASS_T74_LOW_ALIAS_RUN_ALL check=PASS price=PASS crosscheck=PASS runner_controls=2 E=80586 b_40[F:0.001725508889,C:0.001712673749,C8:0.001714056731,P:0.001687123370]", + "runner": "run_all.py", + "steps": { + "check_ext": { + "argv": [ + "check_ext.py", + "--out" + ], + "last_line": "PASS_T74_LOW_ALIAS_WORDS_INDEPENDENT", + "rc": 0, + "seconds": 15.8 + }, + "price_controls": { + "argv": [ + "price_ext.py", + "controls" + ], + "last_line": "PASS_T74_EXT_PRICE_HARNESS", + "rc": 0, + "seconds": 4.1 + }, + "price_ext80": { + "argv": [ + "price_ext.py", + "price", + "price-input-ext80.json", + "--digits", + "40", + "--conservative", + "--out", + "price_ext.ext80.receipt.json" + ], + "last_line": "PASS_T74_EXT_PRICE_HARNESS", + "rc": 0, + "seconds": 1.6 + }, + "price_sources": { + "argv": [ + "price_ext.py", + "sources" + ], + "last_line": "PASS_T74_EXT_PRICE_HARNESS", + "rc": 0, + "seconds": 0.4 + }, + "runner_controls": [ + { + "control": "price input with helper_width_sum + 1 (breaks mass = 1856 + widths)", + "rejected": true + }, + { + "by": [ + "crosscheck:priced profiles != recount", + "crosscheck:F mass=4816761 float=0.0017073314403578952" + ], + "control": "crosscheck with a recount that moves one rank-1 child to rank 2", + "rejected": true + } + ] + } +} diff --git a/research/t74-low-alias-borrowing/vendor/pr2226/NOTICE.md b/research/t74-low-alias-borrowing/vendor/pr2226/NOTICE.md new file mode 100644 index 0000000000..5ea70357a0 --- /dev/null +++ b/research/t74-low-alias-borrowing/vendor/pr2226/NOTICE.md @@ -0,0 +1,22 @@ +# Attribution and license + +New construction, proof text and checkers: Cinna Davis (@1337isnot1337), with +substantial OpenAI Codex assistance, Apache-2.0. + +The selected complex canonical word is the PR1042 ancestry retained in PR1094. +Jeremy Kothe, Rohan Arun, Hao Yan, Chafik Boukhalfa, icekylinx, Jonathan Capalbo +and the source package's full provider/frame/controller lineage retain credit. +Ali Romman supplied the source-bound fixed-block theorem and certificate; +Thomas DiFiore supplied the earlier block discovery. The borrowing construction +does not attribute its changed interface to those predecessor results. + +`price_engine.py` is an unchanged copy of the incorporated +`research/complex-local-word-ceiling/ceiling.py`: Douglas Colkitt, with Claude +(Anthropic) assistance; original SPDX/license context and docstring retained. +General Clifford frame and exact Gaussian normal forms are inherited from +`notes/general-clifford-frames.tex` and the repository's credited phase/compiler +lineage. The package independently checks its actual local Gaussian products. + +Source hashes, base commits and the copied engine's Git blob are in SOURCES.json. +No full native supplier, all-size compiler, precision theorem or new kappa is +claimed. No independent human review is claimed. diff --git a/research/t74-low-alias-borrowing/vendor/pr2226/operators.py b/research/t74-low-alias-borrowing/vendor/pr2226/operators.py new file mode 100644 index 0000000000..5c4fbe8cce --- /dev/null +++ b/research/t74-low-alias-borrowing/vendor/pr2226/operators.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python3 +"""Exact Gaussian-integer checks of every nominated rank-zero handoff. + +Each complete512-column operator is evaluated with a shared power-of-two +denominator. No floating approximation or binary-frame equality is substituted +for the actual Gaussian operator product. +""" +import argparse,hashlib,json +from pathlib import Path +import numpy as np + + +def linear(cols,x): + out=0 + for i,c in enumerate(cols): + if x>>i&1:out^=c + return out + + +def rank(xs): + b={} + for x in xs: + while x: + i=x.bit_length() + if i not in b:b[i]=x;break + x^=b[i] + return len(b) + + +def extend(xs,h): + out=list(xs) + for i in range(h): + if rank(out+[1<len(out):out.append(1<>i)&1)<>i&1)==(M[i]>>j&1) for i in range(h) for j in range(h)) + perm=np.array([linear(cols,x) for x in range(1<>i)&1)*(x>>i&1) for i in range(h))+ + 2*sum(((M[j]>>i)&1)*(x>>i&1)*(x>>j&1) for i in range(h) for j in range(i+1,h)) + for x in perm],dtype=np.int64)%4 + return perm,phase + + +def apply_mono(z,recipe,sign=1): + re,im,exp=z;perm,phase=recipe;rr=np.empty_like(re);ii=np.empty_like(im) + if sign==1: + for p in range(4): + mask=phase==p;r=re[mask];i=im[mask] + if p==0:a,b=r,i + elif p==1:a,b=-i,r + elif p==2:a,b=-r,-i + else:a,b=i,-r + rr[perm[mask]]=a;ii[perm[mask]]=b + else: + r=re[perm];i=im[perm] + for p in range(4): + mask=phase==p + if p==0:a,b=r[mask],i[mask] + elif p==1:a,b=i[mask],-r[mask] + elif p==2:a,b=-r[mask],-i[mask] + else:a,b=-i[mask],r[mask] + rr[mask]=a;ii[mask]=b + return rr,ii,exp + + +def coord(z,axes,sign=1): + re,im,exp=z + for j in axes: + p=np.array([x for x in range(len(re)) if not(x>>j&1)]);q=p^(1< + explicit chronological word with warps, cold restoration and inverse cleanup). +- `audit_local.py`: independent exact scalar/frame/free-algebra auditor (header credits icekylinx + with OpenAI GPT-6 Astra assistance for the base auditor; BORROW-WORD extension by PR2269). +- `borrow_controls.py`: negative controls for the auditor. + +The mechanism they implement is PR2226 anticipatory dirty borrowing (Cinna Davis, @1337isnot1337, +with OpenAI Codex assistance). Unmodified; git blob ids are pinned in ../../SOURCES-PR.json. diff --git a/research/t74-low-alias-borrowing/vendor/pr2269/audit_local.py b/research/t74-low-alias-borrowing/vendor/pr2269/audit_local.py new file mode 100644 index 0000000000..a90b00e023 --- /dev/null +++ b/research/t74-low-alias-borrowing/vendor/pr2269/audit_local.py @@ -0,0 +1,483 @@ +"""Independent exact scalar/frame audit of the changed forward supplier. + +This does not import a generator, builder, stored compensation, or price. +All claimed endpoint matrices are derived from the input word's gates. +Optional --main checks the transported boundary against the pinned parent. +Prepared for icekylinx with OpenAI GPT-6 Astra assistance. Apache-2.0. +""" +import argparse,gzip,json,hashlib,time +from pathlib import Path +from fractions import Fraction as F +from collections import Counter + +def require(x,label): + if not x:raise RuntimeError(label) + +def basis(vs): + piv={} + for a in vs: + while a: + bit=a.bit_length()-1 + if bit in piv:a^=piv[bit] + else: + piv[bit]=a;break + for k in sorted(piv): + for j in piv: + if j>k and piv[j]>>k&1:piv[j]^=piv[k] + return tuple(piv[k] for k in sorted(piv,reverse=True)) + +def contained(a,b):return basis(a+b)==b + +def registers(e):return e[1:3] if e[0]=='add' else e[1:2] + +def apply(e,rows,dual=False): + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + dst=rows[t] + for k,x in list(rows[s].items()): + a=dst.get(k,F(0))+q*x + if a:dst[k]=a + else:dst.pop(k,None) + elif e[0]=='scale': + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + else:raise RuntimeError('unknown scalar primitive') + +def invert(e): + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def check_parent_interface(word,main): + # Read only the retained boundary data. No builder or local checker is imported. + relative="research/community-k492-audit/pr622/replay/baseline558/complex-global/base/split-centres/CANONICAL-WORD.json.gz" + path=main/relative;raw=path.read_bytes() + require(hashlib.sha256(raw).hexdigest()=="66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844",'parent canonical input pin') + parent=json.loads(gzip.decompress(raw)) + tau=lambda x:x^(43 if (x&43).bit_count()%2 else 0) + ports=parent['ports'];v=word['report']['v'] + require(len(ports)==len(set(ports))==v,'parent port count') + require(set(map(tau,word['ports']))==set(ports),'transported source/target ports') + moved={i:ports.index(tau(p)) for i,p in enumerate(word['ports'])} + centers=[moved.get(r,r) for r in word['centers']] + actual=[list(basis([tau(x) for x in frame])) for frame in word['center_frames']] + expected=[parent['frames'][f] for f in parent['center_frames']] + require(len(centers)==len(set(centers))==len(actual)==8,'eight distinct centre carriers') + require(actual==expected and all(len(f)==8 for f in actual),'ordered centre frame interface') + return dict(parent_path=relative,parent_file_sha256=hashlib.sha256(raw).hexdigest(), + transport_tau=43,ordered_frame_bases_match=True,all_ports_match=True, + transported_centers=centers,source_centers=[r for r in centers if r=2*v} + for e in w['precondition']:apply(e,dirt) + compensation=[['add',y,k,-a.numerator,a.denominator,[]] for y in range(v,2*v) for k,a in sorted(dirt[y].items())] + entering=set(map(int,w.get('start_extra',{})));lowends=set(map(int,w.get('helper_final',{}))) + coldends=lowends-entering + require(not any(e[2] in entering for e in compensation),'nonzero entrance response') + require(not any(r in entering|coldends for e in w['precondition']+compensation for r in registers(e)), 'pre-wrapper touch of residual helper') + require(all(e[-1]==[] for e in w['precondition']+compensation),'nonzero frame precondition') + early=w.get('early_cleanup',[]);earlyids={i for i,U in early} + require(len(earlyids)==len(early),'duplicate early cleanup gate') + tail=[w['cleanup'][i][:-1]+[U] for i,U in early] + cleanup=[e for i,e in enumerate(w['cleanup']) if i not in earlyids] + prefix=w['precondition']+compensation+main + program=prefix+tail+cleanup + for dual in (False,True): + actual=ident() + for e in program:apply(e,actual,dual) + expected=ident() + for t in range(v):expected[t if dual else v+t][v+t if dual else t]=F(-1 if dual else 1) + bad=[i for i in range(n) if actual[i]!=expected[i]] + require(not bad,'all-column endpoint failure '+str((dual,bad[:8]))) + print('endpoint', 'dual' if dual else 'forward','PASS',flush=True) + full=basis([1<>=1;i+=1 + return y + +def ginv(cols,h): + # inverse columns over F2 (None if singular), Gauss-Jordan on (G | I) column-wise + piv={}; + for i in range(h): + a=cols[i];b=1<>s&1:a^=piv[s][0];b^=piv[s][1] + if a:return None + pre.append(b) + return pre # pre[t] = G^{-1}(e_t) + +def gtrans(cols,h): + # transpose: column j of G^T = row j of G + return [sum(((cols[i]>>j)&1)<(Gx, (G+G^-T)x + G^-T z) + GiT=gtrans(inv,h) # G^{-T}: columns j = row j of G^{-1} + # G^{-T}(z): via columns GiT + def M(vec): + x=vec&((1<>h + gx=gmul(cols,x);S=gx^gmul(GiT,x) # (G + G^{-T}) x + return gx|((S^gmul(GiT,z))<>h)|((vec&((1<0)-(op<0))*(abs(op)+dsym)) + walg_add(rows[src],row,-c) + return + if e[0]=='warp': + op=e[2];s=(op>0)-(op<0) + if dual:op=s*(abs(op)+dsym) # dual orientation: K_G^{-T} is a distinct free symbol + rows[e[1]]=walg_warp(rows[e[1]],op);return + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + walg_add(rows[t],rows[s],q) + else: + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + +def invert_item(e,full): + if e[0]=='warp':return ['warp',e[1],-e[2]] + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def run_borrow(path,out,main,base,w,data,begin): + v,h,R=w['report']['v'],w['report']['h'],w['report']['R'];n=2*v+R + require((v,h)==(112,9),'wrong source geometry') + require(main is None,'--main parent interface is not available for coordinate-changed BORROW-WORD; use --base') + full=basis([1<=2*v,'correction source must be a remaining helper') + require(s not in entering,'correction source has nonzero entrance frame') + require(len(word)>=1 and all(1<=abs(o)<=K for o in word),'correction operator word') + require(c!=0 and c.denominator&(c.denominator-1)==0,'correction coefficient') + # the source is the lender of the operator it is read through + require(all(warps[abs(o)-1][1]==s for o in word),'correction source is not the lender of its operator') + # --- 4. frames: literal chain, monotone, paid profile --------------------------------------- + end=[full]*v+[basis([x for x in range(1,1<>i&1:Q[t]^=Ub[i] + G2=[al.gmul(G,Q[t]) for t in range(h)] + require(al.basis([al.gmul(G2,x) for x in W])==al.basis(r[4]) and al.ginv(G2,h) is not None,'control G consistent') + r[2]=G2;r[3]=W + good&=expect('frame mismatch (consistent G, from frame differs from lender current frame)',w,basep,tmp,'warp frame mismatch',results) + # frame mismatch with a consistent G: the warp is moved to a B position where the lender is in another frame + # (explicit cleanup removed so the derived cleanup follows the moved warp; the frame audit itself must fire) + found=False + for k in range(K): + r=w0['warps'][k];nxt=next((i for i in range(r[0],len(w0['B'])) if r[1] in al.registers(w0['B'][i])),None) + if nxt is None:continue + w=mut();w.pop('cleanup');w['warps'][k][0]=nxt+1 + try:run_word(w,basep,tmp) + except RuntimeError as e: + if 'warp frame mismatch' in str(e) or 'frame not monotone' in str(e):found=True;break + good&=found + good&=expect('frame mismatch (warp moved to a position where the lender frame differs)',w,basep,tmp,('warp frame mismatch','frame not monotone'),results) + # 4 missing inverse warp + w=mut();i=next(i for i,g in enumerate(w['cleanup']) if g[0]=='warp');del w['cleanup'][i] + good&=expect('missing inverse warp in cleanup',w,basep,tmp,'explicit cleanup differs',results) + w=mut();w['cleanup']=[g for g in w['cleanup'] if g[0]!='warp'];good&=expect('all inverse warps missing',w,basep,tmp,'explicit cleanup differs',results) + # 4b the algebra itself (not just the derivation comparison) rejects a cleanup without inverse warps + w=mut();n=2*w['report']['v']+w['report']['R'];v=w['report']['v'] + removed=set(w['removed']);live=[r for r in range(n) if r not in removed];restored={int(q) for q in w['helper_final']} + DS=10**6;rows={r:{(r,()):al.F(1)} for r in live} + for c in restored:rows[c+n]={} + program=[['corr',t['target'],t['source'],tuple(t['operator_word']),al.F(t['coefficient'])] for t in w['initial_corrections']]+w['precondition']+w['compensation']+w['A']+w['cut'] + byp={} + for op,rec in enumerate(w['warps'],1):byp.setdefault(rec[0],[]).append(op) + for p in range(len(w['B'])+1): + for op in byp.get(p,[]):program.append(['warp',w['warps'][op-1][1],op]) + if p=2*v if rows[r]!={(r,()):al.F(1)}] + results.append(dict(control='algebra without inverse warps does not restore inputs',failed_inputs=len(bad),rejected=bool(bad)));print('algebra-level missing inverse warp: failing restored inputs',len(bad)) + good&=bool(bad) + # 5 dimension mismatch + w=mut();w['warps'][5][4]=w['warps'][5][4][:-1];good&=expect('dim(from)!=dim(to)',w,basep,tmp,'dim(from)!=dim(to)',results) + # 6 inverse warp not at FULL + w=mut();i=next(i for i,g in enumerate(w['cleanup']) if g[0]=='warp');w['cleanup'][i][3]=w['cleanup'][i][3][:-1] + good&=expect('inverse warp not at FULL',w,basep,tmp,'explicit cleanup differs',results) + # 7 zero-buffer rule: cleanup touches the real restored register, not its buffer + w=mut();i=next(i for i,g in enumerate(w['cleanup']) if g[0]=='add' and g[1]>=n) + w['cleanup'][i][1]-=n;good&=expect('cleanup uses real restored input instead of private buffer',w,basep,tmp,'explicit cleanup differs',results) + w=mut();w.pop('cleanup');w['restore']=w['restore'][1:];good&=expect('restoration gate dropped (derived cleanup)',w,basep,tmp,('restored cold','cleanup did not restore','endpoint failure','target map','frame','paid profile mismatch'),results) + # restored real register not decoupled: its buffer is dropped from the restored set while cleanup still derived + w=mut();w.pop('cleanup');c0=next(iter(w['helper_final']));w['helper_final'].pop(c0);good&=expect('restored cold input demoted (needs FULL, was decoupled by FULL-less rows)',w,basep,tmp,('',),results) if False else True + # 8 restored claim without restoration + touched={r for g in w0['precondition']+w0['compensation'] for r in al.registers(g)} + w=mut();w.pop('cleanup');c=next(r for r in range(2*v,n) if r not in removed and str(r) not in w['helper_final'] and r not in touched) + w['helper_final'][str(c)]=[1] + good&=expect('false cold-restoration claim (register not restored)',w,basep,tmp,('restored cold','frame not monotone'),results) + # 9 dropped restoration gate + w=mut();w['restore']=w['restore'][1:];good&=expect('restoration gate dropped',w,basep,tmp,'explicit cleanup differs',results) + # 10 removed helper referenced / alias missing + w=mut();r=w['removed'][0];w['B'].append(['add',r,2*v+1,1,1,[]]);good&=expect('gate on removed helper',w,basep,tmp,'removed helper referenced',results) + # 11 initial corrections (only if present) + if w0['initial_corrections']: + w=mut();del w['initial_corrections'][0];good&=expect('initial correction omitted',w,basep,tmp,'target map failed',results) + w=mut();w['initial_corrections'][0]['coefficient']=str(-al.F(w['initial_corrections'][0]['coefficient']));good&=expect('initial correction sign flipped',w,basep,tmp,'target map failed',results) + w=mut();w['initial_corrections'][0]['source']=next(r for r in range(2*v,n) if r not in removed and r!=w['initial_corrections'][0]['source'] and str(r) not in w['start_extra']) + good&=expect('initial correction reads a non-lender',w,basep,tmp,'not the lender',results) + w=mut();s=w['initial_corrections'][0]['source'];w['start_extra'][str(s)]=[1] + good&=expect('initial correction reads an entering helper',w,basep,tmp,'nonzero entrance frame',results) + # 12 wrong profile claim + w=mut();w['report']['local_profile']['1']+=1;good&=expect('wrong claimed profile',w,basep,tmp,'paid profile mismatch',results) + w=mut();w['report']['width_inventory']['9']+=1;good&=expect('wrong claimed width inventory',w,basep,tmp,'width inventory mismatch',results) + # 13 non-monotone frame / frame cut below start: lender warped to a frame not above its current chain + w=mut();w['B'][100][-1]=[];good&=expect('frame chain not monotone',w,basep,tmp,'frame not monotone',results) + Path(outp).write_text(json.dumps(dict(all_controls_rejected_for_expected_reason=bool(good),controls=results,seconds=time.monotonic()-t),indent=1)+'\n') + print('ALL CONTROLS OK' if good else 'CONTROL FAILURE');return 0 if good else 1 +if __name__=='__main__':sys.exit(main(*sys.argv[1:])) diff --git a/research/t74-low-alias-borrowing/vendor/pr2269/build_word.py b/research/t74-low-alias-borrowing/vendor/pr2269/build_word.py new file mode 100644 index 0000000000..8684d54b31 --- /dev/null +++ b/research/t74-low-alias-borrowing/vendor/pr2269/build_word.py @@ -0,0 +1,39 @@ +import sys,json,gzip +from collections import Counter +sys.path.insert(0,'.') +from emit_word import * +def main(canon,blocksf,witf,out,base_name): + w=json.loads(gzip.decompress(Path(canon).read_bytes())) + blocks=json.loads(Path(blocksf).read_text())['sources'][0]['blocks'] + wit=json.loads(Path(witf).read_text()) + S=build(w,blocks,wit);S=finish(S) + word=assemble(S,base_name) + ops=[x[5] for x in sorted(S['warps'],key=lambda x:x[5])];assert ops==list(range(1,len(ops)+1)),ops + del word['warp_order'] + v=S['v'];n=S['n'];restored=set(S['restored']);full=frame_basis(S['full']) + # explicit cleanup: inverse-reverse at FULL + fw=[] + byp={} + for x in S['warps']:byp.setdefault(x[0],[]).append(x[5]) + for g in word['A']:fw.append(g) + for p in range(len(word['B'])+1): + for op in sorted(byp.get(p,[])):fw.append(['warp',S['warps'][[x[5] for x in S['warps']].index(op)][1],op]) + if p=du else fb;E=span(E_basis) + assert len(E_basis)==du,'paid handoff not supported' + assert x['handoff_basis']==E_basis or span(x['handoff_basis'])==E,(op,) + warps.append([len(B),old,gauss[op],frame_basis(cur[old]),E_basis,op]) + val[old]=warp(val[old],op);cur[old]=E;mapping[new]=old + for target,c in x.get('handoff_echo_coefficients',{}).items(): + target=int(target);climb(target,E);add(val[target],val[old],Q(c));raise NotImplementedError('echo') + for d in deferred.get(i,[]):scalar(d) + for d in early_rewrites.get(i,[]):scalar(d) + if i not in skip and i not in removed_early_echoes:scalar(e) + for t in early_tail.get(len(w['B']),[]):scalar(t) + for r in range(v,2*v):climb(r,frames[w['final'][r]]) + return dict(w=w,out=out,corr=corr,warps=warps,val=val,cur=cur,removed=removed,active=active,frames=frames, + full=full,target_levels=target_levels,n=n,v=v,h=h,mapping=mapping) + +def finish(S,cold_restore=True): + """cold restoration (rp.py semantics, exact modular nomination replaced by direct exact solve).""" + w=S['w'];v=S['v'];n=S['n'];h=S['h'];val=S['val'];cur=S['cur'];frames=S['frames'];full=S['full'];active=S['active'] + out=S['out'] + def dyadic(q):return q.denominator&(q.denominator-1)==0 + def unit(q):return q and dyadic(q) and abs(q.numerator)&(abs(q.numerator)-1)==0 + cold=[r for r in active if not(v<=r<2*v) and len(w['frames'][w['final'][r]])