diff --git a/research/rank7-skip-restore-optimum/.gitattributes b/research/rank7-skip-restore-optimum/.gitattributes new file mode 100644 index 0000000000..d6664a7226 --- /dev/null +++ b/research/rank7-skip-restore-optimum/.gitattributes @@ -0,0 +1,2 @@ +# Keep vendored, data, certificate and evidence bytes exact (the repository default normalizes text). +* -text diff --git a/research/rank7-skip-restore-optimum/CREDITS.md b/research/rank7-skip-restore-optimum/CREDITS.md new file mode 100644 index 0000000000..f7bc8131a8 --- /dev/null +++ b/research/rank7-skip-restore-optimum/CREDITS.md @@ -0,0 +1,27 @@ +# Credits + +- **PR #3042, dcharb78**: the six-skip words (both providers) and the carrier/pivot routing that removes six restore-phase + visits (63, 54, 40, 22 in R1_E42; 73, 5 in R2_E7); the pinned exports in `data/` and the declared edits used for the + erratum and the calibration. +- **PR #3015, Jeremy Kothe (jeremykothe2)**: R1 and the declared restore-edit stage that PR #3042 extends; with PR #2894 / + #2833 the frame accounting and inverse-reverse cleanup conventions this lineage prices with. +- **Nick Petalas**: PR #3054 (T740 packing with the six skips; its words are these words), PR #3057 (restore-frame optimum) + and PR #3065 (joint A/B/restore frame optimum, whose 743-variable / 210-component frame graph `verify.py` reproduces), + PR #3056 and PR #3060 (the `restore[175:179]` replacements used here as attainment controls), PR #3044 (R2 shared + covector), PR #3024 / #3030 (T740 cap). +- **PR #2979 and its lineage, Marius-Paul Dumitrean**: joint rank-7 end frames, the paired extractions at normals 42 and 7 + and the composed words that PR #3015 and PR #3042 edit; the r12 BORROW-WORD harness and the #1186 frame toolkit ported in + `frames_exact.py`. +- **icekylinx**: PR #2833's exact free-operator auditor, vendored unchanged and used both for the restore-entry rows + (`walg_apply`) and for every exactness control. +- **Mason Hale (PR #2917)** and **Jeremy Diviney (PR #2908)**: the paired-extraction words and two-sided certificates that the + restored helpers and their private buffers come from. +- **DreamingOfClouds / chafreaky (research/frame-domain-ceiling)**: the moment engines and GF(2) helpers behind the integer + weights. +- **Sagar Thakrar (PR #3053)** for the frame-reassignment handoff that PR #3057/#3065 answered, and **Gareth Davidson + (PR #1995 / #2013)** for the earlier fixed-word monotone-frame bounds. +- **New here (Marius-Paul Dumitrean, with substantial AI assistance from Claude Code)**: the restore-only optimum theorem and + its proof (auditor semantics with the appended-gate control, forced coordinates and caps, the dual-vector departure + lemma, carriers and lifts, the classification and accounting), the stdlib verifier and port, the PR #2979 calibration, + the PR #3042 erratum and the controls. Lane K of our r15 round found the bound and its censuses; this package re-derives + it with sound lemmas and pins lane K's code and receipts in `evidence/laneK/`. diff --git a/research/rank7-skip-restore-optimum/MANIFEST.json b/research/rank7-skip-restore-optimum/MANIFEST.json new file mode 100644 index 0000000000..6bfbdacadb --- /dev/null +++ b/research/rank7-skip-restore-optimum/MANIFEST.json @@ -0,0 +1,41 @@ +{ + ".gitattributes": "1d90e85a978fc13a34fe1b1656bb61c1e02fb4dbf3babc00ce421d7686fb6e94", + "CREDITS.md": "ba3e64853367d19003bb30b1f7ceecbdffafd5cb433c33321594d5fd8aec8ebe", + "NOTICE": "713634fb82cc419ed93d75b4bce1f7c5f9663fe941442db648758c047577075f", + "PINS.json": "5d7607c539fe2112bd922c582258d94ea71e9256a1af1d5f9693d7b4259217ea", + "README.md": "ad0d76b90e806072ffc7593a50824eba45cf98d86e62b26869903308995047df", + "SOURCES.json": "068a00369827958f1dc155202e63de8c85f69c89bda602854bd90044c5b0723c", + "TASK.json": "e15dc093f8b12be9a56e3a66d375cf5dae28b99fa81d78c16a4bfd7402d4cfb4", + "VERIFY.json": "616f5639c740c32468639aba6be717e85f6a85659b742a89b8948155203469d9", + "census.py": "c7fbb879e7ef2af727207f0be761ac198be73714bdbd967f7b9cc8ebb311058e", + "certificates/BOUND-3042-base.json": "10922a932f51dac4021ea8d6a09b47b3bf0b8e278b77824a79bcf842d4929ebf", + "certificates/BOUND-3042-extra.json": "e75d625fede24fbc712f37f9f11269a418ef643703efc2e253a6005fd226a4db", + "certificates/CALIBRATION-2979.json": "68be5cf24d945ad0c16c7a55ccc655b0ea3c3ffc92c1d6a312200260247f4619", + "certificates/CENSUS.json": "bc983ddeb96d8d3e239bc0f2d919a88539d2414650c195a70c80975bf878bb5c", + "certificates/CONTROLS.json": "b6e91b1c67e425f3255874579b038e3c8ebb7ac926dae7f0e87e63d3db8748b2", + "certificates/ERRATUM-3042.json": "e2ac9e3af74a77574d2ec8afb4a5c2c0197c048f59bad1d2b8b4b65c613e0dd6", + "certificates/RESULT.json": "feadd89cec8dbdb95fa36df8b1c24b5a062a889ffe8d905d06edf58b91d1842a", + "data/EDITS-3042.json": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "data/WORD-2979-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "data/WORD-2979-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "data/WORD-3042-base.json.gz": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e", + "data/WORD-3042-extra.json.gz": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35", + "evidence/laneK/AUDITOR-SEMANTICS.json": "a37ed5585bb6cb907e643a89c3f34d654712e7b70d79d786be313a9f1a960a5c", + "evidence/laneK/CROSSCHECK.json": "3f1b9eab7f55a6d7e4c61bf25be656cd92dfa801b093b7e099c057a86bf469fc", + "evidence/laneK/FULLAB-SUMMARY.json": "135bf24a943fbfae601aacdc30419707457f704dd78655a010f678fb7eb6df47", + "evidence/laneK/NEGATIVE-3042-base.json": "326ad05aa4f3b77a1cb45d669f21231aa69404b7d1f2cbba410e24e31c44abc9", + "evidence/laneK/NEGATIVE-3042-extra.json": "3555d9d59768ed727f4ec01db70a7bfb0e4acaf99b1875663f5dc57850df143b", + "evidence/laneK/bound.py": "6b1479b436c4f01bb32f771aa06af3d2260adee5dd5a5e2bf568b0192cee69d8", + "evidence/laneK/crosscheck_lanek.py": "6a60ea588244b70c2594b763d7d26d1af304ed06dd7968bc668af594c3ab5a92", + "evidence/laneK/lbforced.py": "bd81e3f4460f61ef81e15e76ab25be5f8a9d7b71bb7dcbbf7a87873ca5398341", + "evidence/tail-exchange/TAIL-EXCHANGE-3042-base.jsonl.gz": "7bfa6fee793b7c7732a21f9d24d6f67029d726b9e4bd646fd6e626ab58e5176d", + "evidence/tail-exchange/TAIL-EXCHANGE-3042-extra.jsonl.gz": "7bfa6fee793b7c7732a21f9d24d6f67029d726b9e4bd646fd6e626ab58e5176d", + "frames_exact.py": "69ce80fbe90e77ddc818260b96cebb3c533d8fbd42d111524f24ee84a3ad56bd", + "restore_bound.py": "538e4ea639c9791dc92bec42b284a497da071b5802890a46ff41cd8ffc431342", + "run_registered.py": "f9f244dfb63dd214bb15317de855549d8e34f80ed900feb38cf3edd979199ddb", + "vendor/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "vendor/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/gk_common.py": "e68d190fd436b2f3955decb590adb53344d5d4ea0a19d62d86df1e4b55ecd198", + "vendor/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "verify.py": "2530cea57620a12f3512d4c2e0915054f6a2194bc60de60789dbd3e386eda565" +} diff --git a/research/rank7-skip-restore-optimum/NOTICE b/research/rank7-skip-restore-optimum/NOTICE new file mode 100644 index 0000000000..27bda92353 --- /dev/null +++ b/research/rank7-skip-restore-optimum/NOTICE @@ -0,0 +1,16 @@ +research/rank7-skip-restore-optimum +Copyright 2026 Marius-Paul Dumitrean. Licensed under the Apache License, Version 2.0. +Marius-Paul Dumitrean, with substantial AI assistance (Claude Code). + +This package retains, byte-identical, Apache-2.0 files from: PR #3042 (dcharb78, head +84cc406ad91ec53fff329a11a445d7effe564a77, research/rank7-restore-carrier-skips): data/WORD-3042-base.json.gz and +data/WORD-3042-extra.json.gz (its edits/FINAL-WORD-*.json.gz, also retained by PR #3054, Nick Petalas) and +data/EDITS-3042.json (its edits/EDITS.json); PR #2979 (Marius-Paul Dumitrean, head be191346391661f4d35fc0d1508d0a6029572576, +research/rank7-joint-endframes): data/WORD-2979-base.json.gz and data/WORD-2979-extra.json.gz; PR #2833's independent +exact auditor (icekylinx attribution, research/gmx-t74-borrow43-handoff/new/borrow/audit_local.py): vendor/audit_local.py; +research/frame-domain-ceiling: vendor/moment.py and vendor/base_two_moment.py (engines/) and vendor/gk_common.py +(vendor/static44/gk/, DreamingOfClouds). frames_exact.py ports the BORROW-WORD frame model of our r12 harness and the exact +elimination of research/exact-frame-toolkit (PR #1186); restore_bound.py and census.py re-derive lane K's (r15) bound and +censuses; evidence/laneK/ and evidence/tail-exchange/ hold lane K's unchanged receipts and code. The restore blocks of +PR #3056 and PR #3060 (Nick Petalas) are restated literally in verify.py as attainment controls. All original notices of +the retained predecessor files remain in force. diff --git a/research/rank7-skip-restore-optimum/PINS.json b/research/rank7-skip-restore-optimum/PINS.json new file mode 100644 index 0000000000..791a66e116 --- /dev/null +++ b/research/rank7-skip-restore-optimum/PINS.json @@ -0,0 +1,28 @@ +{ + "certificates/BOUND-3042-base.json": "10922a932f51dac4021ea8d6a09b47b3bf0b8e278b77824a79bcf842d4929ebf", + "certificates/BOUND-3042-extra.json": "e75d625fede24fbc712f37f9f11269a418ef643703efc2e253a6005fd226a4db", + "certificates/CALIBRATION-2979.json": "68be5cf24d945ad0c16c7a55ccc655b0ea3c3ffc92c1d6a312200260247f4619", + "certificates/CENSUS.json": "bc983ddeb96d8d3e239bc0f2d919a88539d2414650c195a70c80975bf878bb5c", + "certificates/CONTROLS.json": "b6e91b1c67e425f3255874579b038e3c8ebb7ac926dae7f0e87e63d3db8748b2", + "certificates/ERRATUM-3042.json": "e2ac9e3af74a77574d2ec8afb4a5c2c0197c048f59bad1d2b8b4b65c613e0dd6", + "certificates/RESULT.json": "feadd89cec8dbdb95fa36df8b1c24b5a062a889ffe8d905d06edf58b91d1842a", + "data/EDITS-3042.json": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "data/WORD-2979-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "data/WORD-2979-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "data/WORD-3042-base.json.gz": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e", + "data/WORD-3042-extra.json.gz": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35", + "evidence/laneK/AUDITOR-SEMANTICS.json": "a37ed5585bb6cb907e643a89c3f34d654712e7b70d79d786be313a9f1a960a5c", + "evidence/laneK/CROSSCHECK.json": "3f1b9eab7f55a6d7e4c61bf25be656cd92dfa801b093b7e099c057a86bf469fc", + "evidence/laneK/FULLAB-SUMMARY.json": "135bf24a943fbfae601aacdc30419707457f704dd78655a010f678fb7eb6df47", + "evidence/laneK/NEGATIVE-3042-base.json": "326ad05aa4f3b77a1cb45d669f21231aa69404b7d1f2cbba410e24e31c44abc9", + "evidence/laneK/NEGATIVE-3042-extra.json": "3555d9d59768ed727f4ec01db70a7bfb0e4acaf99b1875663f5dc57850df143b", + "evidence/laneK/bound.py": "6b1479b436c4f01bb32f771aa06af3d2260adee5dd5a5e2bf568b0192cee69d8", + "evidence/laneK/crosscheck_lanek.py": "6a60ea588244b70c2594b763d7d26d1af304ed06dd7968bc668af594c3ab5a92", + "evidence/laneK/lbforced.py": "bd81e3f4460f61ef81e15e76ab25be5f8a9d7b71bb7dcbbf7a87873ca5398341", + "evidence/tail-exchange/TAIL-EXCHANGE-3042-base.jsonl.gz": "7bfa6fee793b7c7732a21f9d24d6f67029d726b9e4bd646fd6e626ab58e5176d", + "evidence/tail-exchange/TAIL-EXCHANGE-3042-extra.jsonl.gz": "7bfa6fee793b7c7732a21f9d24d6f67029d726b9e4bd646fd6e626ab58e5176d", + "vendor/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "vendor/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/gk_common.py": "e68d190fd436b2f3955decb590adb53344d5d4ea0a19d62d86df1e4b55ecd198", + "vendor/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" +} diff --git a/research/rank7-skip-restore-optimum/README.md b/research/rank7-skip-restore-optimum/README.md new file mode 100644 index 0000000000..bcb7dfb55c --- /dev/null +++ b/research/rank7-skip-restore-optimum/README.md @@ -0,0 +1,233 @@ +# Restore-only optimum for PR #3042's six-skip words: every exact restore costs at least 10,868,103,087 (no new κ) + +```text +Status / UTC update / priority revision: FINDING (scoped exact negative) · 2026-10-17 UTC · priority revision 6 · base main 18aacb21 +Concrete question and changed premise: PR #3042 (dcharb78) removed six restore-phase visits from PR #2979's words with two + declared restore edits; Nick Petalas's top claim PR #3054 uses the same six-skip words. PR #3057 and PR #3065 prove the + restore (and joint A/B/restore) FRAMES optimal for the fixed scalar order. Can a different restore gate sequence (more + carrier or pivot skips, any exact rewrite) lower the local frame bill when A/B, warps, cut, helper ends, start frames + and buffers stay fixed and all frames are re-solved? +Established result and evidence status: no. On both providers every exact restore-only rewrite costs at least + LB_forced + forced restore-phase visits = 10,867,765,164 + 337,923 = 10,868,103,087, the certified cost of PR #3042's + words, which attain it. The same bound on PR #2979's words leaves exactly dcharb78's realized 29,976. Author-checked + (AI-assisted), stdlib verifier; not maintainer-reviewed. Also corrects PR #3042's README attribution of the two edits. +Public artifact URL + exact commit: this package (see the PR). +Next useful task: A/B-phase re-synthesis (the 161,558 forced-cap units and the 192,384 kernel/preload visit units are + forced by A/B), or a changed target port interface; restore-only search on these words is exhausted. +Active claim / expiry: released. +``` + +## Result + +| word (both providers identical) | certified local cost | LB_forced (empty restore + 88 forced caps) | forced restore-phase visits | bound | gap | +|---|---:|---:|---:|---:|---:| +| PR #3042 six-skip words (`WORD-3042-{base,extra}`) | **10,868,103,087** | 10,867,765,164 | 337,923 | **10,868,103,087** | **0** | +| PR #2979 words (same A/B; calibration) | 10,868,133,063 | 10,867,765,164 | 337,923 | 10,868,103,087 | 29,976 | + +Costs are the certified frame solver's integer local costs in units of 2⁻⁴⁰ at the base saving b = 0.001703676387993676 +(c1 = 2,116,671, c2 = 4,228,346, c3 = 6,338,140, c4 = 8,446,713, c5 = 10,554,378). A visit that splits a climb of D ranks +into a + (D − a) costs c_a + c_{D−a} − c_D: 4,996 (1+1), 6,877 (1+2), 9,979 (2+2), 8,098 (1+3). The 51 visits of PR #3042's +literal frames are 20 × 4,996 + 23 × 6,877 + 8 × 9,979 = 337,923, and at profile level + +```text +{1:2433, 2:712, 3:232, 4:108, 5:18, 8:8} = LB_forced {1:2370, 2:693, 3:255, 4:116, 5:18, 8:8} + + 20 (2H1 - H2) + 23 (H1 + H2 - H3) + 8 (2H2 - H4). +``` + +The restore's total overhead over the unconstrained empty-restore optimum is 499,481 = 337,923 (forced visits) + 161,558 +(forced entry caps acting on A/B chains). Both parts are forced by A/B and by what the restored helpers must contain. + +## Theorem + +Let W be `WORD-3042-base` or `WORD-3042-extra` (PR #3042 head `84cc406a`, `edits/FINAL-WORD-*.json.gz`, byte-identical in +`data/`). A *restore-only rewrite* W′ keeps the initial corrections, precondition, compensation, A (with its prelude), cut, +warps, B, start frames, helper end frames, removed helpers and private buffers of W, and replaces the restore by any +finite sequence of scalar gates; all frames (A, B and restore) are re-solved. W′ is *exact* if PR #2833's auditor +(BORROW-WORD branch, `vendor/audit_local.py`, unchanged) passes forward and dual on W′ with its frames written back. The +proof uses only the auditor's forward end-of-restore requirements (Lemma 1), so the bound holds for every restore that +meets them. Then + +```text +cert(W') >= LB_forced(W) + 337,923 = 10,868,103,087 = cert(W), +``` + +where cert is the exact frame optimum of the BORROW-WORD frame model (monotone register chains, paid rank jumps, +fixed interfaces: start/end frames, cut equality, warp entry equality, fixed centre descents). The class contains every +restore-only edit considered so far on these words (carrier/pivot skips, R2-style shared covectors, the PR #3056 and +PR #3060 replacements of `restore[175:179]`, which tie) and, with R′ = R, the frame reassignments of PR #3057 and PR #3065 +(in this package's frame model). + +## Proof + +Write 𝓡 for the 91 restored helpers (end frames E_c, all below FULL), e_q for the restore-entry rows of the 632 live +registers in the auditor's free algebra, and F_r for register r's frame at its last vertex before the restore. L_r and +U_r are the solver's forward lower bound and the upper bound from r's other registers at that vertex, computed in the +capped empty-restore graph; they hold for every restore-only rewrite because A/B are unchanged. + +1. **Auditor semantics.** After the restore the auditor requires, in its forward replay, every restored helper c to hold + exactly its own input row x_c (`vendor/audit_local.py` line 444), no other live register to contain the variable c + (line 445) and the target map (line 442); the restore may not write a target (line 340), a non-target may not read a + target (line 335), and the restore holds no warps (line 323). These are the only facts the bound uses. They do not + constrain the other final rows, and the derived inverse-reverse cleanup inverts them. Control: appending `0 += 1` or + `62 += 70` at FULL to the restore changes two non-restored final rows; with frames re-solved the auditor passes forward + and dual at cost delta 0, while appending `249 += 251` fails (`certificates/CONTROLS.json`). Keeping every final row + identical is therefore sufficient for exactness but not necessary. +2. **Forced coordinates.** The 632 restore-entry rows are linearly independent (exact elimination, rank 632), so each + x_c has unique coordinates M[c] in them. A restore is a product of invertible scalar gates, so the final row of c is + Σ_q R′[c][q] e_q and exactness forces R′[c] = M[c] for every exact W′. The current restore realizes exactly these M. +3. **Forced caps.** If M[c][r] ≠ 0 (r ≠ c), the (c, r) entry of the product of elementary gates is a sum over gate paths + r → u₁ → … → c; on such a path consecutive gate frames are nested and the last is inside E_c, and the first gate reads r, + so F_r ⊆ E_c. Hence F_r ⊆ cap_r = ∩ E_c over r's restored receivers: **88 caps**. +4. **Merge.** In any feasible frame assignment φ of W′, replace every register's restore-phase climbs by one end climb. + The result is feasible for the capped empty-restore problem (Lemma 3) and cheaper by Σ_r ov_r(φ), where ov_r = + Σ c_{jᵢ} − c_{Σ jᵢ} ≥ 0 (weights are subadditive). So cert(W′) ≥ LB_forced + Σ_r ov_r(φ), with LB_forced = + 10,867,765,164 computed by exact elimination. +5. **Delivery and cleaning.** If M[c][r] ≠ 0, r is read at a restore-phase frame inside E_c by a register y with + L_y ⊆ that frame ⊆ E_y. If a non-restored r enters the restore holding a restored input variable, it must be written + below FULL: the span of restored-input parts of the registers at FULL never shrinks (FULL registers only meet FULL + registers) and must end at 0. +6. **Departure (dual vectors).** Suppose r stays inside a frame G until, at time t, it jumps to its end frame E_r. Let A_t + be the matrix of the restore prefix (rows = register rows in the e-basis) and d_r(t) = A_t⁻¹ e_r its dual vector, and + O = {c ∈ 𝓡 : c ≠ r, E_r ⊄ E_c}. Then d_r(t) ≠ 0 and ⟨M[c], d_r(t)⟩ = 0 for c ∈ O, since after t no gate path leads + from r to c. A gate `t += k·s` changes only d_s (by −k·d_t), so d_r changes only when r is read, by a register whose + frame is inside G, and recursively; hence d_r(t) is supported on Z = {r} ∪ {y : L_y ⊆ G}. **If M[O][Z] has full column + rank |Z|, r cannot stay inside G and then leave to E_r.** (This replaces lane K's partner-only rank test, whose columns + omitted the registers that can sit strictly inside G; on these words both exclude the same frames.) +7. **Carriers.** Content sitting at a frame F (or inside a restored source's end V) that must reach a receiver which + cannot sit there is carried upward by a register that sits there. A non-restored carrier then has two restore-phase + jumps (≥ 2c1 − c2 = 4,996); a restored carrier is free only if its end meets E_c above F (resp. outside V); a BLOCKED + register has no gate at its entry frame, so carrying needs a third jump, which costs at least β + 4,996 here. + +**Classification** (`restore_bound.py`, all frames enumerated exactly). A register r with restored receivers or leaks is +*BLOCKED* when some receiver c with E_r ⊄ E_c (or its leak) admits no partner s with L_r + L_s ⊆ U_r ∩ E_c ∩ E_s of +dimension < 9. Then r has no gate at F_r and at least two restore-phase jumps; β_r is the minimum overhead over every +admissible entry dimension, every two-jump first frame G (enumerated; a reader must sit at G and the departure test must +pass) and every chain of three or more jumps. Every *OPEN* non-restored register is tested at every admissible entry frame +F ∈ [L_r, U_r ∩ cap_r]: if no F admits a skip (reader + departure), r pays a visit; if every skip frame leaves a receiver +that needs a non-free carrier, the group {r} ∪ (non-restored registers that can sit at F) pays one visit (*zero-sum*). +Lifts out of a restored source's end are charged the same way. Overlapping groups are merged and charged once; BLOCKED +members are admitted only when carrying costs them ≥ β + 4,996. Result on both providers: **42 BLOCKED registers, +Σ β = 292,959; 9 disjoint payer groups, 9 × 4,996 = 44,964; bound = LB_forced + 337,923 = cert(W).** ∎ + +## The 51 visits of PR #3042's literal frames, all forced + +| restore block | visiting registers | units | verdict | +|---|---|---:|---| +| PR2857/PR2894 kernel-preload pairs | 3, 44, 46, 69, 105, 306, 308, 310, 322, 324, 326, 351, 367, 383, 399, 408, 412, 414, 424, 428, 430, 434, 436, 438, 439, 440, 444, 446, 475, 486 | 192,384 | 24 BLOCKED; 46/521, 367/496, 399/472, 446/545 zero-sum; 69, 444 departure-forced | +| stage-1 group gates (W_A..W_D) | 5, 7, 34, 54, 73, 226, 228, 230, 231, 232, 236, 238, 363, 395 | 103,043 | 14 BLOCKED | +| n45 (PR2942, pivots 249/251/265/267 at V45) | 2, 70, 71, 72 (6 → V45 → 9, 6,877 each) | 27,508 | 4 BLOCKED | +| PR2908/PR2917 extraction outputs | 23, 35 | 9,992 | zero-sum with 39, 77 | +| n42 (PR2979 + R1_E42) | 61 (V45 → E42 → 9) | 4,996 | forced lift | + +* **Normal 45.** The entry lower bounds of 2, 70, 71, 72 and of the pivots 249, 251, 265, 267 are eight pairwise-distinct + 6-dimensional subspaces inside V45 = ⟨256, 128, 64, 35, 16, 11, 5⟩ (they span it). For each visitor r and each of its + restored receivers c, U_r ∩ E_c = L_r and no other register s has L_s ⊆ L_r ⊆ E_s: no partner, entry frame forced to + L_r, first frame inside V45, hence the (1, 2) split 6 → V45 → 9 at 6,877. +* **The (2, 2) registers** 5, 34, 44, 54, 73, 105, 414, 430 would save 1,881 each with a (1, 3) split. Each has three + 6-dim candidate first frames: two admit no register at all, and at the third M[O][Z] has full column rank (|Z| = 6, 8 + or 10), so Lemma 6 excludes it. +* **Zero-sum** (23 and 39, 35 and 77, 46 and 521, 367 and 496, 399 and 472, 446 and 545): at every skip frame the receiver + (511, 499, 589, 543, 567, 591) cannot sit there, no restored register can carry the content above it inside the + receiver's end, and the only possible carrier is one non-restored register, so one of the pair visits. +* **Departure-forced** 69 and 444: every admissible entry frame either has no reader or fails Lemma 6 (|Z| = 2). +* **61's lift.** 230 (end E42 = ⟨256, 128, 64, 34, 16, 10, 4, 1⟩) needs the entry contents of the V45-ended pivots 249 and + 265 (M[230] has ±1/4 on 2, 34, 45, 54, 71, 92, 103, 228, 249, 265, 299, 331). No restored register can sit inside + V45 ∩ E42 and climb out of V45 inside E42, so a register of {0, 2, 61, 62, 63, 70, 71, 72, 76, 94, 233, 235} must make a + V45 → E42 → 9 visit (the blocked 2, 70, 71, 72 would need a third jump: 11,873 = 6,877 + 4,996). In PR #3042's words + 61 does it. + +## Calibration on PR #2979's words + +PR #2979 (same A/B, same caps, same LB_forced) costs 10,868,133,063 with 54 literal visits (367,899 units). Against the +same bound its unforced part is exactly 29,976 = 6 × 4,996: the BLOCKED 5, 54, 73 pay 14,975 instead of β = 9,979, 22 and +40 visit without any forcing, and the lift group pays twice (61 and 63). These are precisely dcharb78's six skips 63, 54, +40, 22, 73, 5 (PR #3042 keeps 61 as the lifter). The bound therefore predicted PR #3042's realized gain exactly, and +PR #3042 attains it; nothing further is available to restore-only rewrites. + +## Erratum to PR #3042's README (documentation only) + +Applying each declared block of PR #3042's `edits/EDITS.json` alone to PR #2979's words (exact splice, frames re-solved; +`certificates/ERRATUM-3042.json`, both providers): + +| block | certified delta | profile delta | registers that skip | PR #3042 README says | +|---|---:|---|---|---| +| R1_E42 (`restore[162:188]`) | **−19,984** | −8 H1 + 4 H2 | 63, 54, 40, **22** | −14,888 for 63, 54, 40 | +| R2_E7 (`restore[190:203]`) | **−9,992** | −4 H1 + 2 H2 | 73, 5 | −14,938 for 22, 73, 5 | +| both | **−29,976** | −12 H1 + 6 H2 | all six | −29,826 | + +Register 22 skips through R1_E42's gate `22 += −2·34`; R2_E7's gates touch only 5, 59, 73, 96, 363, 395. The declared +blocks replace 26 gates by 33 and 13 by 15 (the README lists 26 → 29 and 13 → 14; the restore grows from 203 to 212 +gates). Applying both blocks reproduces PR #3042's final words exactly, so its profile, allocation and κ are unaffected. + +## Verification + +```sh +python3 -B research/rank7-skip-restore-optimum/run_registered.py # ~70 s, Python standard library (3.12; 3.14 also runs) +python3 -B scripts/research_package.py --package research/rank7-skip-restore-optimum +``` + +`run_registered.py` checks the complete inventory (MANIFEST.json) and pins, reruns `verify.py` and `census.py` in a +temporary directory, requires their regenerated receipts to equal `certificates/` byte for byte, and binds lane K's stored +receipts (evidence/laneK/) to the recomputation. `verify.py` (13 s) recomputes per provider: the exact frame optimum +(10,868,103,087, the declared profile, 743 variables in 210 components, largest 94, as PR #3065 reports independently), +the free-algebra restore-entry rows (vendored PR2833 `walg_apply`), their rank, the forced coordinates and that the current +restore realizes them, the auditor on the word, the 88 caps, LB_forced, the classification and bound, the 51 literal +visits and their charges, the normal-45 facts; then the calibration, the erratum and the controls: + +* auditor semantics: two appended FULL gates pass at delta 0, a gate into a restored helper fails; +* attainment: PR #3056's three-ADD and PR #3060's four-gate words for `restore[175:179]` are exact and tie the bound; +* twelve rejections: mislabeled provider, flipped byte, a dropped cap (LB_forced falls to 10,867,757,066), a dropped + visit, a perturbed entry row, three cheaper restores that violate exactness (empty restore −499,481; deleting R44 + −6,877 leaves 498 in 475; deleting R82 −4,996 leaves 584 dirty; each rejected by Lemma 1 and by the auditor), a wrong + claimed cost, an optimality claim for PR #2979, the departure lemma restricted to receivers containing the frame (admits + the eight (1, 3) splits, bound 10,868,088,039), and caps read from the restore map of an emptied restore (0 caps). + +`frames_exact.py` is a numpy-free port of the certified solver used for every price in this lineage (our r12 BORROW-WORD +harness on the #1186 frame toolkit, `research/exact-frame-toolkit/frames.py`): same model, same exact elimination, same +weights from the vendored `research/frame-domain-ceiling` engines; it reproduces all four certified optima and LB_forced. +`evidence/laneK/CROSSCHECK.json` runs lane K's current `bound.py`/`lbforced.py` (the version that takes the supplied M, +pinned in `evidence/laneK/`) on the four words with their own and with an emptied restore: bound, LB_forced and caps agree +in all eight cases. This package derives M from the restore-entry rows, never from the restore. + +### Empirical controls (not part of the proof) + +* **Deletion census** (recomputed completely): of the 212 single-gate restore deletions per provider, 10 keep the Lemma 1 + conditions; all cost delta 0. +* **Tail-exchange census** (lane K; candidate list re-derived here, 1 in 25 records re-checked): 8,098 exchanges per + provider of a visiting register r with a non-restored s (exact swap at r's first restore touch or at R0, restore + relabelled); 6,378 exact, 990 frame-feasible, minimum delta 0, none negative. +* Lane K's A/B censuses scored by this bound (local evidence on the base provider, not re-run and not part of the + theorem; `evidence/laneK/FULLAB-SUMMARY.json`): 25,846 single-gate moves over all A/B gates, 6,387 read splits, 640 + write-sink variants, 99 merges and 350 commuting pairs, no positive gap. One move scored a gap of 9,992 only because it + lands a target write in the restore, which the auditor forbids; it is excluded. + +## Scope + +Covered: every restore gate sequence at fixed A/B scalar programs, with all frames re-solved, at the certified solver's +weights. PR #3057 fixes every scalar operation and changes restore frames only; PR #3065 changes A/B/restore frames jointly +for the fixed scalar order (uniformly in b, with a relaxation at fixed interfaces). This package changes the restore's +scalar program arbitrarily but keeps A/B fixed. Not covered: A/B gate changes (lane K's scored A/B censuses are local +evidence only), helper ends, entrances, warps, buffers, the width inventory, packing or allocation, physical or native +costs, and other words. No κ is changed; PR #3042's and PR #3054's admissions are untouched. + +## Open next questions + +* **A/B-phase re-synthesis.** The restore's 499,481-unit overhead over the unconstrained empty-restore optimum is forced + by A/B: 161,558 units of entry caps acting on A/B chains and 337,923 units of forced visits, of which 192,384 sit in the + 30 PR2857/PR2894 kernel/preload restore pairs. Only an A-phase (input block) or B-phase re-synthesis that changes the + forced coordinates M or the entry bounds L/U can move them. First step: recompute M, the caps and this bound for a + candidate A/B block before pricing it (`restore_bound.bound` takes any word). +* **Fixed target port hyperplanes.** Our r15 searches of A/B moves, start-frame raises and narrowing (lane reports, not + packaged) all stopped at the same constraint: target writes in late B and the A-end target levels are pinned by the + targets' 8-dim port-perpendicular end frames. A changed target port interface (PR2312 lineage) looks like the common + wall for local levers on these words; it changes the source contract and needs a complete replacement bound. + +## Credit + +dcharb78 (PR #3042) for the six-skip words and the carrier/pivot skips; Jeremy Kothe (PR #3015) for R1 and the declared +restore-edit stage; Nick Petalas for PR #3054 (T740 with the six skips), PR #3057 and PR #3065 (frame optima), PR #3056 +and PR #3060 (restore blocks used here as attainment controls) and T740; Marius-Paul Dumitrean for PR #2979 and its +lineage; icekylinx for PR #2833's auditor (vendored unchanged); Mason Hale (PR #2917) and Jeremy Diviney (PR #2908) for the +paired extractions. Details and retained files: [CREDITS.md](CREDITS.md), [NOTICE](NOTICE), [SOURCES.json](SOURCES.json). +Prepared by Marius-Paul Dumitrean with substantial AI assistance (Claude Code); author-checked, no independent review is +claimed. Apache-2.0. diff --git a/research/rank7-skip-restore-optimum/SOURCES.json b/research/rank7-skip-restore-optimum/SOURCES.json new file mode 100644 index 0000000000..6687f6adfa --- /dev/null +++ b/research/rank7-skip-restore-optimum/SOURCES.json @@ -0,0 +1,257 @@ +{ + "schema_version": 1, + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "upstream_repository": "https://github.com/CrocSwap/integer-mult-bounds", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "role": "originating task catalogue (priority revision 6)" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "role": "selected record (unchanged by this package)" + }, + { + "path": "research/gmx-t74-borrow43-handoff/new/borrow/audit_local.py", + "usage": "provenance", + "git_blob": "8224873d0497cf0b4c202f31b145fa273553d978", + "sha256": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "package_path": "vendor/audit_local.py", + "pr": 2833, + "role": "PR2833's independent exact auditor (icekylinx attribution), BORROW-WORD branch; walg_apply and run, vendored unchanged" + }, + { + "path": "research/frame-domain-ceiling/engines/moment.py", + "usage": "provenance", + "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "package_path": "vendor/moment.py", + "role": "outward moment bounds behind the integer weights c[r] (frames.Costs)" + }, + { + "path": "research/frame-domain-ceiling/engines/base_two_moment.py", + "usage": "provenance", + "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "package_path": "vendor/base_two_moment.py", + "role": "second moment engine (PR39 cross-check) behind the integer weights" + }, + { + "path": "research/frame-domain-ceiling/vendor/static44/gk/gk_common.py", + "usage": "provenance", + "git_blob": "0e5fde920d29106232776eb56347297c0d40fa72", + "sha256": "e68d190fd436b2f3955decb590adb53344d5d4ea0a19d62d86df1e4b55ecd198", + "package_path": "vendor/gk_common.py", + "role": "canonical GF(2) bases (DreamingOfClouds), as used by the frame toolkit" + }, + { + "path": "research/exact-frame-toolkit/frames.py", + "usage": "provenance", + "git_blob": "c27c28b80b52e23346a772a67c23934c8292fd69", + "sha256": "59d5f5725c50c5d6c22178e82ee79a5d7646f0133b1aa267081ec1ad228ec437", + "pr": 1186, + "role": "PR1186 exact frame toolkit (Graph domains, exact variable elimination, Costs): ported to frames_exact.py without numpy" + }, + { + "path": "research/rank7-restore-carrier-skips/edits/FINAL-WORD-base.json.gz", + "usage": "provenance", + "git_blob": "2ee02e318c98281a71445b954feccd55c153827c", + "sha256": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e", + "pin": "head:84cc406ad91ec53fff329a11a445d7effe564a77:research/rank7-restore-carrier-skips/edits/FINAL-WORD-base.json.gz", + "package_path": "data/WORD-3042-base.json.gz", + "pr": 3042, + "role": "dcharb78's six-skip base provider word (PR3042 head)" + }, + { + "path": "research/rank7-restore-carrier-skips/edits/FINAL-WORD-extra.json.gz", + "usage": "provenance", + "git_blob": "33ba5f34996a31edd197cb58eca575645575e529", + "sha256": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35", + "pin": "head:84cc406ad91ec53fff329a11a445d7effe564a77:research/rank7-restore-carrier-skips/edits/FINAL-WORD-extra.json.gz", + "package_path": "data/WORD-3042-extra.json.gz", + "pr": 3042, + "role": "dcharb78's six-skip extra provider word (PR3042 head)" + }, + { + "path": "research/rank7-restore-carrier-skips/edits/EDITS.json", + "usage": "provenance", + "git_blob": "c2042a37bdba0febb791d39bcb1f9f55de9fb14e", + "sha256": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "pin": "head:84cc406ad91ec53fff329a11a445d7effe564a77:research/rank7-restore-carrier-skips/edits/EDITS.json", + "package_path": "data/EDITS-3042.json", + "pr": 3042, + "role": "PR3042's declared restore edits R1_E42 and R2_E7 (erratum and calibration)" + }, + { + "path": "research/rank7-restore-carrier-skips/README.md", + "usage": "provenance", + "git_blob": "0cbfc50459652b00f46722ed7b5e769a9e5f6b50", + "sha256": "a7f24ba0b020afc394197ed2866f9958cfe6628c8b42bf84b09c98da0f681c85", + "pin": "head:84cc406ad91ec53fff329a11a445d7effe564a77:research/rank7-restore-carrier-skips/README.md", + "pr": 3042, + "role": "PR3042's README, whose per-block attribution the erratum corrects" + }, + { + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/edits/FINAL-WORD-base.json.gz", + "usage": "provenance", + "git_blob": "2ee02e318c98281a71445b954feccd55c153827c", + "sha256": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e", + "pin": "head:4773c3ea67b471415870e38411fae313ec44a675:research/rank7-t740-carrier-skips/vendor/pr3042/edits/FINAL-WORD-base.json.gz", + "pr": 3054, + "role": "PR3054 (Nick Petalas) retains the same base word (same blob)" + }, + { + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/edits/FINAL-WORD-extra.json.gz", + "usage": "provenance", + "git_blob": "33ba5f34996a31edd197cb58eca575645575e529", + "sha256": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35", + "pin": "head:4773c3ea67b471415870e38411fae313ec44a675:research/rank7-t740-carrier-skips/vendor/pr3042/edits/FINAL-WORD-extra.json.gz", + "pr": 3054, + "role": "PR3054 retains the same extra word (same blob)" + }, + { + "path": "research/rank7-joint-endframes/data/WORD-base.json.gz", + "usage": "provenance", + "git_blob": "d9aa96a93fea5f7395e7783aef0bc117c0a0ae89", + "sha256": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/data/WORD-base.json.gz", + "package_path": "data/WORD-2979-base.json.gz", + "pr": 2979, + "role": "PR2979's base word (calibration; also retained by PR3042 as data/WORD-base.json.gz)" + }, + { + "path": "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "usage": "provenance", + "git_blob": "74f6cb64595c21f7726ae77e69437868620bdcee", + "sha256": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/data/WORD-extra.json.gz", + "package_path": "data/WORD-2979-extra.json.gz", + "pr": 2979, + "role": "PR2979's extra word (calibration)" + }, + { + "path": "research/rank7-restore-frame-optimum/README.md", + "usage": "provenance", + "git_blob": "f3dc70b1b57a4bc6997dd2ccf9fda0c3d493cbca", + "sha256": "88e672250159e796bf1184974ba40ce8898a5e4f2e31cbcdf16c09ee6891f601", + "pr": 3057, + "role": "PR3057 (Nick Petalas): restore-frame optimum for the fixed scalar order (scope comparison)" + }, + { + "path": "research/rank7-joint-frame-optimum/README.md", + "usage": "provenance", + "git_blob": "9bba275378cfa7efa626013e32e24acd7d266754", + "sha256": "baf9e7d0d85753918b2d54f39cc43db8efb6802c704ed91cf8533fbd5bc343e9", + "pr": 3065, + "role": "PR3065 (Nick Petalas): joint A/B/restore frame optimum for the fixed scalar order; reports 743 variables, 210 components, largest 94" + }, + { + "path": "research/rank7-restore-contraction/contract.py", + "usage": "provenance", + "git_blob": "8b81fe8a760b23723fb6739f1e71165bd8ef7287", + "sha256": "5f9823fe342f629312e28d8edf5bca02171ce574f1037bc980397ba6c88ba784", + "pr": 3056, + "role": "PR3056 (Nick Petalas): OLD/NEW literal blocks of restore[175:179] used as an attainment control" + }, + { + "path": "research/rank7-native-tariff-optimum/tariff.py", + "usage": "provenance", + "git_blob": "b1676fd2e85d65ca5bb42d97c775a06f2d0a4dbb", + "sha256": "618721d59891a3aad495692ebb943451f5df6700a60e57d7761009aec0644655", + "pr": 3060, + "role": "PR3060 (Nick Petalas): OPTIMAL literal block of restore[175:179] used as an attainment control" + }, + { + "path": "research/rank7-joint-endframes-restore-edit/README.md", + "usage": "provenance", + "git_blob": "493f9d0621981ec8d061200264d2efe93c4a590a", + "sha256": "186a01ff053630b6451464ed61b779e3747602d85805f5f0ad0dca8c3b9407f0", + "pr": 3015, + "role": "PR3015 (Jeremy Kothe): R1 and the declared restore-edit stage" + }, + { + "path": "research/rank7-shared-restore-fanin/README.md", + "usage": "provenance", + "git_blob": "2ed3a44ebf163d140ab1f2b285a805d1334d8b19", + "sha256": "305677bd8f6b3d8fa79594bc8073b36023bc1efa2f35a77f1ac6d7f0711f0ec6", + "pr": 3044, + "role": "PR3044 (Nick Petalas): R2 shared restore covector on the R1 words" + } + ], + "adapted_sources": [ + { + "package_path": "frames_exact.py", + "origin": [ + "r12 BORROW-WORD harness bp.py (Marius-Paul Dumitrean; unpublished, sha256 940370add03868d982fe7fc1a133641b239adeb2567fefae6b754c94d615668d): build_problem, BorrowGraph, centre_descents, frame_profile", + "research/exact-frame-toolkit/frames.py (PR1186): Graph._domain, profile, solve_component_ve, optimal_frames accounting, Costs" + ], + "change": "numpy-free port of the exact variable-elimination path only (a component elimination cannot finish raises); hard-coded checkout paths replaced by vendored engines; optional caps keyed by original register" + }, + { + "package_path": "restore_bound.py", + "origin": [ + "lane K (r15) bound.py, lbforced.py, screen4.py, rowsfa.py, coords.py (pinned in evidence/laneK/ for the first two)" + ], + "change": "sound re-derivation: forced coordinates from the restore-entry rows (never from the restore); departure lemma with columns {r} + {y : L_y <= G} and all restored rows (replaces the partner-only rank test); every admissible entry frame and every two-jump first frame enumerated; carriers of blocked registers need a third jump; lifts with the weaker free-carrier condition" + }, + { + "package_path": "census.py", + "origin": [ + "lane K delcensus.py and swapcensus.py (relabel and exchange copied)" + ], + "change": "deletion census recomputed completely; tail-exchange candidate list re-derived and stored records re-checked on a sample" + } + ], + "new_sources": [ + "verify.py", + "run_registered.py", + "certificates/", + "README.md", + "TASK.json", + "VERIFY.json", + "NOTICE", + "CREDITS.md", + "PINS.json", + "MANIFEST.json", + ".gitattributes" + ], + "unpublished_sources": [ + { + "package_path": "evidence/laneK/bound.py", + "sha256": "6b1479b436c4f01bb32f771aa06af3d2260adee5dd5a5e2bf568b0192cee69d8", + "role": "lane K's current bound (takes the supplied M); runs only in lane K's tree" + }, + { + "package_path": "evidence/laneK/lbforced.py", + "sha256": "bd81e3f4460f61ef81e15e76ab25be5f8a9d7b71bb7dcbbf7a87873ca5398341", + "role": "lane K's current LB_forced (takes the supplied M)" + }, + { + "package_path": "evidence/laneK/NEGATIVE-3042-base.json", + "role": "lane K's receipt made with the r12 harness (bound to the recomputation by run_registered.py)" + }, + { + "package_path": "evidence/laneK/NEGATIVE-3042-extra.json", + "role": "same, extra provider" + }, + { + "package_path": "evidence/laneK/AUDITOR-SEMANTICS.json", + "role": "lane K's appended-gate auditor control (recomputed in certificates/CONTROLS.json)" + }, + { + "package_path": "evidence/laneK/FULLAB-SUMMARY.json", + "role": "lane K's A/B censuses scored by the bound (local evidence, not re-run)" + }, + { + "package_path": "evidence/tail-exchange/", + "role": "lane K's tail-exchange census records (both providers; identical records)" + } + ], + "source_boundary": "Only this package is new. Every retained upstream file is byte-identical to its pinned blob; the verifier reads only files inside the package and needs no network, Git or numpy." +} diff --git a/research/rank7-skip-restore-optimum/TASK.json b/research/rank7-skip-restore-optimum/TASK.json new file mode 100644 index 0000000000..97882cdf6f --- /dev/null +++ b/research/rank7-skip-restore-optimum/TASK.json @@ -0,0 +1,72 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 6, + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "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": [ + "docs/research/research-family-status.md", + "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. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "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.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "refined", + "actual_scope": "On PR #3042's two six-skip provider words (also PR #3054's words): the complete class of exact restore-only rewrites (A with its prelude, B, warps, cut, initial corrections, precondition, compensation, start frames, helper end frames, removed helpers and buffers fixed; any restore scalar gate sequence; all frames re-solved; exactness = PR2833's auditor), priced by the certified frame solver at b = 0.001703676387993676.", + "scope_change_reason": "The card asks whether a changed local cost interface can beat current packing. On the six-skip words the only lever left to restore edits is the local frame bill at fixed widths and buffers, and PR3057/PR3065 already settled the fixed-scalar-order frame problem. This package narrows the card to one word pair and one section (the restore) but widens the move set to every exact restore gate sequence, and proves that the published restore is optimal there; a scoped negative that tells the next construction which premise (A/B or the target interface) must change.", + "bottleneck_link": "The restore-phase overhead of PR3042's words over the unconstrained empty-restore optimum is 499,481 units per call (161,558 forced entry caps on A/B chains + 337,923 forced visits). All of it is forced by A/B and the restored helpers' required content, so no restore-only rewrite can lower the local profile or raise the inventory's packing cap; a gain must change A/B or the target interface.", + "budget_minutes": 240, + "stop_rule": "Stop at an exact lower bound equal to the certified cost on both providers (scoped negative, no dependent construction round), or at the first exact restore-only rewrite that beats it (then one complete release). The bound must be calibrated on PR2979's words, where it has to reproduce dcharb78's realized 29,976.", + "outcome": "negative-result", + "evidence": "run_registered.py (Python 3.12 standard library): MANIFEST/PINS; verify.py (exact frame optimum, restore-entry rows and their rank, forced coordinates, 88 caps, LB_forced 10,867,765,164, classification 42 blocked + 9 payer groups = 337,923, bound = certified cost 10,868,103,087 on both providers, 51 literal visits all charged, normal-45 facts, PR2979 calibration gap 29,976 = the six PR3042 skips, per-block erratum of PR3042's README, auditor-semantics controls, PR3056/PR3060 attainment controls, 12 rejection controls) and census.py (complete deletion census, re-derived tail-exchange candidate list with sampled re-checks); regenerated receipts byte-equal to certificates/; lane K's stored receipts and its current bound.py/lbforced.py cross-checked in evidence/laneK/.", + "author": "Marius-Paul Dumitrean", + "ai_assistance": "Substantial AI assistance (Claude Code) for the search, the proof write-up, the stdlib port and the checks; author-checked, no independent review is claimed.", + "open_questions": [ + { + "question": "Can an A-phase (input block) or B-phase re-synthesis lower the restore's forced overhead (161,558 forced-cap units on A/B chains; 192,384 units of kernel/preload visits in 30 registers)?", + "why_it_matters": "This package proves the whole 499,481-unit restore overhead forced at fixed A/B; any further local gain on these words must change A/B, i.e. the forced coordinates M of the restored helpers or the entry bounds L/U.", + "first_step": "For a candidate A/B block, recompute the restore-entry rows, M, the caps and restore_bound.bound on the edited word before pricing it; only candidates whose bound falls below the current cost are worth realizing.", + "blocked_by": "Lane K's single-move A/B censuses scored by this bound (local evidence) found no positive gap; multi-gate input-block re-synthesis needs exact dirty-input identities for the changed block and its frame bill." + }, + { + "question": "Is the fixed target port interface the common wall for local levers on these words?", + "why_it_matters": "Several r15 searches stopped at late-B target writes and A-end target levels pinned by the targets' 8-dim port-perpendicular end frames.", + "first_step": "Name one changed port interface (PR2312 lineage), derive its complete replacement bound, and price its effect on L/U of the restore-entry registers with this package's bound.", + "blocked_by": "A changed port interface changes the source contract and needs a fully charged replacement bound and admission." + } + ] +} diff --git a/research/rank7-skip-restore-optimum/VERIFY.json b/research/rank7-skip-restore-optimum/VERIFY.json new file mode 100644 index 0000000000..3353657a92 --- /dev/null +++ b/research/rank7-skip-restore-optimum/VERIFY.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/run_registered.py" + ], + "timeout_seconds": 600, + "checks": "Complete inventory (MANIFEST) and pins; verify.py on both PR3042 providers: exact frame optimum 10,868,103,087 with the declared profile, restore-entry rows (PR2833 free algebra) independent, forced coordinates realized by the current restore, PR2833 auditor PASS, 88 forced caps, LB_forced 10,867,765,164, sound classification (42 blocked, 9 payer groups) giving bound = certified cost, 51 literal visits all charged, normal-45 facts; PR2979 calibration (gap 29,976 = the six PR3042 skips); per-block erratum of PR3042's README; auditor-semantics, PR3056/PR3060 attainment and 12 rejection controls; census.py (deletion census, tail-exchange candidate list and sampled re-checks); regenerated receipts byte-equal to certificates/; lane K receipts and its current bound.py/lbforced.py cross-check bound to the recomputation." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "The proof replay with Python assertions disabled and warnings as errors: every check is an explicit exception; regenerated receipts compared with certificates/." + } + ] +} diff --git a/research/rank7-skip-restore-optimum/census.py b/research/rank7-skip-restore-optimum/census.py new file mode 100644 index 0000000000..67c0e1b44e --- /dev/null +++ b/research/rank7-skip-restore-optimum/census.py @@ -0,0 +1,165 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Empirical controls (not part of the proof): the single-gate deletion census of the restore, recomputed completely, and +the tail-exchange census of lane K, whose candidate list is re-derived here and whose stored records are re-checked on a +deterministic sample with this package's exactness test and exact frame solver. + +Deletion census: delete one restore gate at a time; keep it if the Lemma 1 end conditions still hold (relaxed semantics: +other final rows free) and price it. Tail-exchange census: for a register r with a restore-phase visit and any other +non-restored, non-target register s with dim(L_r + L_s) <= 8, insert the exact exchange [s += r; r -= s; s += r] at r's +first restore touch or at R0 and relabel the rest of the restore (r <-> s with signs), so that s carries r's restore role; +price every exact candidate. Marius-Paul Dumitrean, with substantial AI assistance (Claude Code). +""" +import argparse +import collections +import copy +import gzip +import json +import sys +import time +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import frames_exact as FX # noqa: E402 +import restore_bound as RB # noqa: E402 +import verify as VF # noqa: E402 + +SAMPLE_EVERY = 25 +TAIL_SHA = {'base': '7bfa6fee793b7c7732a21f9d24d6f67029d726b9e4bd646fd6e626ab58e5176d', + 'extra': '7bfa6fee793b7c7732a21f9d24d6f67029d726b9e4bd646fd6e626ab58e5176d'} +TAIL_PINS = {'base': 'evidence/tail-exchange/TAIL-EXCHANGE-3042-base.jsonl.gz', + 'extra': 'evidence/tail-exchange/TAIL-EXCHANGE-3042-extra.jsonl.gz'} + + +def deletion_census(w, rows, base): + exact = [] + n = 0 + for i in range(len(w['restore'])): + x = copy.deepcopy(w) + g = x['restore'].pop(i) + fin = RB.run_restore(x['restore'], rows) + dirty, leaks, targets = RB.end_conditions(x, fin, rows) + n += 1 + if dirty or leaks or targets: + continue + try: + d = FX.frame_optimum(x)['cost'] - base + except FX.Infeasible: + d = None + exact.append(dict(deleted=i, gate=g[:5], delta=d)) + return dict(deletions=n, exact=len(exact), exact_deletions=exact, + min_delta=min((e['delta'] for e in exact if e['delta'] is not None), default=None)) + + +def relabel(g, r, s): + """gate on old registers rewritten after the exchange (new s = old r, new r = -old s); lane K's swapcensus.py""" + g = list(g) + if g[0] == 'add': + t, u, num = g[1], g[2], g[3] + sgn = 1 + nt = {r: s, s: r}.get(t, t) + nu = {r: s, s: r}.get(u, u) + if u == s: + sgn = -sgn + if t == s: + sgn = -sgn + g[1], g[2], g[3] = nt, nu, num * sgn + else: + g[1] = {r: s, s: r}.get(g[1], g[1]) + return g + + +def exchange(w, r, s, p): + x = copy.deepcopy(w) + R0 = w['restore'] + sw = [['add', s, r, 1, 1, list(FX.FULL9)], ['add', r, s, -1, 1, list(FX.FULL9)], ['add', s, r, 1, 1, list(FX.FULL9)]] + x['restore'] = [list(g) for g in R0[:p]] + sw + [relabel(g, r, s) for g in R0[p:]] + return x + + +def tail_jobs(w, lit, LU): + R = RB.restored(w) + regs = [q for q, x in sorted(lit.items()) if x['overhead']] + jobs = [] + for r in regs: + first = min(i for i, g in enumerate(w['restore']) if r in FX.regs_of(g)) + for s in sorted(LU): + if s == r or s in R or RB.is_target(s): + continue + if len(FX.join(LU[r][0], LU[s][0])) > 8: + continue + for p in sorted({first, 0}): + jobs.append((r, s, p)) + return jobs + + +def tail_check(prov, w, rows, base, LU, lit): + raw = (HERE / TAIL_PINS[prov]).read_bytes() + recs = [json.loads(l) for l in gzip.decompress(raw).decode().splitlines()] + jobs = tail_jobs(w, lit, LU) + VF.require(sorted((x['r'], x['s'], x['p']) for x in recs) == sorted(jobs), 'stored census covers exactly the re-derived candidates') + hist = collections.Counter(x['delta'] for x in recs if x.get('status') == 'ok') + summary = dict(candidates=len(recs), exact=sum(1 for x in recs if x['clean']), frame_feasible=sum(1 for x in recs if x.get('status') == 'ok'), + infeasible=sum(1 for x in recs if x.get('status') == 'infeasible'), not_exact=sum(1 for x in recs if not x['clean']), + min_delta=min(hist), negative=sum(v for k, v in hist.items() if k < 0), + delta_histogram={str(k): v for k, v in sorted(hist.items())}) + checked = 0 + for i, x in enumerate(sorted(recs, key=lambda y: (y['r'], y['s'], y['p']))): + if i % SAMPLE_EVERY: + continue + y = exchange(w, x['r'], x['s'], x['p']) + fin = RB.run_restore(y['restore'], rows) + dirty, leaks, targets = RB.end_conditions(y, fin, rows) + clean = not dirty and not leaks and not targets + VF.require(clean == x['clean'], 'exactness of stored candidate %s' % ((x['r'], x['s'], x['p']),)) + if clean: + try: + d = FX.frame_optimum(y)['cost'] - base + status = 'ok' + except FX.Infeasible: + d, status = None, 'infeasible' + VF.require(status == x.get('status') and (d == x.get('delta') or status != 'ok'), 'price of stored candidate %s' % ((x['r'], x['s'], x['p']),)) + checked += 1 + summary['sample_every'] = SAMPLE_EVERY + summary['sample_rechecked'] = checked + return summary + + +def main(): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument('--work', type=Path) + a = ap.parse_args() + t0 = time.monotonic() + VF.authenticate() + VF.authenticate(pins={TAIL_PINS['base']: TAIL_SHA['base'], TAIL_PINS['extra']: TAIL_SHA['extra']}) + out = {} + for prov in ('base', 'extra'): + w = VF.load_word('3042-' + prov) + rows = RB.entry_rows(w) + sol = FX.frame_optimum(w) + base = sol['cost'] + lit = RB.literal_restore_chains(w) + Mc, rk = RB.coordinates(rows, {x: {(x, ()): VF.Q(1)} for x in RB.restored(w)}) + caps, _ = RB.forced_caps({x: dict(v) for x, v in Mc.items()}, RB.end_frames(w), RB.restored(w)) + LU = RB.entry_bounds(w, RB.lb_forced(w, caps)) + dele = deletion_census(w, rows, base) + VF.require(dele['deletions'] == 212 and dele['exact'] == 10 and all(e['delta'] == 0 for e in dele['exact_deletions']), 'deletion census') + tail = tail_check(prov, w, rows, base, LU, lit) + VF.require(tail['candidates'] == 8098 and tail['negative'] == 0 and tail['min_delta'] == 0, 'tail-exchange census') + out[prov] = dict(deletion=dele, tail_exchange=tail) + print('PASS census', prov, 'deletions', dele['deletions'], 'exact', dele['exact'], 'min delta', dele['min_delta'], + '| tail exchanges', tail['candidates'], 'exact', tail['exact'], 'feasible', tail['frame_feasible'], 'min delta', + tail['min_delta'], 'rechecked', tail['sample_rechecked'], flush=True) + VF.require(out['base'] == out['extra'], 'providers agree') + text = VF.canonical(out) + if a.work: + a.work.mkdir(parents=True, exist_ok=True) + (a.work / 'CENSUS.json').write_text(text) + else: + VF.require((HERE / 'certificates/CENSUS.json').read_text() == text, 'regenerated census differs from certificates/CENSUS.json') + print('PASS_RANK7_SKIP_RESTORE_CENSUS deletions=212x2 exact=10 tail_exchanges=8098x2 negative=0 (%.1f s)' % (time.monotonic() - t0)) + + +if __name__ == '__main__': + main() diff --git a/research/rank7-skip-restore-optimum/certificates/BOUND-3042-base.json b/research/rank7-skip-restore-optimum/certificates/BOUND-3042-base.json new file mode 100644 index 0000000000..49ecc09cd8 --- /dev/null +++ b/research/rank7-skip-restore-optimum/certificates/BOUND-3042-base.json @@ -0,0 +1,6018 @@ +{ + "LB_forced": 10867765164, + "LB_profile": { + "1": 2370, + "2": 693, + "3": 255, + "4": 116, + "5": 18, + "8": 8 + }, + "blocked": 42, + "blocked_detail": { + "105": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 102, + 22, + 8, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 66, + 36, + 22, + 8 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 257, + 129, + 67, + 37, + 22, + 8 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ] + } + }, + "2": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + } + }, + "226": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 6, + "overhead": 4996, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + } + }, + "228": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 6, + "overhead": 4996, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + } + }, + "230": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 6, + "overhead": 4996, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + } + }, + "231": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + } + }, + "232": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + } + }, + "236": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + } + }, + "238": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + } + }, + "3": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 48, + 8, + 4, + 3 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 256, + 128, + 67, + 33, + 18, + 8, + 4 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 256, + 128, + 67, + 34, + 17, + 8, + 4 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "306": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 152, + 80, + 40, + 4, + 2, + 1 + ] + } + }, + "308": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 74, + 42, + 16, + 6, + 1 + ] + } + }, + "310": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 67, + 34, + 16, + 8, + 7 + ] + } + }, + "322": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 145, + 80, + 32, + 8, + 5, + 2 + ] + } + }, + "324": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 72, + 41, + 16, + 4, + 3 + ] + } + }, + "326": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 32, + 16, + 10, + 7 + ] + } + }, + "34": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 39, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 65, + 38, + 21, + 11 + ], + "why": "no register can sit at G" + }, + { + "Z": 8, + "frame": [ + 266, + 138, + 74, + 44, + 30, + 1 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + } + }, + "351": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 38, + 18, + 12, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 256, + 128, + 96, + 18, + 10, + 6, + 1 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "363": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 43, + 24, + 6 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 262, + 134, + 70, + 32, + 19, + 13 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 262, + 134, + 70, + 38, + 21, + 11 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + } + }, + "383": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "Z": 10, + "frame": [ + 256, + 128, + 67, + 33, + 18, + 8, + 4 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 259, + 131, + 64, + 34, + 17, + 11, + 7 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 260, + 132, + 68, + 37, + 21, + 12, + 3 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "395": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 37, + 22, + 8 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 259, + 131, + 67, + 37, + 22, + 8 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 320, + 192, + 37, + 21, + 8, + 3 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + } + }, + "408": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 66, + 36, + 30, + 1 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 257, + 129, + 67, + 37, + 22, + 8 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 257, + 129, + 67, + 37, + 23, + 9 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ] + } + }, + "412": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 131, + 65, + 36, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 259, + 131, + 65, + 39, + 20, + 10 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 292, + 128, + 65, + 20, + 9, + 3 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ] + } + }, + "414": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 164, + 65, + 20, + 9, + 3 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 259, + 128, + 65, + 36, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 259, + 131, + 65, + 39, + 20, + 10 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ] + } + }, + "424": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 130, + 65, + 37, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 258, + 128, + 65, + 37, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 384, + 65, + 37, + 20, + 8, + 2 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ] + } + }, + "428": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 100, + 28, + 2, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 72, + 44, + 28, + 2 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 257, + 129, + 73, + 45, + 28, + 2 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ] + } + }, + "430": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 72, + 46, + 30, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 73, + 44, + 29, + 3 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 257, + 129, + 73, + 45, + 28, + 2 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ] + } + }, + "434": { + "entry_dims": [ + 7, + 7 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "436": { + "entry_dims": [ + 7, + 7 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "438": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 32, + 24, + 6, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 256, + 128, + 70, + 32, + 20, + 10, + 1 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "439": { + "entry_dims": [ + 7, + 7 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "44": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 165, + 65, + 20, + 8, + 2 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 293, + 128, + 65, + 20, + 8, + 2 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 384, + 65, + 37, + 20, + 8, + 2 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ] + } + }, + "440": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 262, + 128, + 64, + 32, + 20, + 10, + 1 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "475": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 76, + 40, + 28, + 2, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 64, + 37, + 17, + 12, + 3 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 257, + 129, + 65, + 36, + 16, + 13, + 3 + ] + } + }, + "486": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 130, + 65, + 32, + 17, + 10, + 5 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 260, + 130, + 64, + 32, + 20, + 10, + 1 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 257, + 130, + 65, + 32, + 16, + 10, + 4 + ] + } + }, + "5": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 45, + 29, + 3 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 259, + 131, + 67, + 37, + 22, + 8 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 259, + 131, + 67, + 38, + 21, + 11 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + } + }, + "54": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 41, + 26, + 4 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 267, + 139, + 75, + 41, + 26, + 4 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 320, + 192, + 34, + 17, + 11, + 4 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + } + }, + "7": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + } + }, + "70": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + } + }, + "71": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + } + }, + "72": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + } + }, + "73": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 32, + 19, + 13 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 262, + 134, + 70, + 32, + 19, + 13 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 320, + 192, + 32, + 19, + 11, + 6 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + } + } + }, + "bound": 10868103087, + "caps": { + "103": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 230 + ] + }, + "105": { + "cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "receivers": [ + 408, + 573 + ] + }, + "108": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 228 + ] + }, + "16": { + "cap": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "receivers": [ + 424 + ] + }, + "18": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 226 + ] + }, + "2": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 230, + 251, + 265 + ] + }, + "22": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 331 + ] + }, + "226": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 449 + ] + }, + "228": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 230, + 451 + ] + }, + "23": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "receivers": [ + 511 + ] + }, + "230": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 450 + ] + }, + "231": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 448 + ] + }, + "232": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 452 + ] + }, + "236": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 454 + ] + }, + "238": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 455 + ] + }, + "249": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 230, + 267 + ] + }, + "251": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 265, + 267 + ] + }, + "265": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 230, + 251 + ] + }, + "267": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265 + ] + }, + "299": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 226, + 230, + 484 + ] + }, + "3": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 554 + ] + }, + "306": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 498, + 499 + ] + }, + "308": { + "cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "receivers": [ + 304, + 501 + ] + }, + "310": { + "cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "receivers": [ + 304, + 500 + ] + }, + "311": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 499 + ] + }, + "322": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "receivers": [ + 327, + 511 + ] + }, + "324": { + "cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "receivers": [ + 320, + 513 + ] + }, + "326": { + "cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "receivers": [ + 320, + 512 + ] + }, + "327": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "receivers": [ + 510, + 511 + ] + }, + "331": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 228, + 230, + 508 + ] + }, + "34": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 228, + 230, + 331, + 509 + ] + }, + "35": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 499 + ] + }, + "351": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 531 + ] + }, + "363": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 532 + ] + }, + "367": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 543 + ] + }, + "383": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 555 + ] + }, + "395": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 556 + ] + }, + "399": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 567 + ] + }, + "40": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 299 + ] + }, + "400": { + "cap": [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + "receivers": [ + 412 + ] + }, + "408": { + "cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "receivers": [ + 572 + ] + }, + "412": { + "cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "receivers": [ + 574 + ] + }, + "414": { + "cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "receivers": [ + 412, + 575 + ] + }, + "416": { + "cap": [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ], + "receivers": [ + 428 + ] + }, + "42": { + "cap": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "receivers": [ + 408 + ] + }, + "424": { + "cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "receivers": [ + 580 + ] + }, + "428": { + "cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "receivers": [ + 582 + ] + }, + "430": { + "cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "receivers": [ + 428, + 583 + ] + }, + "434": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 585 + ] + }, + "436": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 587 + ] + }, + "438": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 586 + ] + }, + "439": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 584 + ] + }, + "44": { + "cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "receivers": [ + 424, + 581 + ] + }, + "440": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 588 + ] + }, + "444": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 590 + ] + }, + "446": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 591 + ] + }, + "448": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 484 + ] + }, + "449": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 485 + ] + }, + "45": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 230 + ] + }, + "450": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 508 + ] + }, + "451": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 509 + ] + }, + "452": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 532 + ] + }, + "453": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 533 + ] + }, + "454": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 556 + ] + }, + "455": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 557 + ] + }, + "46": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 589 + ] + }, + "498": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 311 + ] + }, + "499": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 498 + ] + }, + "5": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 395, + 557 + ] + }, + "511": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "receivers": [ + 327 + ] + }, + "54": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 226, + 230, + 299, + 485 + ] + }, + "585": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 555 + ] + }, + "587": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 531 + ] + }, + "589": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 543 + ] + }, + "59": { + "cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "receivers": [ + 363 + ] + }, + "591": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 567 + ] + }, + "61": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 251 + ] + }, + "62": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249 + ] + }, + "63": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 267 + ] + }, + "69": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 566 + ] + }, + "7": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 453 + ] + }, + "70": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265, + 267 + ] + }, + "71": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 230, + 249, + 267 + ] + }, + "72": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265, + 267 + ] + }, + "73": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 363, + 533 + ] + }, + "92": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 230 + ] + }, + "94": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 265 + ] + }, + "96": { + "cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "receivers": [ + 395 + ] + } + }, + "certified_cost": 10868103087, + "certified_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "current_restore": { + "auditor": { + "dual": "PASS", + "forward": "PASS", + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD" + }, + "dirty": [], + "gates": 212, + "leaks": {}, + "targets_changed": [] + }, + "extras_blocked": 292959, + "extras_open": 44964, + "forced_caps": 88, + "frame_graph": { + "components": 210, + "largest_component": 94, + "variables": 743 + }, + "gap": 0, + "groups": [ + { + "members": [ + 0, + 2, + 61, + 62, + 63, + 70, + 71, + 72, + 76, + 94, + 233, + 235 + ], + "parts": [ + { + "kind": "lift", + "receiver": 230, + "region": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "source": 265 + }, + { + "kind": "lift", + "receiver": 230, + "region": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "source": 249 + } + ] + }, + { + "members": [ + 23, + 39 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 23 + } + ] + }, + { + "members": [ + 35, + 77 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 35 + } + ] + }, + { + "members": [ + 46, + 521 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 46 + } + ] + }, + { + "members": [ + 69 + ], + "parts": [ + { + "kind": "forced-visit", + "register": 69 + } + ] + }, + { + "members": [ + 367, + 496 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 367 + } + ] + }, + { + "members": [ + 399, + 472 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 399 + } + ] + }, + { + "members": [ + 444 + ], + "parts": [ + { + "kind": "forced-visit", + "register": 444 + } + ] + }, + { + "members": [ + 446, + 545 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 446 + } + ] + } + ], + "literal_visit_units": 337923, + "literal_visits": 51, + "normal45": { + "V45": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "entry_lower_bounds": { + "2": [ + 256, + 128, + 64, + 35, + 16, + 14 + ], + "249": [ + 256, + 139, + 64, + 40, + 16, + 5 + ], + "251": [ + 267, + 128, + 64, + 40, + 16, + 5 + ], + "265": [ + 256, + 128, + 64, + 40, + 27, + 5 + ], + "267": [ + 261, + 133, + 69, + 38, + 21, + 11 + ], + "70": [ + 272, + 128, + 80, + 35, + 11, + 5 + ], + "71": [ + 256, + 144, + 80, + 35, + 11, + 5 + ], + "72": [ + 320, + 192, + 35, + 16, + 11, + 5 + ] + }, + "visitors": [ + { + "beta": 6877, + "entry_lower": [ + 256, + 128, + 64, + 35, + 16, + 14 + ], + "receivers": [ + 230, + 251, + 265 + ], + "register": 2 + }, + { + "beta": 6877, + "entry_lower": [ + 272, + 128, + 80, + 35, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265, + 267 + ], + "register": 70 + }, + { + "beta": 6877, + "entry_lower": [ + 256, + 144, + 80, + 35, + 11, + 5 + ], + "receivers": [ + 230, + 249, + 267 + ], + "register": 71 + }, + { + "beta": 6877, + "entry_lower": [ + 320, + 192, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265, + 267 + ], + "register": 72 + } + ] + }, + "open_detail": { + "103": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "108": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "16": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "free": true + } + ] + }, + "18": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "22": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "free": true + } + ] + }, + "23": { + "kind": "zero-sum", + "rejected_skip_frames": [ + { + "frame": [ + 261, + 133, + 68, + 34, + 17, + 15 + ], + "why": "no reader at F" + } + ], + "skip_frames": [ + { + "carriers": [ + 39 + ], + "frame": [ + 256, + 128, + 65, + 34, + 17, + 10, + 5 + ], + "needy_receivers": [ + 511 + ] + } + ] + }, + "35": { + "kind": "zero-sum", + "rejected_skip_frames": [ + { + "frame": [ + 260, + 132, + 74, + 44, + 30, + 1 + ], + "why": "no reader at F" + } + ], + "skip_frames": [ + { + "carriers": [ + 77 + ], + "frame": [ + 256, + 128, + 74, + 40, + 26, + 4, + 1 + ], + "needy_receivers": [ + 499 + ] + } + ] + }, + "367": { + "kind": "zero-sum", + "rejected_skip_frames": [ + { + "frame": [ + 289, + 128, + 65, + 18, + 10, + 6 + ], + "why": "no reader at F" + } + ], + "skip_frames": [ + { + "carriers": [ + 496 + ], + "frame": [ + 257, + 128, + 65, + 32, + 18, + 10, + 6 + ], + "needy_receivers": [ + 543 + ] + } + ] + }, + "399": { + "kind": "zero-sum", + "rejected_skip_frames": [ + { + "frame": [ + 256, + 131, + 68, + 34, + 17, + 12 + ], + "why": "no reader at F" + } + ], + "skip_frames": [ + { + "carriers": [ + 472 + ], + "frame": [ + 256, + 131, + 64, + 34, + 17, + 8, + 4 + ], + "needy_receivers": [ + 567 + ] + } + ] + }, + "40": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "free": true + } + ] + }, + "400": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + "free": true + } + ] + }, + "416": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ], + "free": true + } + ] + }, + "42": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "free": true + } + ] + }, + "444": { + "kind": "forced-visit", + "rejected_skip_frames": [ + { + "Z": 2, + "frame": [ + 273, + 128, + 64, + 48, + 8, + 4, + 3 + ], + "why": "departure from F: M[O][Z] full column rank" + } + ] + }, + "446": { + "kind": "zero-sum", + "rejected_skip_frames": [], + "skip_frames": [ + { + "carriers": [ + 545 + ], + "frame": [ + 256, + 145, + 64, + 48, + 8, + 4, + 3 + ], + "needy_receivers": [ + 591 + ] + } + ] + }, + "45": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "46": { + "kind": "zero-sum", + "rejected_skip_frames": [], + "skip_frames": [ + { + "carriers": [ + 521 + ], + "frame": [ + 288, + 128, + 96, + 18, + 10, + 6, + 1 + ], + "needy_receivers": [ + 589 + ] + } + ] + }, + "59": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "free": true + } + ] + }, + "61": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "free": true + } + ] + }, + "62": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "free": true + } + ] + }, + "63": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "free": true + } + ] + }, + "69": { + "kind": "forced-visit", + "rejected_skip_frames": [ + { + "frame": [ + 259, + 128, + 68, + 34, + 17, + 12 + ], + "why": "no reader at F" + }, + { + "Z": 2, + "frame": [ + 259, + 128, + 64, + 34, + 17, + 8, + 4 + ], + "why": "departure from F: M[O][Z] full column rank" + } + ] + }, + "92": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "94": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "free": true + } + ] + }, + "96": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "free": true + } + ] + } + }, + "payer_groups": 9, + "restore_entry": { + "forced_coordinates_match_restore": true, + "live_registers": 632, + "rank": 632, + "restored_helpers": 91 + }, + "theorem": "For every exact restore-only rewrite of WORD-3042-base (A, B, warps, cut, corrections, compensation, start frames, helper ends and buffers fixed; any restore gate sequence; all frames re-solved; exact = PR2833 auditor), certified cost >= LB_forced + forced extras = 10868103087 = certified cost of WORD-3042-base.", + "visit_blocks": [ + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charges": { + "beta": 24, + "forced-visit": 2, + "zero-sum": 4 + }, + "registers": [ + 3, + 44, + 46, + 69, + 105, + 306, + 308, + 310, + 322, + 324, + 326, + 351, + 367, + 383, + 399, + 408, + 412, + 414, + 424, + 428, + 430, + 434, + 436, + 438, + 439, + 440, + 444, + 446, + 475, + 486 + ], + "units": 192384 + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charges": { + "beta": 14 + }, + "registers": [ + 5, + 7, + 34, + 54, + 73, + 226, + 228, + 230, + 231, + 232, + 236, + 238, + 363, + 395 + ], + "units": 103043 + }, + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charges": { + "beta": 4 + }, + "registers": [ + 2, + 70, + 71, + 72 + ], + "units": 27508 + }, + { + "block": "PR2908/PR2917 paired-extraction outputs", + "charges": { + "zero-sum": 2 + }, + "registers": [ + 23, + 35 + ], + "units": 9992 + }, + { + "block": "n42: PR2979 extraction + PR3042 R1_E42", + "charges": { + "lift": 1 + }, + "registers": [ + 61 + ], + "units": 4996 + } + ], + "visits": [ + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R142", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 230, + 251, + 265 + ], + "register": 2, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R68", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 554 + ], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 554 + ], + "register": 3, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R75", + 7, + 2 + ], + [ + "R211", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 395, + 557 + ], + "register": 5, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R30", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 453 + ], + "register": 7, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2908/PR2917 paired-extraction outputs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R112", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 510, + 511 + ], + "overhead": 4996, + "payer_group": [ + 23, + 39 + ], + "receivers": [ + 511 + ], + "register": 23, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R52", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 228, + 230, + 331, + 509 + ], + "register": 34, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2908/PR2917 paired-extraction outputs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R118", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 499 + ], + "overhead": 4996, + "payer_group": [ + 35, + 77 + ], + "receivers": [ + 499 + ], + "register": 35, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R7", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 424, + 581 + ], + "register": 44, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R89", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": [ + 46, + 521 + ], + "receivers": [ + 589 + ], + "register": 46, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R39", + 7, + 2 + ], + [ + "R187", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 226, + 230, + 299, + 485 + ], + "register": 54, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "n42: PR2979 extraction + PR3042 R1_E42", + "charge": "lift", + "entry_dim": 7, + "jumps": [ + [ + "R189", + 8, + 1 + ], + [ + "R190", + 9, + 1 + ] + ], + "leaks": [ + 251 + ], + "overhead": 4996, + "payer_group": [ + 0, + 2, + 61, + 62, + 63, + 70, + 71, + 72, + 76, + 94, + 233, + 235 + ], + "receivers": [ + 251 + ], + "register": 61, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "forced-visit", + "entry_dim": 7, + "jumps": [ + [ + "R77", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 566 + ], + "overhead": 4996, + "payer_group": [ + 69 + ], + "receivers": [ + 566 + ], + "register": 69, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R121", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 249, + 251, + 265, + 267 + ], + "register": 70, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R122", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 230, + 249, + 267 + ], + "register": 71, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R123", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 249, + 251, + 265, + 267 + ], + "register": 72, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R63", + 7, + 2 + ], + [ + "R203", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 363, + 533 + ], + "register": 73, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R1", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 408, + 573 + ], + "register": 105, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R22", + 7, + 1 + ], + [ + "R166", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 449 + ], + "register": 226, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R26", + 7, + 1 + ], + [ + "R179", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 230, + 451 + ], + "register": 228, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R24", + 7, + 1 + ], + [ + "R182", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 450 + ], + "register": 230, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R20", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 448 + ], + "register": 231, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R28", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 452 + ], + "register": 232, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R32", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 454 + ], + "register": 236, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R34", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 455 + ], + "register": 238, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R40", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 498 + ], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 498, + 499 + ], + "register": 306, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R48", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 304, + 501 + ], + "register": 308, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R47", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 304, + 500 + ], + "register": 310, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R15", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 327, + 511 + ], + "register": 322, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R56", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 320, + 513 + ], + "register": 324, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R55", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 320, + 512 + ], + "register": 326, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R57", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 531, + 587 + ], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 531 + ], + "register": 351, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R60", + 7, + 2 + ], + [ + "R198", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 532 + ], + "register": 363, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R64", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 543, + 589 + ], + "overhead": 4996, + "payer_group": [ + 367, + 496 + ], + "receivers": [ + 543 + ], + "register": 367, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R70", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 555, + 585 + ], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 555 + ], + "register": 383, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R74", + 7, + 2 + ], + [ + "R205", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 556 + ], + "register": 395, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R79", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 567, + 591 + ], + "overhead": 4996, + "payer_group": [ + 399, + 472 + ], + "receivers": [ + 567 + ], + "register": 399, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R0", + 7, + 2 + ], + [ + "R94", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 572 + ], + "register": 408, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R3", + 7, + 2 + ], + [ + "R101", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 574 + ], + "register": 412, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R4", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 412, + 575 + ], + "register": 414, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R6", + 7, + 2 + ], + [ + "R96", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 580 + ], + "register": 424, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R9", + 7, + 2 + ], + [ + "R98", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 582 + ], + "register": 428, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R10", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 428, + 583 + ], + "register": 430, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R83", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 585 + ], + "register": 434, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R86", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 587 + ], + "register": 436, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R85", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 586 + ], + "register": 438, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R82", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 584 + ], + "register": 439, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R88", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 588 + ], + "register": 440, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "forced-visit", + "entry_dim": 7, + "jumps": [ + [ + "R91", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": [ + 444 + ], + "receivers": [ + 590 + ], + "register": 444, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R92", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": [ + 446, + 545 + ], + "receivers": [ + 591 + ], + "register": 446, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R44", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 498 + ], + "overhead": 6877, + "payer_group": null, + "receivers": [], + "register": 475, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R54", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 510 + ], + "overhead": 6877, + "payer_group": null, + "receivers": [], + "register": 486, + "restored": false, + "verdict": "BLOCKED" + } + ], + "weights": { + "c1": 2116671, + "c2": 4228346, + "c3": 6338140, + "c4": 8446713, + "c5": 10554378, + "visit_unit": 4996 + }, + "word": "3042-base", + "word_sha256": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e" +} diff --git a/research/rank7-skip-restore-optimum/certificates/BOUND-3042-extra.json b/research/rank7-skip-restore-optimum/certificates/BOUND-3042-extra.json new file mode 100644 index 0000000000..e7893c6d97 --- /dev/null +++ b/research/rank7-skip-restore-optimum/certificates/BOUND-3042-extra.json @@ -0,0 +1,6018 @@ +{ + "LB_forced": 10867765164, + "LB_profile": { + "1": 2370, + "2": 693, + "3": 255, + "4": 116, + "5": 18, + "8": 8 + }, + "blocked": 42, + "blocked_detail": { + "105": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 102, + 22, + 8, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 66, + 36, + 22, + 8 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 257, + 129, + 67, + 37, + 22, + 8 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ] + } + }, + "2": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + } + }, + "226": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 6, + "overhead": 4996, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + } + }, + "228": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 6, + "overhead": 4996, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + } + }, + "230": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 6, + "overhead": 4996, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + } + }, + "231": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + } + }, + "232": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + } + }, + "236": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + } + }, + "238": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + } + }, + "3": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 48, + 8, + 4, + 3 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 256, + 128, + 67, + 33, + 18, + 8, + 4 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 256, + 128, + 67, + 34, + 17, + 8, + 4 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "306": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 152, + 80, + 40, + 4, + 2, + 1 + ] + } + }, + "308": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 74, + 42, + 16, + 6, + 1 + ] + } + }, + "310": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 67, + 34, + 16, + 8, + 7 + ] + } + }, + "322": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 145, + 80, + 32, + 8, + 5, + 2 + ] + } + }, + "324": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 72, + 41, + 16, + 4, + 3 + ] + } + }, + "326": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 32, + 16, + 10, + 7 + ] + } + }, + "34": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 39, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 65, + 38, + 21, + 11 + ], + "why": "no register can sit at G" + }, + { + "Z": 8, + "frame": [ + 266, + 138, + 74, + 44, + 30, + 1 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + } + }, + "351": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 38, + 18, + 12, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 256, + 128, + 96, + 18, + 10, + 6, + 1 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "363": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 43, + 24, + 6 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 262, + 134, + 70, + 32, + 19, + 13 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 262, + 134, + 70, + 38, + 21, + 11 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + } + }, + "383": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "Z": 10, + "frame": [ + 256, + 128, + 67, + 33, + 18, + 8, + 4 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 259, + 131, + 64, + 34, + 17, + 11, + 7 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 260, + 132, + 68, + 37, + 21, + 12, + 3 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "395": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 37, + 22, + 8 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 259, + 131, + 67, + 37, + 22, + 8 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 320, + 192, + 37, + 21, + 8, + 3 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + } + }, + "408": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 66, + 36, + 30, + 1 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 257, + 129, + 67, + 37, + 22, + 8 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 257, + 129, + 67, + 37, + 23, + 9 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ] + } + }, + "412": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 131, + 65, + 36, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 259, + 131, + 65, + 39, + 20, + 10 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 292, + 128, + 65, + 20, + 9, + 3 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ] + } + }, + "414": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 164, + 65, + 20, + 9, + 3 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 259, + 128, + 65, + 36, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 259, + 131, + 65, + 39, + 20, + 10 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ] + } + }, + "424": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 130, + 65, + 37, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 258, + 128, + 65, + 37, + 20, + 10 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 384, + 65, + 37, + 20, + 8, + 2 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ] + } + }, + "428": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 100, + 28, + 2, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 72, + 44, + 28, + 2 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 257, + 129, + 73, + 45, + 28, + 2 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ] + } + }, + "430": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 72, + 46, + 30, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 73, + 44, + 29, + 3 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 257, + 129, + 73, + 45, + 28, + 2 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ] + } + }, + "434": { + "entry_dims": [ + 7, + 7 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "436": { + "entry_dims": [ + 7, + 7 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "438": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 32, + 24, + 6, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 256, + 128, + 70, + 32, + 20, + 10, + 1 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "439": { + "entry_dims": [ + 7, + 7 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "three_or_more": null, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "44": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 165, + 65, + 20, + 8, + 2 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 293, + 128, + 65, + 20, + 8, + 2 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 384, + 65, + 37, + 20, + 8, + 2 + ], + "why": "departure from G: M[O][Z] full column rank" + } + ], + "first_frame_cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ] + } + }, + "440": { + "entry_dims": [ + 6, + 7 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 262, + 128, + 64, + 32, + 20, + 10, + 1 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 7, + "overhead": 4996, + "visit_dim": 8, + "visit_frame": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "475": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 76, + 40, + 28, + 2, + 1 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 257, + 129, + 64, + 37, + 17, + 12, + 3 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 257, + 129, + 65, + 36, + 16, + 13, + 3 + ] + } + }, + "486": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 130, + 65, + 32, + 17, + 10, + 5 + ], + "why": "no register can sit at G" + }, + { + "frame": [ + 260, + 130, + 64, + 32, + 20, + 10, + 1 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 257, + 130, + 65, + 32, + 16, + 10, + 4 + ] + } + }, + "5": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 45, + 29, + 3 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 259, + 131, + 67, + 37, + 22, + 8 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 259, + 131, + 67, + 38, + 21, + 11 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + } + }, + "54": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 41, + 26, + 4 + ], + "why": "no register can sit at G" + }, + { + "Z": 6, + "frame": [ + 267, + 139, + 75, + 41, + 26, + 4 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 320, + 192, + 34, + 17, + 11, + 4 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + } + }, + "7": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + } + }, + "70": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + } + }, + "71": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + } + }, + "72": { + "entry_dims": [ + 6, + 6 + ], + "excluded_two_jump_frames": [], + "first_frame_cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "three_or_more": { + "entry_dim": 6, + "jumps": [ + 1, + 1, + 1 + ], + "overhead": 11873 + }, + "two_jump": { + "entry_dim": 6, + "overhead": 6877, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + } + }, + "73": { + "entry_dims": [ + 5, + 5 + ], + "excluded_two_jump_frames": [ + { + "frame": [ + 256, + 128, + 64, + 32, + 19, + 13 + ], + "why": "no register can sit at G" + }, + { + "Z": 10, + "frame": [ + 262, + 134, + 70, + 32, + 19, + 13 + ], + "why": "departure from G: M[O][Z] full column rank" + }, + { + "frame": [ + 320, + 192, + 32, + 19, + 11, + 6 + ], + "why": "no register can sit at G" + } + ], + "first_frame_cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "three_or_more": { + "entry_dim": 5, + "jumps": [ + 1, + 1, + 2 + ], + "overhead": 14975 + }, + "two_jump": { + "entry_dim": 5, + "overhead": 9979, + "visit_dim": 7, + "visit_frame": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + } + } + }, + "bound": 10868103087, + "caps": { + "103": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 230 + ] + }, + "105": { + "cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "receivers": [ + 408, + 573 + ] + }, + "108": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 228 + ] + }, + "16": { + "cap": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "receivers": [ + 424 + ] + }, + "18": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 226 + ] + }, + "2": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 230, + 251, + 265 + ] + }, + "22": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 331 + ] + }, + "226": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 449 + ] + }, + "228": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 230, + 451 + ] + }, + "23": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "receivers": [ + 511 + ] + }, + "230": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 450 + ] + }, + "231": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 448 + ] + }, + "232": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 452 + ] + }, + "236": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 454 + ] + }, + "238": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 455 + ] + }, + "249": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 230, + 267 + ] + }, + "251": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 265, + 267 + ] + }, + "265": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 230, + 251 + ] + }, + "267": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265 + ] + }, + "299": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 226, + 230, + 484 + ] + }, + "3": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 554 + ] + }, + "306": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 498, + 499 + ] + }, + "308": { + "cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "receivers": [ + 304, + 501 + ] + }, + "310": { + "cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "receivers": [ + 304, + 500 + ] + }, + "311": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 499 + ] + }, + "322": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "receivers": [ + 327, + 511 + ] + }, + "324": { + "cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "receivers": [ + 320, + 513 + ] + }, + "326": { + "cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "receivers": [ + 320, + 512 + ] + }, + "327": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "receivers": [ + 510, + 511 + ] + }, + "331": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 228, + 230, + 508 + ] + }, + "34": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 228, + 230, + 331, + 509 + ] + }, + "35": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 499 + ] + }, + "351": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 531 + ] + }, + "363": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 532 + ] + }, + "367": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 543 + ] + }, + "383": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 555 + ] + }, + "395": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 556 + ] + }, + "399": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 567 + ] + }, + "40": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 299 + ] + }, + "400": { + "cap": [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + "receivers": [ + 412 + ] + }, + "408": { + "cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "receivers": [ + 572 + ] + }, + "412": { + "cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "receivers": [ + 574 + ] + }, + "414": { + "cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "receivers": [ + 412, + 575 + ] + }, + "416": { + "cap": [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ], + "receivers": [ + 428 + ] + }, + "42": { + "cap": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "receivers": [ + 408 + ] + }, + "424": { + "cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "receivers": [ + 580 + ] + }, + "428": { + "cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "receivers": [ + 582 + ] + }, + "430": { + "cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "receivers": [ + 428, + 583 + ] + }, + "434": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 585 + ] + }, + "436": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 587 + ] + }, + "438": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 586 + ] + }, + "439": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 584 + ] + }, + "44": { + "cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "receivers": [ + 424, + 581 + ] + }, + "440": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 588 + ] + }, + "444": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 590 + ] + }, + "446": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 591 + ] + }, + "448": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 484 + ] + }, + "449": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 485 + ] + }, + "45": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 230 + ] + }, + "450": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 508 + ] + }, + "451": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "receivers": [ + 509 + ] + }, + "452": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 532 + ] + }, + "453": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 533 + ] + }, + "454": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 556 + ] + }, + "455": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 557 + ] + }, + "46": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 589 + ] + }, + "498": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 311 + ] + }, + "499": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "receivers": [ + 498 + ] + }, + "5": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "receivers": [ + 395, + 557 + ] + }, + "511": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "receivers": [ + 327 + ] + }, + "54": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "receivers": [ + 226, + 230, + 299, + 485 + ] + }, + "585": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 555 + ] + }, + "587": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 531 + ] + }, + "589": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "receivers": [ + 543 + ] + }, + "59": { + "cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "receivers": [ + 363 + ] + }, + "591": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 567 + ] + }, + "61": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 251 + ] + }, + "62": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249 + ] + }, + "63": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 267 + ] + }, + "69": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "receivers": [ + 566 + ] + }, + "7": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 453 + ] + }, + "70": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265, + 267 + ] + }, + "71": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 230, + 249, + 267 + ] + }, + "72": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265, + 267 + ] + }, + "73": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "receivers": [ + 363, + 533 + ] + }, + "92": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "receivers": [ + 230 + ] + }, + "94": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 265 + ] + }, + "96": { + "cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "receivers": [ + 395 + ] + } + }, + "certified_cost": 10868103087, + "certified_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "current_restore": { + "auditor": { + "dual": "PASS", + "forward": "PASS", + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD" + }, + "dirty": [], + "gates": 212, + "leaks": {}, + "targets_changed": [] + }, + "extras_blocked": 292959, + "extras_open": 44964, + "forced_caps": 88, + "frame_graph": { + "components": 210, + "largest_component": 94, + "variables": 743 + }, + "gap": 0, + "groups": [ + { + "members": [ + 0, + 2, + 61, + 62, + 63, + 70, + 71, + 72, + 76, + 94, + 233, + 235 + ], + "parts": [ + { + "kind": "lift", + "receiver": 230, + "region": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "source": 265 + }, + { + "kind": "lift", + "receiver": 230, + "region": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "source": 249 + } + ] + }, + { + "members": [ + 23, + 39 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 23 + } + ] + }, + { + "members": [ + 35, + 77 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 35 + } + ] + }, + { + "members": [ + 46, + 521 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 46 + } + ] + }, + { + "members": [ + 69 + ], + "parts": [ + { + "kind": "forced-visit", + "register": 69 + } + ] + }, + { + "members": [ + 367, + 496 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 367 + } + ] + }, + { + "members": [ + 399, + 472 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 399 + } + ] + }, + { + "members": [ + 444 + ], + "parts": [ + { + "kind": "forced-visit", + "register": 444 + } + ] + }, + { + "members": [ + 446, + 545 + ], + "parts": [ + { + "kind": "zero-sum", + "register": 446 + } + ] + } + ], + "literal_visit_units": 337923, + "literal_visits": 51, + "normal45": { + "V45": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "entry_lower_bounds": { + "2": [ + 256, + 128, + 64, + 35, + 16, + 14 + ], + "249": [ + 256, + 139, + 64, + 40, + 16, + 5 + ], + "251": [ + 267, + 128, + 64, + 40, + 16, + 5 + ], + "265": [ + 256, + 128, + 64, + 40, + 27, + 5 + ], + "267": [ + 261, + 133, + 69, + 38, + 21, + 11 + ], + "70": [ + 272, + 128, + 80, + 35, + 11, + 5 + ], + "71": [ + 256, + 144, + 80, + 35, + 11, + 5 + ], + "72": [ + 320, + 192, + 35, + 16, + 11, + 5 + ] + }, + "visitors": [ + { + "beta": 6877, + "entry_lower": [ + 256, + 128, + 64, + 35, + 16, + 14 + ], + "receivers": [ + 230, + 251, + 265 + ], + "register": 2 + }, + { + "beta": 6877, + "entry_lower": [ + 272, + 128, + 80, + 35, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265, + 267 + ], + "register": 70 + }, + { + "beta": 6877, + "entry_lower": [ + 256, + 144, + 80, + 35, + 11, + 5 + ], + "receivers": [ + 230, + 249, + 267 + ], + "register": 71 + }, + { + "beta": 6877, + "entry_lower": [ + 320, + 192, + 35, + 16, + 11, + 5 + ], + "receivers": [ + 249, + 251, + 265, + 267 + ], + "register": 72 + } + ] + }, + "open_detail": { + "103": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "108": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "16": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "free": true + } + ] + }, + "18": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "22": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "free": true + } + ] + }, + "23": { + "kind": "zero-sum", + "rejected_skip_frames": [ + { + "frame": [ + 261, + 133, + 68, + 34, + 17, + 15 + ], + "why": "no reader at F" + } + ], + "skip_frames": [ + { + "carriers": [ + 39 + ], + "frame": [ + 256, + 128, + 65, + 34, + 17, + 10, + 5 + ], + "needy_receivers": [ + 511 + ] + } + ] + }, + "35": { + "kind": "zero-sum", + "rejected_skip_frames": [ + { + "frame": [ + 260, + 132, + 74, + 44, + 30, + 1 + ], + "why": "no reader at F" + } + ], + "skip_frames": [ + { + "carriers": [ + 77 + ], + "frame": [ + 256, + 128, + 74, + 40, + 26, + 4, + 1 + ], + "needy_receivers": [ + 499 + ] + } + ] + }, + "367": { + "kind": "zero-sum", + "rejected_skip_frames": [ + { + "frame": [ + 289, + 128, + 65, + 18, + 10, + 6 + ], + "why": "no reader at F" + } + ], + "skip_frames": [ + { + "carriers": [ + 496 + ], + "frame": [ + 257, + 128, + 65, + 32, + 18, + 10, + 6 + ], + "needy_receivers": [ + 543 + ] + } + ] + }, + "399": { + "kind": "zero-sum", + "rejected_skip_frames": [ + { + "frame": [ + 256, + 131, + 68, + 34, + 17, + 12 + ], + "why": "no reader at F" + } + ], + "skip_frames": [ + { + "carriers": [ + 472 + ], + "frame": [ + 256, + 131, + 64, + 34, + 17, + 8, + 4 + ], + "needy_receivers": [ + 567 + ] + } + ] + }, + "40": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "free": true + } + ] + }, + "400": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + "free": true + } + ] + }, + "416": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ], + "free": true + } + ] + }, + "42": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "free": true + } + ] + }, + "444": { + "kind": "forced-visit", + "rejected_skip_frames": [ + { + "Z": 2, + "frame": [ + 273, + 128, + 64, + 48, + 8, + 4, + 3 + ], + "why": "departure from F: M[O][Z] full column rank" + } + ] + }, + "446": { + "kind": "zero-sum", + "rejected_skip_frames": [], + "skip_frames": [ + { + "carriers": [ + 545 + ], + "frame": [ + 256, + 145, + 64, + 48, + 8, + 4, + 3 + ], + "needy_receivers": [ + 591 + ] + } + ] + }, + "45": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "46": { + "kind": "zero-sum", + "rejected_skip_frames": [], + "skip_frames": [ + { + "carriers": [ + 521 + ], + "frame": [ + 288, + 128, + 96, + 18, + 10, + 6, + 1 + ], + "needy_receivers": [ + 589 + ] + } + ] + }, + "59": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "free": true + } + ] + }, + "61": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "free": true + } + ] + }, + "62": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "free": true + } + ] + }, + "63": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "free": true + } + ] + }, + "69": { + "kind": "forced-visit", + "rejected_skip_frames": [ + { + "frame": [ + 259, + 128, + 68, + 34, + 17, + 12 + ], + "why": "no reader at F" + }, + { + "Z": 2, + "frame": [ + 259, + 128, + 64, + 34, + 17, + 8, + 4 + ], + "why": "departure from F: M[O][Z] full column rank" + } + ] + }, + "92": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "free": true + } + ] + }, + "94": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "free": true + } + ] + }, + "96": { + "kind": "free-skip", + "skip_frames": [ + { + "frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "free": true + } + ] + } + }, + "payer_groups": 9, + "restore_entry": { + "forced_coordinates_match_restore": true, + "live_registers": 632, + "rank": 632, + "restored_helpers": 91 + }, + "theorem": "For every exact restore-only rewrite of WORD-3042-extra (A, B, warps, cut, corrections, compensation, start frames, helper ends and buffers fixed; any restore gate sequence; all frames re-solved; exact = PR2833 auditor), certified cost >= LB_forced + forced extras = 10868103087 = certified cost of WORD-3042-extra.", + "visit_blocks": [ + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charges": { + "beta": 24, + "forced-visit": 2, + "zero-sum": 4 + }, + "registers": [ + 3, + 44, + 46, + 69, + 105, + 306, + 308, + 310, + 322, + 324, + 326, + 351, + 367, + 383, + 399, + 408, + 412, + 414, + 424, + 428, + 430, + 434, + 436, + 438, + 439, + 440, + 444, + 446, + 475, + 486 + ], + "units": 192384 + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charges": { + "beta": 14 + }, + "registers": [ + 5, + 7, + 34, + 54, + 73, + 226, + 228, + 230, + 231, + 232, + 236, + 238, + 363, + 395 + ], + "units": 103043 + }, + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charges": { + "beta": 4 + }, + "registers": [ + 2, + 70, + 71, + 72 + ], + "units": 27508 + }, + { + "block": "PR2908/PR2917 paired-extraction outputs", + "charges": { + "zero-sum": 2 + }, + "registers": [ + 23, + 35 + ], + "units": 9992 + }, + { + "block": "n42: PR2979 extraction + PR3042 R1_E42", + "charges": { + "lift": 1 + }, + "registers": [ + 61 + ], + "units": 4996 + } + ], + "visits": [ + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R142", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 230, + 251, + 265 + ], + "register": 2, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R68", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 554 + ], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 554 + ], + "register": 3, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R75", + 7, + 2 + ], + [ + "R211", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 395, + 557 + ], + "register": 5, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R30", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 453 + ], + "register": 7, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2908/PR2917 paired-extraction outputs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R112", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 510, + 511 + ], + "overhead": 4996, + "payer_group": [ + 23, + 39 + ], + "receivers": [ + 511 + ], + "register": 23, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R52", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 228, + 230, + 331, + 509 + ], + "register": 34, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2908/PR2917 paired-extraction outputs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R118", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 499 + ], + "overhead": 4996, + "payer_group": [ + 35, + 77 + ], + "receivers": [ + 499 + ], + "register": 35, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R7", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 424, + 581 + ], + "register": 44, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R89", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": [ + 46, + 521 + ], + "receivers": [ + 589 + ], + "register": 46, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R39", + 7, + 2 + ], + [ + "R187", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 226, + 230, + 299, + 485 + ], + "register": 54, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "n42: PR2979 extraction + PR3042 R1_E42", + "charge": "lift", + "entry_dim": 7, + "jumps": [ + [ + "R189", + 8, + 1 + ], + [ + "R190", + 9, + 1 + ] + ], + "leaks": [ + 251 + ], + "overhead": 4996, + "payer_group": [ + 0, + 2, + 61, + 62, + 63, + 70, + 71, + 72, + 76, + 94, + 233, + 235 + ], + "receivers": [ + 251 + ], + "register": 61, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "forced-visit", + "entry_dim": 7, + "jumps": [ + [ + "R77", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 566 + ], + "overhead": 4996, + "payer_group": [ + 69 + ], + "receivers": [ + 566 + ], + "register": 69, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R121", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 249, + 251, + 265, + 267 + ], + "register": 70, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R122", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 230, + 249, + 267 + ], + "register": 71, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "n45: PR2942 paired extraction, pivots 249/251/265/267 at V45", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R123", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 249, + 251, + 265, + 267 + ], + "register": 72, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R63", + 7, + 2 + ], + [ + "R203", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 363, + 533 + ], + "register": 73, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R1", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 408, + 573 + ], + "register": 105, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R22", + 7, + 1 + ], + [ + "R166", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 449 + ], + "register": 226, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R26", + 7, + 1 + ], + [ + "R179", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 230, + 451 + ], + "register": 228, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R24", + 7, + 1 + ], + [ + "R182", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 450 + ], + "register": 230, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R20", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 448 + ], + "register": 231, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R28", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 452 + ], + "register": 232, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R32", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 454 + ], + "register": 236, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R34", + 7, + 1 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 455 + ], + "register": 238, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R40", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 498 + ], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 498, + 499 + ], + "register": 306, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R48", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 304, + 501 + ], + "register": 308, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R47", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 304, + 500 + ], + "register": 310, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R15", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 327, + 511 + ], + "register": 322, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R56", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 320, + 513 + ], + "register": 324, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R55", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 320, + 512 + ], + "register": 326, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R57", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 531, + 587 + ], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 531 + ], + "register": 351, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R60", + 7, + 2 + ], + [ + "R198", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 532 + ], + "register": 363, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R64", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 543, + 589 + ], + "overhead": 4996, + "payer_group": [ + 367, + 496 + ], + "receivers": [ + 543 + ], + "register": 367, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R70", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 555, + 585 + ], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 555 + ], + "register": 383, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "stage-1 group gates (W_A..W_D)", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R74", + 7, + 2 + ], + [ + "R205", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 556 + ], + "register": 395, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R79", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 567, + 591 + ], + "overhead": 4996, + "payer_group": [ + 399, + 472 + ], + "receivers": [ + 567 + ], + "register": 399, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R0", + 7, + 2 + ], + [ + "R94", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 572 + ], + "register": 408, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R3", + 7, + 2 + ], + [ + "R101", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 574 + ], + "register": 412, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R4", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 412, + 575 + ], + "register": 414, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R6", + 7, + 2 + ], + [ + "R96", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 580 + ], + "register": 424, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R9", + 7, + 2 + ], + [ + "R98", + 8, + 1 + ] + ], + "leaks": [], + "overhead": 6877, + "payer_group": null, + "receivers": [ + 582 + ], + "register": 428, + "restored": true, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 5, + "jumps": [ + [ + "R10", + 7, + 2 + ], + [ + "end", + 9, + 2 + ] + ], + "leaks": [], + "overhead": 9979, + "payer_group": null, + "receivers": [ + 428, + 583 + ], + "register": 430, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R83", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 585 + ], + "register": 434, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R86", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 587 + ], + "register": 436, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R85", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 586 + ], + "register": 438, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R82", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 584 + ], + "register": 439, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 7, + "jumps": [ + [ + "R88", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": null, + "receivers": [ + 588 + ], + "register": 440, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "forced-visit", + "entry_dim": 7, + "jumps": [ + [ + "R91", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": [ + 444 + ], + "receivers": [ + 590 + ], + "register": 444, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "zero-sum", + "entry_dim": 7, + "jumps": [ + [ + "R92", + 8, + 1 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [], + "overhead": 4996, + "payer_group": [ + 446, + 545 + ], + "receivers": [ + 591 + ], + "register": 446, + "restored": false, + "verdict": "OPEN-forced" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R44", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 498 + ], + "overhead": 6877, + "payer_group": null, + "receivers": [], + "register": 475, + "restored": false, + "verdict": "BLOCKED" + }, + { + "block": "PR2857/PR2894 kernel-preload restore pairs", + "charge": "beta", + "entry_dim": 6, + "jumps": [ + [ + "R54", + 8, + 2 + ], + [ + "end", + 9, + 1 + ] + ], + "leaks": [ + 510 + ], + "overhead": 6877, + "payer_group": null, + "receivers": [], + "register": 486, + "restored": false, + "verdict": "BLOCKED" + } + ], + "weights": { + "c1": 2116671, + "c2": 4228346, + "c3": 6338140, + "c4": 8446713, + "c5": 10554378, + "visit_unit": 4996 + }, + "word": "3042-extra", + "word_sha256": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35" +} diff --git a/research/rank7-skip-restore-optimum/certificates/CALIBRATION-2979.json b/research/rank7-skip-restore-optimum/certificates/CALIBRATION-2979.json new file mode 100644 index 0000000000..b954d2b651 --- /dev/null +++ b/research/rank7-skip-restore-optimum/certificates/CALIBRATION-2979.json @@ -0,0 +1,120 @@ +{ + "base": { + "LB_forced": 10867765164, + "blocked_excess": { + "5": 4996, + "54": 4996, + "73": 4996 + }, + "bound": 10868103087, + "certified_cost": 10868133063, + "certified_profile": { + "1": 2445, + "2": 706, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "gap": 29976, + "group_excess": [ + { + "excess": 4996, + "forced": 4996, + "kinds": [ + "lift" + ], + "members_visiting": { + "61": 4996, + "63": 4996 + } + } + ], + "literal_visit_units": 367899, + "literal_visits": 54, + "pr3042_skips": [ + 5, + 22, + 40, + 54, + 63, + 73 + ], + "realized_by_pr3042": 29976, + "registers_involved": [ + 5, + 22, + 40, + 54, + 61, + 63, + 73 + ], + "uncharged_visits": { + "22": 4996, + "40": 4996 + }, + "unforced_total": 29976, + "word": "2979-base", + "word_sha256": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d" + }, + "extra": { + "LB_forced": 10867765164, + "blocked_excess": { + "5": 4996, + "54": 4996, + "73": 4996 + }, + "bound": 10868103087, + "certified_cost": 10868133063, + "certified_profile": { + "1": 2445, + "2": 706, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "gap": 29976, + "group_excess": [ + { + "excess": 4996, + "forced": 4996, + "kinds": [ + "lift" + ], + "members_visiting": { + "61": 4996, + "63": 4996 + } + } + ], + "literal_visit_units": 367899, + "literal_visits": 54, + "pr3042_skips": [ + 5, + 22, + 40, + 54, + 63, + 73 + ], + "realized_by_pr3042": 29976, + "registers_involved": [ + 5, + 22, + 40, + 54, + 61, + 63, + 73 + ], + "uncharged_visits": { + "22": 4996, + "40": 4996 + }, + "unforced_total": 29976, + "word": "2979-extra", + "word_sha256": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7" + } +} diff --git a/research/rank7-skip-restore-optimum/certificates/CENSUS.json b/research/rank7-skip-restore-optimum/certificates/CENSUS.json new file mode 100644 index 0000000000..830acc1068 --- /dev/null +++ b/research/rank7-skip-restore-optimum/certificates/CENSUS.json @@ -0,0 +1,300 @@ +{ + "base": { + "deletion": { + "deletions": 212, + "exact": 10, + "exact_deletions": [ + { + "deleted": 165, + "delta": 0, + "gate": [ + "add", + 40, + 226, + -1, + 1 + ] + }, + { + "deleted": 176, + "delta": 0, + "gate": [ + "add", + 230, + 22, + 1, + 1 + ] + }, + { + "deleted": 184, + "delta": 0, + "gate": [ + "add", + 40, + 18, + -1, + 1 + ] + }, + { + "deleted": 185, + "delta": 0, + "gate": [ + "add", + 18, + 40, + 1, + 1 + ] + }, + { + "deleted": 186, + "delta": 0, + "gate": [ + "add", + 40, + 18, + -1, + 1 + ] + }, + { + "deleted": 187, + "delta": 0, + "gate": [ + "add", + 40, + 54, + 2, + 1 + ] + }, + { + "deleted": 190, + "delta": 0, + "gate": [ + "add", + 61, + 63, + -1, + 1 + ] + }, + { + "deleted": 203, + "delta": 0, + "gate": [ + "add", + 59, + 73, + 1, + 1 + ] + }, + { + "deleted": 210, + "delta": 0, + "gate": [ + "scale", + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ] + }, + { + "deleted": 211, + "delta": 0, + "gate": [ + "add", + 5, + 96, + -1, + 1 + ] + } + ], + "min_delta": 0 + }, + "tail_exchange": { + "candidates": 8098, + "delta_histogram": { + "0": 316, + "11873": 20, + "13094": 20, + "14002": 36, + "3102": 10, + "4996": 280, + "6877": 268, + "8098": 40 + }, + "exact": 6378, + "frame_feasible": 990, + "infeasible": 5388, + "min_delta": 0, + "negative": 0, + "not_exact": 1720, + "sample_every": 25, + "sample_rechecked": 324 + } + }, + "extra": { + "deletion": { + "deletions": 212, + "exact": 10, + "exact_deletions": [ + { + "deleted": 165, + "delta": 0, + "gate": [ + "add", + 40, + 226, + -1, + 1 + ] + }, + { + "deleted": 176, + "delta": 0, + "gate": [ + "add", + 230, + 22, + 1, + 1 + ] + }, + { + "deleted": 184, + "delta": 0, + "gate": [ + "add", + 40, + 18, + -1, + 1 + ] + }, + { + "deleted": 185, + "delta": 0, + "gate": [ + "add", + 18, + 40, + 1, + 1 + ] + }, + { + "deleted": 186, + "delta": 0, + "gate": [ + "add", + 40, + 18, + -1, + 1 + ] + }, + { + "deleted": 187, + "delta": 0, + "gate": [ + "add", + 40, + 54, + 2, + 1 + ] + }, + { + "deleted": 190, + "delta": 0, + "gate": [ + "add", + 61, + 63, + -1, + 1 + ] + }, + { + "deleted": 203, + "delta": 0, + "gate": [ + "add", + 59, + 73, + 1, + 1 + ] + }, + { + "deleted": 210, + "delta": 0, + "gate": [ + "scale", + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ] + }, + { + "deleted": 211, + "delta": 0, + "gate": [ + "add", + 5, + 96, + -1, + 1 + ] + } + ], + "min_delta": 0 + }, + "tail_exchange": { + "candidates": 8098, + "delta_histogram": { + "0": 316, + "11873": 20, + "13094": 20, + "14002": 36, + "3102": 10, + "4996": 280, + "6877": 268, + "8098": 40 + }, + "exact": 6378, + "frame_feasible": 990, + "infeasible": 5388, + "min_delta": 0, + "negative": 0, + "not_exact": 1720, + "sample_every": 25, + "sample_rechecked": 324 + } + } +} diff --git a/research/rank7-skip-restore-optimum/certificates/CONTROLS.json b/research/rank7-skip-restore-optimum/certificates/CONTROLS.json new file mode 100644 index 0000000000..1b52929306 --- /dev/null +++ b/research/rank7-skip-restore-optimum/certificates/CONTROLS.json @@ -0,0 +1,378 @@ +{ + "ablation": { + "admitted": [ + { + "beta": 9979, + "frame": [ + 259, + 131, + 67, + 37, + 22, + 8 + ], + "overhead": 8098, + "register": 5 + }, + { + "beta": 9979, + "frame": [ + 266, + 138, + 74, + 44, + 30, + 1 + ], + "overhead": 8098, + "register": 34 + }, + { + "beta": 9979, + "frame": [ + 384, + 65, + 37, + 20, + 8, + 2 + ], + "overhead": 8098, + "register": 44 + }, + { + "beta": 9979, + "frame": [ + 267, + 139, + 75, + 41, + 26, + 4 + ], + "overhead": 8098, + "register": 54 + }, + { + "beta": 9979, + "frame": [ + 262, + 134, + 70, + 32, + 19, + 13 + ], + "overhead": 8098, + "register": 73 + }, + { + "beta": 9979, + "frame": [ + 257, + 129, + 67, + 37, + 22, + 8 + ], + "overhead": 8098, + "register": 105 + }, + { + "beta": 9979, + "frame": [ + 259, + 131, + 65, + 39, + 20, + 10 + ], + "overhead": 8098, + "register": 414 + }, + { + "beta": 9979, + "frame": [ + 257, + 129, + 73, + 45, + 28, + 2 + ], + "overhead": 8098, + "register": 430 + } + ], + "bound": 10868088039, + "drop": 15048, + "registers": [ + 5, + 34, + 44, + 54, + 73, + 105, + 414, + 430 + ] + }, + "attainment": [ + { + "auditor": { + "dual": "PASS", + "forward": "PASS", + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD" + }, + "control": "PR3056 three-ADD contraction of restore[175:179]", + "delta": 0, + "dirty": 0, + "exact": true, + "feasible": true, + "gates": 211, + "leaks": 0, + "profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + } + }, + { + "auditor": { + "dual": "PASS", + "forward": "PASS", + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD" + }, + "control": "PR3060 four-gate tariff word of restore[175:179]", + "delta": 0, + "dirty": 0, + "exact": true, + "feasible": true, + "gates": 212, + "leaks": 0, + "profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + } + } + ], + "auditor_semantics": [ + { + "appended": [ + "add", + 0, + 1, + 1, + 1 + ], + "auditor": { + "dual": "PASS", + "forward": "PASS", + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD" + }, + "delta": 0, + "dirty": 0, + "exact": true, + "feasible": true, + "leaks": 0, + "profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + } + }, + { + "appended": [ + "add", + 62, + 70, + 1, + 1 + ], + "auditor": { + "dual": "PASS", + "forward": "PASS", + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD" + }, + "delta": 0, + "dirty": 0, + "exact": true, + "feasible": true, + "leaks": 0, + "profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + } + }, + { + "appended": [ + "add", + 249, + 251, + 1, + 1 + ], + "auditor": { + "reason": "restored cold row is not its own input 249", + "status": "FAIL" + }, + "delta": 0, + "dirty": 1, + "exact": false, + "feasible": true, + "leaks": 1, + "profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + } + } + ], + "empty_restore_word_bound": { + "bound": 10868103087, + "forced_caps": 88 + }, + "fake_cheaper_restores": [ + { + "auditor": { + "reason": "restored cold row is not its own input 512", + "status": "FAIL" + }, + "control": "empty restore", + "delta": -499481, + "dirty": 65, + "exact": false, + "feasible": true, + "leaks": 39, + "profile": { + "1": 2367, + "2": 663, + "3": 256, + "4": 131, + "5": 18, + "8": 8 + } + }, + { + "auditor": { + "reason": "restored cold input still read by 498", + "status": "FAIL" + }, + "control": "deleted R44 475 += -1/2*498 (keeps a restored input in 475)", + "delta": -6877, + "dirty": 0, + "exact": false, + "feasible": true, + "leaks": 1, + "profile": { + "1": 2432, + "2": 711, + "3": 233, + "4": 108, + "5": 18, + "8": 8 + } + }, + { + "auditor": { + "reason": "restored cold row is not its own input 584", + "status": "FAIL" + }, + "control": "deleted R82 584 += -1*439 (restored 584 not its own input)", + "delta": -4996, + "dirty": 1, + "exact": false, + "feasible": true, + "leaks": 0, + "profile": { + "1": 2431, + "2": 713, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + } + } + ], + "rejection": [ + { + "control": "mislabeled provider (extra export under the base pin)", + "reason": "pinned export mismatch", + "rejected": true + }, + { + "control": "one flipped byte in the base export", + "reason": "pinned export mismatch", + "rejected": true + }, + { + "control": "certificate with the cap of register 2 dropped (LB 10867757066)", + "reason": "tight sum fails without the cap", + "rejected": true + }, + { + "control": "certificate with the forced visit of register 44 dropped", + "reason": "tight sum fails", + "rejected": true + }, + { + "control": "perturbed restore-entry row of register 70", + "reason": "restore does not realize the perturbed coordinates", + "rejected": true + }, + { + "control": "fake cheaper restore: empty restore (delta -499481)", + "reason": "Lemma 1 end conditions fail (65 dirty restored, 39 leaks); auditor: restored cold row is not its own input 512", + "rejected": true + }, + { + "control": "fake cheaper restore: deleted R44 475 += -1/2*498 (keeps a restored input in 475) (delta -6877)", + "reason": "Lemma 1 end conditions fail (0 dirty restored, 1 leaks); auditor: restored cold input still read by 498", + "rejected": true + }, + { + "control": "fake cheaper restore: deleted R82 584 += -1*439 (restored 584 not its own input) (delta -4996)", + "reason": "Lemma 1 end conditions fail (1 dirty restored, 0 leaks); auditor: restored cold row is not its own input 584", + "rejected": true + }, + { + "control": "claimed cost 10,868,103,086", + "reason": "recomputed certified cost differs", + "rejected": true + }, + { + "control": "optimality claimed for PR2979 base", + "reason": "PR2979 gap 29,976", + "rejected": true + }, + { + "control": "departure lemma with rows restricted to receivers containing the frame (bound 10868088039)", + "reason": "the restricted lemma no longer certifies optimality", + "rejected": true + }, + { + "control": "caps from the restore map of the emptied word (0 caps)", + "reason": "no caps", + "rejected": true + } + ] +} diff --git a/research/rank7-skip-restore-optimum/certificates/ERRATUM-3042.json b/research/rank7-skip-restore-optimum/certificates/ERRATUM-3042.json new file mode 100644 index 0000000000..41476ff12a --- /dev/null +++ b/research/rank7-skip-restore-optimum/certificates/ERRATUM-3042.json @@ -0,0 +1,77 @@ +{ + "certified": { + "R1_E42": { + "delta_units": -19984, + "literal_skip_units": 19984, + "profile_delta": { + "1": -8, + "2": 4 + }, + "skipped_registers": [ + 22, + 40, + 54, + 63 + ] + }, + "R1_E42+R2_E7": { + "delta_units": -29976, + "literal_skip_units": 29976, + "profile_delta": { + "1": -12, + "2": 6 + }, + "skipped_registers": [ + 5, + 22, + 40, + 54, + 63, + 73 + ] + }, + "R2_E7": { + "delta_units": -9992, + "literal_skip_units": 9992, + "profile_delta": { + "1": -4, + "2": 2 + }, + "skipped_registers": [ + 5, + 73 + ] + } + }, + "corrections": { + "R1_E42": "-19,984 units/call (four skips: 63, 54, 40, 22; -8 H1 + 4 H2), not -14,888 for 63, 54, 40", + "R2_E7": "-9,992 units/call (two skips: 73, 5; -4 H1 + 2 H2), not -14,938 for 22, 73, 5", + "total": "-29,976 units/call (-12 H1 + 6 H2 = 6 x 4,996), not -29,826; final words, profile and kappa unaffected" + }, + "declared_block_gates": { + "R1_E42": "26 -> 33", + "R2_E7": "13 -> 15" + }, + "pr3042_readme": { + "R1_E42": { + "gates": "26 -> 29", + "registers": [ + 63, + 54, + 40 + ], + "units": -14888 + }, + "R2_E7": { + "gates": "13 -> 14", + "registers": [ + 22, + 73, + 5 + ], + "units": -14938 + }, + "total": -29826 + }, + "providers_identical": true +} diff --git a/research/rank7-skip-restore-optimum/certificates/RESULT.json b/research/rank7-skip-restore-optimum/certificates/RESULT.json new file mode 100644 index 0000000000..0f6f6c8f40 --- /dev/null +++ b/research/rank7-skip-restore-optimum/certificates/RESULT.json @@ -0,0 +1,21 @@ +{ + "LB_forced": 10867765164, + "blocked": 42, + "calibration_gap_2979": 29976, + "certificates": { + "BOUND-3042-base.json": "10922a932f51dac4021ea8d6a09b47b3bf0b8e278b77824a79bcf842d4929ebf", + "BOUND-3042-extra.json": "e75d625fede24fbc712f37f9f11269a418ef643703efc2e253a6005fd226a4db", + "CALIBRATION-2979.json": "68be5cf24d945ad0c16c7a55ccc655b0ea3c3ffc92c1d6a312200260247f4619", + "CONTROLS.json": "b6e91b1c67e425f3255874579b038e3c8ebb7ac926dae7f0e87e63d3db8748b2", + "ERRATUM-3042.json": "e2ac9e3af74a77574d2ec8afb4a5c2c0197c048f59bad1d2b8b4b65c613e0dd6" + }, + "certified_cost": 10868103087, + "forced_caps": 88, + "forced_extras": 337923, + "no_new_kappa": true, + "payer_groups": 9, + "pinned_inputs": 9, + "providers": 2, + "rejection_controls": 12, + "status": "PASS_RANK7_SKIP_RESTORE_OPTIMUM" +} diff --git a/research/rank7-skip-restore-optimum/data/EDITS-3042.json b/research/rank7-skip-restore-optimum/data/EDITS-3042.json new file mode 100644 index 0000000000..c2042a37bd --- /dev/null +++ b/research/rank7-skip-restore-optimum/data/EDITS-3042.json @@ -0,0 +1,2984 @@ +{ + "declared": { + "local_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + } + }, + "edits": { + "base": [ + { + "id": "R1_E42", + "new": [ + [ + "add", + 40, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 226, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 18, + 226, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 228, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 54, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 61, + 63, + 1, + 1, + [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + ], + [ + "add", + 230, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 61, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 230, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 230, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "old": [ + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "section": "restore", + "start": 162, + "stop": 188 + }, + { + "id": "R2_E7", + "new": [ + [ + "add", + 363, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + 1, + 4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 96, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "old": [ + [ + "add", + 59, + 73, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 5, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -4, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ] + ], + "section": "restore", + "start": 190, + "stop": 203 + } + ], + "extra": [ + { + "id": "R1_E42", + "new": [ + [ + "add", + 40, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 226, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 18, + 226, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 228, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 54, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 61, + 63, + 1, + 1, + [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + ], + [ + "add", + 230, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 61, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 230, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 230, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "old": [ + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "section": "restore", + "start": 162, + "stop": 188 + }, + { + "id": "R2_E7", + "new": [ + [ + "add", + 363, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + 1, + 4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 96, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "old": [ + [ + "add", + 59, + 73, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 5, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -4, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ] + ], + "section": "restore", + "start": 190, + "stop": 203 + } + ] + } +} \ No newline at end of file diff --git a/research/rank7-skip-restore-optimum/data/WORD-2979-base.json.gz b/research/rank7-skip-restore-optimum/data/WORD-2979-base.json.gz new file mode 100644 index 0000000000..d9aa96a93f Binary files /dev/null and b/research/rank7-skip-restore-optimum/data/WORD-2979-base.json.gz differ diff --git a/research/rank7-skip-restore-optimum/data/WORD-2979-extra.json.gz b/research/rank7-skip-restore-optimum/data/WORD-2979-extra.json.gz new file mode 100644 index 0000000000..74f6cb6459 Binary files /dev/null and b/research/rank7-skip-restore-optimum/data/WORD-2979-extra.json.gz differ diff --git a/research/rank7-skip-restore-optimum/data/WORD-3042-base.json.gz b/research/rank7-skip-restore-optimum/data/WORD-3042-base.json.gz new file mode 100644 index 0000000000..2ee02e318c Binary files /dev/null and b/research/rank7-skip-restore-optimum/data/WORD-3042-base.json.gz differ diff --git a/research/rank7-skip-restore-optimum/data/WORD-3042-extra.json.gz b/research/rank7-skip-restore-optimum/data/WORD-3042-extra.json.gz new file mode 100644 index 0000000000..33ba5f3499 Binary files /dev/null and b/research/rank7-skip-restore-optimum/data/WORD-3042-extra.json.gz differ diff --git a/research/rank7-skip-restore-optimum/evidence/laneK/AUDITOR-SEMANTICS.json b/research/rank7-skip-restore-optimum/evidence/laneK/AUDITOR-SEMANTICS.json new file mode 100644 index 0000000000..e54f48a78c --- /dev/null +++ b/research/rank7-skip-restore-optimum/evidence/laneK/AUDITOR-SEMANTICS.json @@ -0,0 +1,28 @@ +{ + "test": "append a FULL-frame gate between two non-restored registers at the end of restore (changes their final rows); re-derive frames + cleanup; PR2833 auditor", + "results": [ + { + "gate": [ + "add", + 0, + 1, + 1, + 1 + ], + "audit": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "cost_delta": 0 + }, + { + "gate": [ + "add", + 62, + 70, + 1, + 1 + ], + "audit": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "cost_delta": 0 + } + ], + "conclusion": "non-restored final rows are free at the end of restore; exactness = restored helpers own input + no restored input leaked + targets untouched" +} \ No newline at end of file diff --git a/research/rank7-skip-restore-optimum/evidence/laneK/CROSSCHECK.json b/research/rank7-skip-restore-optimum/evidence/laneK/CROSSCHECK.json new file mode 100644 index 0000000000..46f47ee26c --- /dev/null +++ b/research/rank7-skip-restore-optimum/evidence/laneK/CROSSCHECK.json @@ -0,0 +1,233 @@ +{ + "laneK_files": { + "bound.py": "6b1479b436c4f01bb32f771aa06af3d2260adee5dd5a5e2bf568b0192cee69d8", + "lbforced.py": "bd81e3f4460f61ef81e15e76ab25be5f8a9d7b71bb7dcbbf7a87873ca5398341" + }, + "rows": [ + { + "agree": true, + "laneK_LB_forced": 10867765164, + "laneK_blocked": [ + 42, + 292959 + ], + "laneK_bound": 10868103087, + "laneK_caps": 88, + "laneK_lb_forced_direct": 10867765164, + "laneK_open": [ + 9, + 44964 + ], + "package_LB_forced": 10867765164, + "package_blocked": [ + 42, + 292959 + ], + "package_bound": 10868103087, + "package_caps": 88, + "package_groups": [ + 9, + 44964 + ], + "variant": "word", + "word": "3042-base" + }, + { + "agree": true, + "laneK_LB_forced": 10867765164, + "laneK_blocked": [ + 42, + 292959 + ], + "laneK_bound": 10868103087, + "laneK_caps": 88, + "laneK_lb_forced_direct": 10867765164, + "laneK_open": [ + 9, + 44964 + ], + "package_LB_forced": 10867765164, + "package_blocked": [ + 42, + 292959 + ], + "package_bound": 10868103087, + "package_caps": 88, + "package_groups": [ + 9, + 44964 + ], + "variant": "emptied-restore", + "word": "3042-base" + }, + { + "agree": true, + "laneK_LB_forced": 10867765164, + "laneK_blocked": [ + 42, + 292959 + ], + "laneK_bound": 10868103087, + "laneK_caps": 88, + "laneK_lb_forced_direct": 10867765164, + "laneK_open": [ + 9, + 44964 + ], + "package_LB_forced": 10867765164, + "package_blocked": [ + 42, + 292959 + ], + "package_bound": 10868103087, + "package_caps": 88, + "package_groups": [ + 9, + 44964 + ], + "variant": "word", + "word": "3042-extra" + }, + { + "agree": true, + "laneK_LB_forced": 10867765164, + "laneK_blocked": [ + 42, + 292959 + ], + "laneK_bound": 10868103087, + "laneK_caps": 88, + "laneK_lb_forced_direct": 10867765164, + "laneK_open": [ + 9, + 44964 + ], + "package_LB_forced": 10867765164, + "package_blocked": [ + 42, + 292959 + ], + "package_bound": 10868103087, + "package_caps": 88, + "package_groups": [ + 9, + 44964 + ], + "variant": "emptied-restore", + "word": "3042-extra" + }, + { + "agree": true, + "laneK_LB_forced": 10867765164, + "laneK_blocked": [ + 42, + 292959 + ], + "laneK_bound": 10868103087, + "laneK_caps": 88, + "laneK_lb_forced_direct": 10867765164, + "laneK_open": [ + 9, + 44964 + ], + "package_LB_forced": 10867765164, + "package_blocked": [ + 42, + 292959 + ], + "package_bound": 10868103087, + "package_caps": 88, + "package_groups": [ + 9, + 44964 + ], + "variant": "word", + "word": "2979-base" + }, + { + "agree": true, + "laneK_LB_forced": 10867765164, + "laneK_blocked": [ + 42, + 292959 + ], + "laneK_bound": 10868103087, + "laneK_caps": 88, + "laneK_lb_forced_direct": 10867765164, + "laneK_open": [ + 9, + 44964 + ], + "package_LB_forced": 10867765164, + "package_blocked": [ + 42, + 292959 + ], + "package_bound": 10868103087, + "package_caps": 88, + "package_groups": [ + 9, + 44964 + ], + "variant": "emptied-restore", + "word": "2979-base" + }, + { + "agree": true, + "laneK_LB_forced": 10867765164, + "laneK_blocked": [ + 42, + 292959 + ], + "laneK_bound": 10868103087, + "laneK_caps": 88, + "laneK_lb_forced_direct": 10867765164, + "laneK_open": [ + 9, + 44964 + ], + "package_LB_forced": 10867765164, + "package_blocked": [ + 42, + 292959 + ], + "package_bound": 10868103087, + "package_caps": 88, + "package_groups": [ + 9, + 44964 + ], + "variant": "word", + "word": "2979-extra" + }, + { + "agree": true, + "laneK_LB_forced": 10867765164, + "laneK_blocked": [ + 42, + 292959 + ], + "laneK_bound": 10868103087, + "laneK_caps": 88, + "laneK_lb_forced_direct": 10867765164, + "laneK_open": [ + 9, + 44964 + ], + "package_LB_forced": 10867765164, + "package_blocked": [ + 42, + 292959 + ], + "package_bound": 10868103087, + "package_caps": 88, + "package_groups": [ + 9, + 44964 + ], + "variant": "emptied-restore", + "word": "2979-extra" + } + ], + "status": "PASS_LANEK_CROSSCHECK" +} diff --git a/research/rank7-skip-restore-optimum/evidence/laneK/FULLAB-SUMMARY.json b/research/rank7-skip-restore-optimum/evidence/laneK/FULLAB-SUMMARY.json new file mode 100644 index 0000000000..30325390a7 --- /dev/null +++ b/research/rank7-skip-restore-optimum/evidence/laneK/FULLAB-SUMMARY.json @@ -0,0 +1,108 @@ +{ + "word": "WORD-3042-base", + "current_cost": 10868103087, + "rw_single_moves": { + "candidates": 25846, + "feasible": 22354, + "infeasible": 3492, + "errors": {}, + "other": {}, + "gap_histogram": { + "-15635": 17, + "-13754": 2, + "-6877": 14, + "-4996": 3, + "-3102": 11, + "0": 22307 + }, + "gap_positive": [], + "best_gap": 0, + "by_class": { + "A->A feasible": 20166, + "A->A infeasible": 1194, + "B->B feasible": 2188, + "B->B infeasible": 2233, + "R->B infeasible": 65 + }, + "excluded_invalid": [ + { + "ref": "B1865", + "gate": [ + "add", + 149, + 297, + -2, + 1 + ], + "to": [ + "B1873", + "after" + ], + "sec": "R", + "coef": "-2", + "bound": 10868093095, + "gap": 9992, + "dLB": -9992, + "dB": 0, + "dO": 0, + "reason": "target write landing in the restore (auditor: restoration writes only non-targets); its bound drop is an artifact of the empty-restore relaxation dropping a target write" + } + ] + }, + "read_splits_2to3": { + "candidates": 6387, + "feasible": 4894, + "infeasible": 1493, + "errors": {}, + "other": {}, + "gap_histogram": { + "-15635": 4, + "-11200": 4, + "-8098": 4, + "-6877": 2, + "-4996": 10, + "0": 4870 + }, + "gap_positive": [], + "best_gap": 0 + }, + "write_sinks": { + "candidates": 640, + "feasible": 66, + "infeasible": 444, + "errors": { + "RuntimeError('self add')": 118, + "ValueError(('target outside span', 531, ": 2, + "ValueError(('target outside span', 543, ": 1, + "ValueError(('target outside span', 554, ": 2, + "ValueError(('target outside span', 555, ": 1, + "ValueError(('target outside span', 557, ": 2, + "ValueError(('target outside span', 566, ": 2, + "ValueError(('target outside span', 567, ": 2 + }, + "other": {}, + "gap_histogram": { + "-11873": 58, + "-8098": 2, + "-4996": 2, + "0": 4 + }, + "gap_positive": [], + "best_gap": 0 + }, + "adjacent_pairs": { + "candidates": 350, + "feasible": 224, + "infeasible": 126, + "errors": {}, + "other": {}, + "gap_histogram": { + "-3102": 8, + "0": 216 + }, + "gap_positive": [], + "best_gap": 0 + }, + "lanef_merges_3to2": "99 legal (84 A, 15 B), 93 feasible, all gap 0 (out/AB/merge-ab-base.jsonl, complete over A and B)", + "note": "bound.py fix during this run: lb_forced now takes the caller-supplied M (the sink census had computed caps from an empty restore; the first 125 sink records were discarded and the census rerun). The move and split censuses were unaffected (their restore map equals the supplied M)." +} \ No newline at end of file diff --git a/research/rank7-skip-restore-optimum/evidence/laneK/NEGATIVE-3042-base.json b/research/rank7-skip-restore-optimum/evidence/laneK/NEGATIVE-3042-base.json new file mode 100644 index 0000000000..4bee0ed568 --- /dev/null +++ b/research/rank7-skip-restore-optimum/evidence/laneK/NEGATIVE-3042-base.json @@ -0,0 +1,1441 @@ +{ + "word": "3042-base", + "certified_cost": 10868103087, + "certified_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "LB_forced": 10867765164, + "LB_certified": true, + "LB_profile": { + "1": 2370, + "2": 693, + "3": 255, + "4": 116, + "5": 18, + "8": 8 + }, + "forced_caps": 88, + "visits": 51, + "sum_forced_extras": 337923, + "LB_plus_forced": 10868103087, + "equals_current": true, + "blocked": 42, + "blocked_units": 292959, + "open_but_forced": 9, + "open_units": 44964, + "exchange_census": { + "priced": 990, + "negative": 0, + "min_delta": 0 + }, + "caps": { + "2": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 230, + 251, + 265 + ] + }, + "3": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 554 + ] + }, + "5": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 395, + 557 + ] + }, + "7": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 453 + ] + }, + "16": { + "cap": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 424 + ] + }, + "18": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 226 + ] + }, + "22": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 331 + ] + }, + "23": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "dim": 8, + "receivers": [ + 511 + ] + }, + "34": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 228, + 230, + 331, + 509 + ] + }, + "35": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 499 + ] + }, + "40": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 299 + ] + }, + "42": { + "cap": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 408 + ] + }, + "44": { + "cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "dim": 7, + "receivers": [ + 424, + 581 + ] + }, + "45": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 230 + ] + }, + "46": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 589 + ] + }, + "54": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 226, + 230, + 299, + 485 + ] + }, + "59": { + "cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "dim": 8, + "receivers": [ + 363 + ] + }, + "61": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 251 + ] + }, + "62": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249 + ] + }, + "63": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 267 + ] + }, + "69": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 566 + ] + }, + "70": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249, + 251, + 265, + 267 + ] + }, + "71": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 230, + 249, + 267 + ] + }, + "72": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249, + 251, + 265, + 267 + ] + }, + "73": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 363, + 533 + ] + }, + "92": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 230 + ] + }, + "94": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 265 + ] + }, + "96": { + "cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "dim": 8, + "receivers": [ + 395 + ] + }, + "103": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 230 + ] + }, + "105": { + "cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "dim": 7, + "receivers": [ + 408, + 573 + ] + }, + "108": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 228 + ] + }, + "226": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 449 + ] + }, + "228": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 230, + 451 + ] + }, + "230": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 450 + ] + }, + "231": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 448 + ] + }, + "232": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 452 + ] + }, + "236": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 454 + ] + }, + "238": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 455 + ] + }, + "249": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 230, + 267 + ] + }, + "251": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249, + 265, + 267 + ] + }, + "265": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 230, + 251 + ] + }, + "267": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249, + 251, + 265 + ] + }, + "299": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 226, + 230, + 484 + ] + }, + "306": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 498, + 499 + ] + }, + "308": { + "cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 304, + 501 + ] + }, + "310": { + "cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 304, + 500 + ] + }, + "311": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 499 + ] + }, + "322": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "dim": 8, + "receivers": [ + 327, + 511 + ] + }, + "324": { + "cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 320, + 513 + ] + }, + "326": { + "cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 320, + 512 + ] + }, + "327": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "dim": 8, + "receivers": [ + 510, + 511 + ] + }, + "331": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 228, + 230, + 508 + ] + }, + "351": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 531 + ] + }, + "363": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 532 + ] + }, + "367": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 543 + ] + }, + "383": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 555 + ] + }, + "395": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 556 + ] + }, + "399": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 567 + ] + }, + "400": { + "cap": [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + "dim": 8, + "receivers": [ + 412 + ] + }, + "408": { + "cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "dim": 7, + "receivers": [ + 572 + ] + }, + "412": { + "cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "dim": 7, + "receivers": [ + 574 + ] + }, + "414": { + "cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "dim": 7, + "receivers": [ + 412, + 575 + ] + }, + "416": { + "cap": [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 428 + ] + }, + "424": { + "cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "dim": 7, + "receivers": [ + 580 + ] + }, + "428": { + "cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "dim": 7, + "receivers": [ + 582 + ] + }, + "430": { + "cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "dim": 7, + "receivers": [ + 428, + 583 + ] + }, + "434": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 585 + ] + }, + "436": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 587 + ] + }, + "438": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 586 + ] + }, + "439": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 584 + ] + }, + "440": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 588 + ] + }, + "444": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 590 + ] + }, + "446": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 591 + ] + }, + "448": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 484 + ] + }, + "449": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 485 + ] + }, + "450": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 508 + ] + }, + "451": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 509 + ] + }, + "452": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 532 + ] + }, + "453": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 533 + ] + }, + "454": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 556 + ] + }, + "455": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 557 + ] + }, + "498": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 311 + ] + }, + "499": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 498 + ] + }, + "511": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "dim": 8, + "receivers": [ + 327 + ] + }, + "585": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 555 + ] + }, + "587": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 531 + ] + }, + "589": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 543 + ] + }, + "591": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 567 + ] + } + }, + "theorem": "For every exact restore-only rewrite R of WORD-3042-base (A, B, warps, cut, helper ends, buffers fixed; exact = the PR2833 auditor end-of-restore conditions), cert_cost(R) >= LB_forced + sum_forced_extras = 10868103087 = cert_cost(WORD-3042-base)." +} \ No newline at end of file diff --git a/research/rank7-skip-restore-optimum/evidence/laneK/NEGATIVE-3042-extra.json b/research/rank7-skip-restore-optimum/evidence/laneK/NEGATIVE-3042-extra.json new file mode 100644 index 0000000000..fd764fb8cc --- /dev/null +++ b/research/rank7-skip-restore-optimum/evidence/laneK/NEGATIVE-3042-extra.json @@ -0,0 +1,1441 @@ +{ + "word": "3042-extra", + "certified_cost": 10868103087, + "certified_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "LB_forced": 10867765164, + "LB_certified": true, + "LB_profile": { + "1": 2370, + "2": 693, + "3": 255, + "4": 116, + "5": 18, + "8": 8 + }, + "forced_caps": 88, + "visits": 51, + "sum_forced_extras": 337923, + "LB_plus_forced": 10868103087, + "equals_current": true, + "blocked": 42, + "blocked_units": 292959, + "open_but_forced": 9, + "open_units": 44964, + "exchange_census": { + "priced": 990, + "negative": 0, + "min_delta": 0 + }, + "caps": { + "2": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 230, + 251, + 265 + ] + }, + "3": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 554 + ] + }, + "5": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 395, + 557 + ] + }, + "7": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 453 + ] + }, + "16": { + "cap": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 424 + ] + }, + "18": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 226 + ] + }, + "22": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 331 + ] + }, + "23": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "dim": 8, + "receivers": [ + 511 + ] + }, + "34": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 228, + 230, + 331, + 509 + ] + }, + "35": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 499 + ] + }, + "40": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 299 + ] + }, + "42": { + "cap": [ + 256, + 128, + 64, + 36, + 20, + 8, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 408 + ] + }, + "44": { + "cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "dim": 7, + "receivers": [ + 424, + 581 + ] + }, + "45": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 230 + ] + }, + "46": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 589 + ] + }, + "54": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 226, + 230, + 299, + 485 + ] + }, + "59": { + "cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "dim": 8, + "receivers": [ + 363 + ] + }, + "61": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 251 + ] + }, + "62": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249 + ] + }, + "63": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 267 + ] + }, + "69": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 566 + ] + }, + "70": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249, + 251, + 265, + 267 + ] + }, + "71": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 230, + 249, + 267 + ] + }, + "72": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249, + 251, + 265, + 267 + ] + }, + "73": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 363, + 533 + ] + }, + "92": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 230 + ] + }, + "94": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 265 + ] + }, + "96": { + "cap": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "dim": 8, + "receivers": [ + 395 + ] + }, + "103": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 230 + ] + }, + "105": { + "cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "dim": 7, + "receivers": [ + 408, + 573 + ] + }, + "108": { + "cap": [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ], + "dim": 8, + "receivers": [ + 228 + ] + }, + "226": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 449 + ] + }, + "228": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 230, + 451 + ] + }, + "230": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 450 + ] + }, + "231": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 448 + ] + }, + "232": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 452 + ] + }, + "236": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 454 + ] + }, + "238": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 455 + ] + }, + "249": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 230, + 267 + ] + }, + "251": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249, + 265, + 267 + ] + }, + "265": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 230, + 251 + ] + }, + "267": { + "cap": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "dim": 7, + "receivers": [ + 249, + 251, + 265 + ] + }, + "299": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 226, + 230, + 484 + ] + }, + "306": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 498, + 499 + ] + }, + "308": { + "cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 304, + 501 + ] + }, + "310": { + "cap": [ + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 304, + 500 + ] + }, + "311": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 499 + ] + }, + "322": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "dim": 8, + "receivers": [ + 327, + 511 + ] + }, + "324": { + "cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 320, + 513 + ] + }, + "326": { + "cap": [ + 256, + 128, + 65, + 32, + 16, + 9, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 320, + 512 + ] + }, + "327": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "dim": 8, + "receivers": [ + 510, + 511 + ] + }, + "331": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 228, + 230, + 508 + ] + }, + "351": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 531 + ] + }, + "363": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 532 + ] + }, + "367": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 543 + ] + }, + "383": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 555 + ] + }, + "395": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 556 + ] + }, + "399": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 567 + ] + }, + "400": { + "cap": [ + 256, + 128, + 65, + 33, + 17, + 9, + 5, + 3 + ], + "dim": 8, + "receivers": [ + 412 + ] + }, + "408": { + "cap": [ + 256, + 128, + 66, + 36, + 22, + 8, + 1 + ], + "dim": 7, + "receivers": [ + 572 + ] + }, + "412": { + "cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "dim": 7, + "receivers": [ + 574 + ] + }, + "414": { + "cap": [ + 256, + 128, + 65, + 36, + 20, + 9, + 3 + ], + "dim": 7, + "receivers": [ + 412, + 575 + ] + }, + "416": { + "cap": [ + 256, + 128, + 68, + 32, + 16, + 12, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 428 + ] + }, + "424": { + "cap": [ + 256, + 128, + 65, + 37, + 20, + 8, + 2 + ], + "dim": 7, + "receivers": [ + 580 + ] + }, + "428": { + "cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "dim": 7, + "receivers": [ + 582 + ] + }, + "430": { + "cap": [ + 256, + 128, + 72, + 44, + 28, + 2, + 1 + ], + "dim": 7, + "receivers": [ + 428, + 583 + ] + }, + "434": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 585 + ] + }, + "436": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 587 + ] + }, + "438": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 586 + ] + }, + "439": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 584 + ] + }, + "440": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 588 + ] + }, + "444": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 590 + ] + }, + "446": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 591 + ] + }, + "448": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 484 + ] + }, + "449": { + "cap": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "dim": 7, + "receivers": [ + 485 + ] + }, + "450": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 508 + ] + }, + "451": { + "cap": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "dim": 7, + "receivers": [ + 509 + ] + }, + "452": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 532 + ] + }, + "453": { + "cap": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "dim": 7, + "receivers": [ + 533 + ] + }, + "454": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 556 + ] + }, + "455": { + "cap": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "dim": 7, + "receivers": [ + 557 + ] + }, + "498": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 311 + ] + }, + "499": { + "cap": [ + 256, + 128, + 72, + 40, + 24, + 4, + 2, + 1 + ], + "dim": 8, + "receivers": [ + 498 + ] + }, + "511": { + "cap": [ + 256, + 128, + 65, + 32, + 17, + 8, + 5, + 2 + ], + "dim": 8, + "receivers": [ + 327 + ] + }, + "585": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 555 + ] + }, + "587": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 531 + ] + }, + "589": { + "cap": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ], + "dim": 8, + "receivers": [ + 543 + ] + }, + "591": { + "cap": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ], + "dim": 8, + "receivers": [ + 567 + ] + } + }, + "theorem": "For every exact restore-only rewrite R of WORD-3042-extra (A, B, warps, cut, helper ends, buffers fixed; exact = the PR2833 auditor end-of-restore conditions), cert_cost(R) >= LB_forced + sum_forced_extras = 10868103087 = cert_cost(WORD-3042-extra)." +} \ No newline at end of file diff --git a/research/rank7-skip-restore-optimum/evidence/laneK/bound.py b/research/rank7-skip-restore-optimum/evidence/laneK/bound.py new file mode 100644 index 0000000000..0ff35d3ac5 --- /dev/null +++ b/research/rank7-skip-restore-optimum/evidence/laneK/bound.py @@ -0,0 +1,259 @@ +"""bound.py -- lower bound on the certified cost of ANY exact restore for a word's A/B (the restore re-synthesized freely). +bound(w) = LB_forced(w) + sum of forced restore-phase extras (exact arguments, see screen.py / screen4.py / lbforced.py): + M = restore map of w (w exact => every restored helper c ends at its own input = FIXED combination of entry rows); + caps: r's restore-entry frame inside E_c for every restored receiver c of r's entry content; + LB_forced = certified optimum of w with an EMPTY restore and the caps; + extras per register r with restored receivers or leaked restored inputs (L/U from the capped empty-restore graph): + BLOCKED (for some receiver c, or for its leaks, no partner s != r with J = L_r+L_s, |J|<9, J <= U_r ^ E_c ^ E_s; for a + restored r a receiver with E_r <= E_c does not block): min over entry dims d in [dim L_r, dim(U_r ^ cap)] and 2-splits + (a, D-a), D = dim E_r - d, of c_a + c_{D-a} - c_D; a split whose first frame has dim d+1 (or equals the blocking cap) is + dropped when no such frame admits partners passing the rank test (receivers' rows on r + partners must have rank <= + #partners), since r itself cannot deliver; + OPEN-but-forced 4,996: for every receiver c, every partner frame J has no free lifter (c cannot sit at J; every register + that can sit at J and climb inside E_c is non-restored, or BLOCKED with no visit frame strictly above J); the payer + groups ({r} u non-restored lifters) are disjoint between counted registers (overlaps are merged and counted once); + otherwise 0 (optimistic, keeps the bound valid). +Calibration target: bound(WORD-3042-*) == certified cost 10,868,103,087.""" +import sys +sys.path.insert(0, '/private/tmp/claude-501/-Users-mdumitrean-Desktop-dev-aigent-math-prime/c80ebb8e-fc28-4d1d-b7ef-b214d4660f98/scratchpad/r15/agents/K/code') +from screen4 import * +from lbforced import lb_forced +CC = bp.costs().c + +def rank(rows): + m = [list(r) for r in rows if any(r)] + if not m: return 0 + rk = 0; ncol = len(m[0]) + for c in range(ncol): + piv = next((i for i in range(rk, len(m)) if m[i][c] != 0), None) + if piv is None: continue + m[rk], m[piv] = m[piv], m[rk] + for i in range(len(m)): + if i != rk and m[i][c] != 0: + f = m[i][c] / m[rk][c]; m[i] = [a - f * b for a, b in zip(m[i], m[rk])] + rk += 1 + return rk + +def entry_info_graph(g, assign, al, removed): + out = {} + for q, segs in al.items(): + if q in removed: continue + v = segs[-1]; last = None + for k in g.chains[v]: + if g.nodes[k][2] in ('tail', 'end'): break + last = k + L = tuple(g.lower[last]); U = set(span(FULL)) + if last in set(g.mutable): + for t in g.nodes[last][0]: + if t == v: continue + j = g.nxt.get((last, t)) + if j is not None: U &= set(span(tuple(g.upper[j]))) + else: + U = set(span(tuple(assign.get(last, g.nodes[last][1])))) + out[q] = dict(L=L, U=tuple(basis(tuple(U)))) + return out + +def split_costs(D): + return sorted((CC[a] + CC[D - a] - CC[D], a) for a in range(1, D)) + +def bound(w, detail=False, rows=None, M=None): + Rs = restored_set(w); E = end_frames(w) + if M is None: M = restore_map(w) + if rows is None: rows = entry_rows(w) + lb = lb_forced(w, M=M); g = lb['graph']; al = aliases(lb['w0'], lb['meta']) + EI = entry_info_graph(g, lb['assign'], al, set(w['removed'])) + regs = [q for q in EI if not (V <= q < 2 * V)] + Lof = {q: EI[q]['L'] for q in EI} + recv = {r: sorted(c for c in Rs if c != r and M[c].get(r)) for r in regs} + leak = {r: sorted({var for var, word in rows[r] if var in Rs and var != r}) for r in regs} + _sp = {} + def SP(x): + y = _sp.get(x) + if y is None: y = _sp[x] = frozenset(span(x)) + return y + SL = {s: SP(Lof[s]) for s in EI}; SE = {s: SP(E[s]) for s in EI} + def partners(r, Ec): + # J = L_r + L_s lies in X = U_r ^ E_c ^ E_s <=> L_r and L_s both lie in X (no join needed for the test) + Lr = SL[r]; X0 = SP(EI[r]['U']) if Ec is None else (SP(EI[r]['U']) & SP(Ec)) + if not Lr <= X0: return [] + out = [] + for s in EI: + if s == r: continue + Es = SE[s] + if Lr <= Es and SL[s] <= X0 and SL[s] <= Es: + J = join(Lof[r], Lof[s]) + if len(J) < 9: out.append((s, J)) + return out + status = {}; extra = {}; info = {} + for r in regs: + if not recv[r] and not leak[r]: continue + blocking = [] + pc = {} + for c in recv[r]: + if r in Rs and leq(E[r], E[c]): continue + ps = partners(r, E[c]); pc[c] = ps + if not ps: blocking.append(c) + pl = partners(r, None) if (leak[r] and r not in Rs) else [] + blocked = bool(blocking) or (bool(leak[r]) and r not in Rs and not pl) + status[r] = 'BLOCKED' if blocked else 'OPEN' + info[r] = dict(recv=recv[r], leak=leak[r], blocking=blocking, pc=pc) + # visit-frame dims of blocked registers (for free-ride checks): entry dims and first-frame dims allowed + def blocked_extra(r): + Lr, Ur = Lof[r], EI[r]['U']; cap = set(span(FULL)) + for c in recv[r]: cap &= set(span(E[c])) + capb = tuple(basis(tuple(cap & set(span(Ur))))) + bcap = set(span(FULL)) + for c in info[r]['blocking'] or recv[r]: bcap &= set(span(E[c])) + bcap = tuple(basis(tuple(bcap))) + best = None; dE = len(E[r]); split_regions = []; best_enumerated_only = [False] + for d in range(len(Lr), len(capb) + 1): + D = dE - d + if D < 2: continue + for cost, a in split_costs(D): + f = d + a + feasible = True; enumerated = False + if leq(Lr, bcap) and (f == len(Lr) + 1 and d == len(Lr) or f == len(bcap)) and f <= len(bcap): + enumerated = True + # enumerate first frames J1 of dim f with L_r <= J1 <= bcap; rank test with partners at J1 + cands = set() + if f == len(bcap): cands.add(bcap) + else: + for z in span(bcap): + if z and not leq((z,), Lr): cands.add(join(Lr, (z,))) + ok = False; regions = set() + for J1 in cands: + P = [s for s in EI if s != r and leq(Lof[s], J1) and leq(J1, E[s])] + if not P: continue + cols = [r] + P + outs = [c for c in Rs if c != r and not (r in Rs and leq(E[r], E[c])) and any(M[c].get(q) for q in cols)] + if rank([[M[c].get(q, Q(0)) for q in cols] for c in outs]) <= len(P): + ok = True + SJ1 = set(span(J1)); need = False + for c in (info[r]['blocking'] or recv[r]): + SEc = set(span(E[c])) + if not (SJ1 < SEc) or leq(Lof[c], J1): continue + if any(h != r and leq(Lof[h], J1) and leq(J1, E[h]) and (set(span(E[h])) & SEc) > SJ1 for h in Rs): continue + ride = False + for h in EI: # a BLOCKED full-end register whose own visit could sit above J1 + if h == r or h in Rs or V <= h < 2 * V or not leq(Lof[h], J1): continue + if status.get(h) != 'BLOCKED': continue + caph = set(span(FULL)) + for c2 in recv.get(h, []): caph &= set(span(E[c2])) + if (caph & SEc) > SJ1: ride = True; break + if ride: continue + need = True; break + regions.add(J1 if need else None) + feasible = ok + if ok: split_regions.append((cost, regions)) + elif f > len(bcap): + feasible = False + if feasible: + if best is None or cost < best: + best = cost; best_enumerated_only[0] = enumerated + elif cost == best and not enumerated: + best_enumerated_only[0] = False + break + if best is None: + best = min(c for c, a in split_costs(dE - len(capb))) if dE - len(capb) >= 2 else 0 + # a lift region is forced only if EVERY feasible enumerated split of minimal cost needs a lift out of the same region and + # no split without enumeration (assumed feasible, optimistic) achieves the same cost + forced = None + mins = [rg for c, rg in split_regions if c == best] + if mins and best_enumerated_only[0]: + allr = set().union(*mins) + if None not in allr and len(allr) == 1: forced = next(iter(allr)) + return best, forced + lift_regions = {} + for r, st in status.items(): + if st == 'BLOCKED': + extra[r], reg_ = blocked_extra(r) + if reg_ is not None: lift_regions.setdefault(reg_, []).append(r) + # OPEN-but-forced (non-restored r only): + # zero-sum: every partner frame J for receiver c needs a lift (J strictly inside E_c, c cannot sit at J), no restored + # register can sit at J and climb inside E_c, all partners are non-restored and not BLOCKED -> r or a partner pays; + # rank: for receiver c every partner frame J fails the rank test on [r] + P_J -> r itself must climb above J. + groups = []; Rs_list = sorted(Rs); group_frames = {} + for r, st in status.items(): + if st != 'OPEN' or r in Rs or not recv[r]: continue + rank_cache = {} + kind = None; payers = {r} + for c, ps in info[r]['pc'].items(): + if not ps: continue + zs = True; rk_fail = True; seenJ = {} + SEc = SP(E[c]) + for s, J in ps: + SJ = SP(J) + if not (SJ < SEc) or SL[c] <= SJ: zs = False + if zs and any(SL[h] <= SJ and SJ <= SE[h] and (SE[h] & SEc) > SJ for h in Rs_list if h != r): zs = False + if s in Rs or status.get(s) == 'BLOCKED': zs = False + if rk_fail and J not in seenJ: + P = [h for h in EI if h != r and SL[h] <= SJ and SJ <= SE[h]] + key = frozenset(P) + if key not in rank_cache: + cols = [r] + P; outs = [c2 for c2 in Rs if any(M[c2].get(q) for q in cols)] + rank_cache[key] = rank([[M[c2].get(q, Q(0)) for q in cols] for c2 in outs]) <= len(P) + seenJ[J] = rank_cache[key] + if seenJ[J]: rk_fail = False + payers.add(s) + if rk_fail: kind = 'rank'; payers = {r}; break + if zs and kind is None: kind = 'zero-sum' + if kind: groups.append((r, payers, kind)); group_frames[r] = [(J, c) for c, ps in info[r]['pc'].items() for s, J in ps] + # lift (the base's 61 case, checked by its premises): restored c whose entry content q sits inside V (E_q <= V) must be + # carried above V inside E_c by a full-end register when no restored register can sit inside V and end above V in E_c. + lifts = [] + for c in Rs: + for q, x in M[c].items(): + if q == c or not x or q not in Rs: continue + Vq = E[q] + if leq(E[c], Vq) or leq(Lof[c], Vq): continue + if any(h in Rs and leq(Lof[h], Vq) and not leq(E[h], Vq) and (set(span(E[h])) & set(span(E[c]))) > set(span(Vq)) for h in EI): continue + lifts.append((c, Vq)) + lift_keys = [] + for c, Vq in sorted({(c, Vq) for c, Vq in lifts}): + payers = {h for h in EI if h not in Rs and not (V <= h < 2 * V) and leq(Lof[h], Vq)} + ride = False + for h in payers: + if h in extra: # BLOCKED: could its forced visit frame sit strictly above Vq inside E_c? + caph = set(span(EI[h]['U'])) | set(span(FULL)) + caph = set(span(FULL)) + for c2 in recv.get(h, []): caph &= set(span(E[c2])) + if (caph & set(span(E[c]))) > set(span(Vq)): ride = True; break + if ride: continue + lift_keys.append((c, Vq, frozenset(payers))) + merged = [] + for r, P, kind in groups: + hit = [m for m in merged if m[1] & P] + rs_ = {r}; Ps = set(P) + for m in hit: rs_ |= m[0]; Ps |= m[1] + merged = [m for m in merged if m not in hit] + [(rs_, Ps)] + open_forced = {('open',) + tuple(sorted(a)): CC[1] * 2 - CC[2] for a, _ in merged} + regions_counted = set() + for c, Vq, pay in lift_keys: + if any(pay & m[1] for m in merged): continue # shares a payer with a counted open group: count once + if Vq in regions_counted: continue + regions_counted.add(Vq); open_forced[('lift', c, Vq)] = CC[1] * 2 - CC[2] + def shareable(J1, lift_recv, members): + for r0 in members: + for J, c in group_frames.get(r0, []): + Jj = join(J, J1) + if len(Jj) >= 9: continue + if any(leq(Jj, E[c]) and leq(Jj, E[c1]) for c1 in lift_recv): return True + return False + for J1, rs_ in lift_regions.items(): + if J1 in regions_counted: continue + pay = {h for h in EI if h not in Rs and not (V <= h < 2 * V) and leq(Lof[h], J1)} + lift_recv = sorted({c for r0 in rs_ for c in (info[r0]['blocking'] or recv[r0]) if set(span(J1)) < set(span(E[c])) and not leq(Lof[c], J1)}) + if any((pay & m[1]) and shareable(J1, lift_recv, m[0]) for m in merged): continue + regions_counted.add(J1); open_forced[('blocked-lift',) + tuple(sorted(rs_)) + (J1,)] = CC[1] * 2 - CC[2] + tot = sum(extra.values()) + sum(open_forced.values()) + res = dict(bound=lb['cost'] + tot, LB_forced=lb['cost'], extras_blocked=sum(extra.values()), extras_open=sum(open_forced.values()), + n_blocked=len(extra), n_open_forced=len(open_forced), lifts=[k for k in open_forced if k[0] != 'open']) + if detail: res.update(extra=extra, open_groups=[(sorted(a), sorted(b)) for a, b in merged], open_kinds=[(r, k) for r, P, k in groups], status=status, info={r: dict(recv=v['recv'], leak=v['leak'], blocking=v['blocking']) for r, v in info.items()}) + return res + +if __name__ == '__main__': + w = W(sys.argv[1]); t0 = time.time(); b = bound(w, detail=True); cur = solve(w) + print('current', cur['cost'], 'bound', b['bound'], 'gap', cur['cost'] - b['bound'], 'LB_forced', b['LB_forced'], 'blocked', b['n_blocked'], b['extras_blocked'], + 'open-forced', b['n_open_forced'], b['extras_open'], 'lifts', b['lifts'], round(time.time() - t0, 2), 's') + print('open groups', b['open_groups']) + print('open kinds', b['open_kinds']) diff --git a/research/rank7-skip-restore-optimum/evidence/laneK/crosscheck_lanek.py b/research/rank7-skip-restore-optimum/evidence/laneK/crosscheck_lanek.py new file mode 100644 index 0000000000..9a7292c79d --- /dev/null +++ b/research/rank7-skip-restore-optimum/evidence/laneK/crosscheck_lanek.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Cross-check of this package's stdlib bound (restore_bound.py) against lane K's CURRENT bound.py / lbforced.py +(the r12 BORROW-WORD harness bp.py on the #1186 frame toolkit; numpy). Not part of the registered replay: it needs lane +K's working tree. Usage: crosscheck_lanek.py LANE_K_CODE_DIR PACKAGE_DIR OUT.json. Marius-Paul Dumitrean, with +substantial AI assistance (Claude Code).""" +import gzip, hashlib, json, sys +from fractions import Fraction as Q +from pathlib import Path +lane, pkg, out = Path(sys.argv[1]), Path(sys.argv[2]), Path(sys.argv[3]) +sys.path.insert(0, str(lane)) +import bound as KB # lane K, current +import lbforced as KL +sys.path.insert(0, str(pkg)) +import frames_exact as FX, restore_bound as RB +rows_out = [] +for name in ('3042-base', '3042-extra', '2979-base', '2979-extra'): + w = json.loads(gzip.decompress((pkg / ('data/WORD-%s.json.gz' % name)).read_bytes())) + for variant in ('word', 'emptied-restore'): + x = dict(w) + if variant == 'emptied-restore': + x['restore'] = [] + rows = RB.entry_rows(x) + Mc, rk = RB.coordinates(rows, {c: {(c, ()): Q(1)} for c in RB.restored(x)}) + M = {q: {q: Q(1)} for q in RB.live_registers(x)} + M.update({c: dict(v) for c, v in Mc.items()}) + kb = KB.bound(x, M=M) + kl = KL.lb_forced(x, M=M) + pb = RB.bound(x) + rec = dict(word=name, variant=variant, laneK_bound=kb['bound'], laneK_LB_forced=kb['LB_forced'], laneK_lb_forced_direct=kl['cost'], + laneK_caps=kl['ncaps'], laneK_blocked=[kb['n_blocked'], kb['extras_blocked']], laneK_open=[kb['n_open_forced'], kb['extras_open']], + package_bound=pb['bound'], package_LB_forced=pb['LB_forced'], package_caps=pb['forced_caps'], + package_blocked=[pb['blocked'], pb['extras_blocked']], package_groups=[pb['groups'], pb['extras_open']]) + rec['agree'] = (rec['laneK_bound'] == rec['package_bound'] and rec['laneK_LB_forced'] == rec['package_LB_forced'] == rec['laneK_lb_forced_direct'] + and rec['laneK_caps'] == rec['package_caps']) + rows_out.append(rec) + print(rec, flush=True) +assert all(r['agree'] for r in rows_out) +res = dict(status='PASS_LANEK_CROSSCHECK', laneK_files={f: hashlib.sha256((lane / f).read_bytes()).hexdigest() for f in ('bound.py', 'lbforced.py')}, + rows=rows_out) +out.write_text(json.dumps(res, indent=1, sort_keys=True) + '\n') +print('PASS_LANEK_CROSSCHECK', len(rows_out)) diff --git a/research/rank7-skip-restore-optimum/evidence/laneK/lbforced.py b/research/rank7-skip-restore-optimum/evidence/laneK/lbforced.py new file mode 100644 index 0000000000..b3434c7666 --- /dev/null +++ b/research/rank7-skip-restore-optimum/evidence/laneK/lbforced.py @@ -0,0 +1,37 @@ +"""lbforced.py WORD -- frame lower bound for ANY exact restore-only rewrite of the word (auditor semantics, A/B/warps/cut/ +endpoints fixed). Every restored helper c ends with its own input, a FIXED combination M[c][.] of the (independent) restore- +entry rows; so for every register r with M[c][r] != 0 the content of r must reach c along gates with nested frames inside E_c, +and r's restore-entry frame is inside E_c. LB = certified optimum of the word with an EMPTY restore and the caps +cap[r] = intersection of E_c over those c (applied from r's last pre-restore vertex to its end climb; toolkit BorrowGraph caps). +Any exact rewrite R satisfies the caps, and merging its restore-phase jumps of every register into one end climb never costs +more (c_{a+b} <= c_a + c_b), so cost(R) >= LB. If LB == cost(current word), the current restore is optimal in the whole class.""" +import sys +sys.path.insert(0, '/private/tmp/claude-501/-Users-mdumitrean-Desktop-dev-aigent-math-prime/c80ebb8e-fc28-4d1d-b7ef-b214d4660f98/scratchpad/r15/agents/K/code') +from screen4 import * +def lb_forced(w, extra_caps=None, M=None): + if M is None: M = restore_map(w) + E = end_frames(w); Rs = restored_set(w) + capf = {} + for c in Rs: + for r, x in M[c].items(): + if r == c or not x: continue + capf.setdefault(r, set(span(FULL))) + capf[r] &= set(span(E[c])) + if extra_caps: + for r, U in extra_caps.items(): + capf.setdefault(r, set(span(FULL))); capf[r] &= set(span(U)) + w0 = dict(w); w0['restore'] = [] + w2, meta = bp.build_problem(w0) + al = aliases(w0, meta) + caps = {al[r][-1]: tuple(basis(tuple(U))) for r, U in capf.items()} + g = bp.BorrowGraph(w2, meta['eq_end'], check_literal=False, tail_mutable=True, caps=caps, cut_equality=True) + res = bp.F.optimal_frames(w2, bp.costs(), check_literal=False, graph=g) + cd = bp.centre_descents(w0); prof = collections.Counter(res['profile']); prof.update(cd) + return dict(cost=res['cost'] + bp.costs().profile_cost(cd), certified=res['certified'], profile=dict(sorted(prof.items())), + ncaps=len(caps), assign=res['assign'], graph=g, meta=meta, w0=w0) +if __name__ == '__main__': + w = W(sys.argv[1]); cur = solve(w) + lb = lb_forced(w) + print('current', cur['cost'], cur['profile']) + print('LB_forced', lb['cost'], lb['certified'], lb['profile'], 'caps', lb['ncaps']) + print('gap (max possible gain of any exact restore-only rewrite)', cur['cost'] - lb['cost']) diff --git a/research/rank7-skip-restore-optimum/evidence/tail-exchange/TAIL-EXCHANGE-3042-base.jsonl.gz b/research/rank7-skip-restore-optimum/evidence/tail-exchange/TAIL-EXCHANGE-3042-base.jsonl.gz new file mode 100644 index 0000000000..3d6cfeeb2a Binary files /dev/null and b/research/rank7-skip-restore-optimum/evidence/tail-exchange/TAIL-EXCHANGE-3042-base.jsonl.gz differ diff --git a/research/rank7-skip-restore-optimum/evidence/tail-exchange/TAIL-EXCHANGE-3042-extra.jsonl.gz b/research/rank7-skip-restore-optimum/evidence/tail-exchange/TAIL-EXCHANGE-3042-extra.jsonl.gz new file mode 100644 index 0000000000..3d6cfeeb2a Binary files /dev/null and b/research/rank7-skip-restore-optimum/evidence/tail-exchange/TAIL-EXCHANGE-3042-extra.jsonl.gz differ diff --git a/research/rank7-skip-restore-optimum/frames_exact.py b/research/rank7-skip-restore-optimum/frames_exact.py new file mode 100644 index 0000000000..dbd197a63e --- /dev/null +++ b/research/rank7-skip-restore-optimum/frames_exact.py @@ -0,0 +1,510 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Exact frame optimum of a BORROW-WORD for a fixed gate order (Python standard library only). + +This is a numpy-free port of the certified frame solver used for the receipts of this package: the BORROW-WORD frame model +of our r12 harness (`bp.py`: build_problem, BorrowGraph, centre_descents) on the frame toolkit of PR #1186 +(research/exact-frame-toolkit/frames.py: Graph domains, exact variable elimination, component accounting, Costs). Only +the exact variable-elimination path is ported; a component that elimination cannot finish raises instead of falling back +to the toolkit's numpy chain-dual solver, so every optimum reported here is an exhaustive minimum. + +Frame model (the BORROW-WORD branch of PR2833's audit_local.py): every A (after the prelude), B and restore gate is one +vertex whose frame (a subspace of F_2^9) is shared by its registers; register chains are nested (monotone); every rank +jump is paid c[jump]; ends climb (paid) to the end frames; at the end of A the targets equal their target levels and the +centres their centre frames (cut equality); a warp requires the lender's current frame to EQUAL its entry frame U (no +payment) and resets it to E (modelled by splitting the lender into virtual registers). Centre descents are fixed. +Optional caps bound a register's frame at its last vertex before its end (used for the forced restore-entry caps). + +Weights: c[r] = floor(2^40 * lo_r(b)) at b = 0.001703676387993676, lo_r the outward lower moment bound of the vendored +research/frame-domain-ceiling engines (exactly frames.Costs). Marius-Paul Dumitrean, with substantial AI assistance +(Claude Code). +""" +import collections +import importlib.util +from fractions import Fraction as Q +from functools import lru_cache +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def _load(name, path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +GK = _load('rank7sro_gk_common', HERE / 'vendor' / 'gk_common.py') # canonical GF(2) bases +MOM = _load('rank7sro_moment', HERE / 'vendor' / 'moment.py') # moment engine (Mercator/exp) +MOM2 = _load('rank7sro_base_two_moment', HERE / 'vendor' / 'base_two_moment.py') # second engine (PR39 cross-check) + +V = 112 +H = 9 +M_DIM = 73 +W_LIVE = 7168 +B_DEFAULT = '0.001703676387993676' +UNIT_BITS = 40 +VE_MAX_COMPONENT = 600 +VE_MAX_TUPLES = 5_000_000 + + +class Infeasible(Exception): + pass + + +@lru_cache(None) +def basis(F): + return GK.basis(F) + + +@lru_cache(None) +def span(F): + s = {0} + for b in F: + s |= {x ^ b for x in s} + return frozenset(s) + + +def leq(F, G): + return span(tuple(F)) <= span(tuple(G)) + + +def join(F, G): + return basis(tuple(F) + tuple(G)) + + +def meet(*frames): + s = set(span(FULL9)) + for f in frames: + s &= span(tuple(f)) + return basis(tuple(s)) + + +FULL9 = basis(tuple(1 << i for i in range(H))) + + +def perp_port(p): + return basis(tuple(x for x in range(1, 1 << H) if (x & p).bit_count() % 2 == 0)) + + +def regs_of(g): + return [g[1]] + ([g[2]] if g[0] == 'add' else []) + + +@lru_cache(None) +def weights(b=B_DEFAULT): + """integer surrogate weights c[0..9] (frames.Costs, unit 2^-40)""" + b = Q(b) + fl, fu = MOM2.moment(M_DIM, W_LIVE, [(1, 32 * M_DIM * M_DIM)], b) + c = {0: 0} + for r in range(1, H + 1): + lo1, hi1 = MOM.moment({r: 1}, M_DIM, W_LIVE, b, True) + lo2, hi2 = MOM2.moment(M_DIM, W_LIVE, [(r, 1)], b) + lo2 += fl / Q(10 ** 16) + hi2 += fu / Q(10 ** 16) + lo, hi = max(lo1, lo2), min(hi1, hi2) + if not 0 < lo <= hi: + raise ValueError(('moment bounds out of order', r)) + c[r] = (lo.numerator << UNIT_BITS) // lo.denominator + return tuple(c[r] for r in range(H + 1)) + + +def profile_cost(profile, c=None): + c = c or weights() + return sum(n * c[int(r)] for r, n in profile.items()) + + +def centre_descents(w): + """the auditor's cut-path payments (fixed by centre frames, target levels and cut gates)""" + lev = {int(t): basis(tuple(U)) for t, U in w.get('target_levels', {}).items()} + paid = collections.Counter() + for q, U in zip(w['centers'], w['center_frames']): + U = basis(tuple(U)) + served = {lev.get(e[1] - V, ()) for e in w['cut'] if e[2] == q} + for T in sorted(served, key=lambda x: -len(x)): + if not leq(T, U): + raise ValueError('centre path not nested') + if T != U: + paid[len(U) - len(T)] += 1 + U = T + return paid + + +def build_problem(w): + """BORROW-WORD -> inline problem with virtual registers split at warps (bp.build_problem).""" + R = w['report']['R'] + N = 2 * V + R + removed = set(w['removed']) + start = [(p,) for p in w['ports']] + [()] * (V + R) + for q, U in w.get('start_extra', {}).items(): + start[int(q)] = basis(tuple(U)) + end = [FULL9] * V + [perp_port(p) for p in w['ports']] + [FULL9] * R + for q, U in w.get('helper_final', {}).items(): + end[int(q)] = basis(tuple(U)) + starts = list(start) + finals = [None] * N + alias = list(range(N)) + eq_end = set() + nxt_virtual = [N] + + def close_and_split(r, fr, to): + cur = alias[r] + finals[cur] = basis(tuple(fr)) + eq_end.add(cur) + new = nxt_virtual[0] + nxt_virtual[0] += 1 + starts.append(basis(tuple(to))) + finals.append(None) + alias[r] = new + + def ren(e): + g = list(e) + if g[0] == 'add': + g[1] = alias[g[1]] + g[2] = alias[g[2]] + else: + g[1] = alias[g[1]] + return g + + npre = w.get('prelude_events', 0) + A_out = [] + A_idx = [] + for i, e in enumerate(w['A']): + if e[0] == 'warp': + if i >= npre: + raise ValueError('warp after prelude') + _, r, op, fr, to = e + close_and_split(r, fr, to) + else: + A_out.append(ren(e)) + A_idx.append(i) + centers_at_cut = [alias[q] for q in w['centers']] + byp = collections.defaultdict(list) + for op, rec in enumerate(w['warps'], 1): + byp[rec[0]].append(op) + B_out = [] + for p in range(len(w['B']) + 1): + for op in byp.get(p, []): + pos, lender, cols, U, E = w['warps'][op - 1] + close_and_split(lender, U, E) + if p < len(w['B']): + B_out.append(ren(w['B'][p])) + T_out = [ren(e) for e in w['restore']] + Nv = nxt_virtual[0] + for r in range(N): + a = alias[r] + if finals[a] is None: + finals[a] = end[r] + for r in removed: + starts[r] = () + finals[r] = () + if alias[r] != r: + raise ValueError('removed helper with a warp') + w2 = dict(A=A_out, B=B_out, _tail=T_out, ports=w['ports'], centers=centers_at_cut, center_frames=w['center_frames'], + target_levels=w.get('target_levels', {}), R=Nv - 2 * V, + _start_frames=[tuple(s) for s in starts], _final_frames=[tuple(f) for f in finals]) + meta = dict(N=N, Nv=Nv, eq_end=eq_end, A_idx=A_idx, virtual=Nv - N, removed=len(removed)) + return w2, meta + + +def aliases(w, meta): + """original register -> list of its virtual registers (warp segments) in solver order""" + N = meta['N'] + alias = {q: [q] for q in range(N)} + nxt = N + for e in w['A']: + if e[0] == 'warp': + alias[e[1]].append(nxt) + nxt += 1 + byp = collections.defaultdict(list) + for op, rec in enumerate(w['warps'], 1): + byp[rec[0]].append(op) + for p in range(len(w['B']) + 1): + for op in byp.get(p, []): + alias[w['warps'][op - 1][1]].append(nxt) + nxt += 1 + return alias + + +class FrameGraph: + """event graph of the inline problem (frames.Graph + bp.BorrowGraph, check_literal=False, tail_mutable=True)""" + + def __init__(self, w, eq_end, caps=None, cut_equality=True): + R = w['R'] + N = 2 * V + R + self.N = N + caps = caps or {} + nodes = [] + chains = [[] for _ in range(N)] + mutable = [] + start_frames = w['_start_frames'] + final_frames = w['_final_frames'] + tail = w.get('_tail', []) + + def node(regs, Fr, sec, index=None): + k = len(nodes) + nodes.append((tuple(regs), basis(tuple(Fr)), sec, index)) + for r in regs: + chains[r].append(k) + if sec in ('A', 'B', 'tail'): + mutable.append(k) + + for r in range(N): + node([r], start_frames[r], 'start') + for sec in ('A', 'B'): + if sec == 'B': + for r, Fr in zip(w['centers'], w['center_frames']): + node([r], Fr, 'cut') + for t in range(V): + node([V + t], w.get('target_levels', {}).get(str(t), []), 'cut') + for i, e in enumerate(w[sec]): + node(regs_of(e), e[-1] if e[-1] is not None else [], sec, i) + for i, e in enumerate(tail): + node(regs_of(e), e[-1], 'tail', i) + for r in range(N): + node([r], final_frames[r], 'end') + self.chains = chains + self.mutable = mutable + prev = {} + nxt = {} + for r, ch in enumerate(chains): + for p, q in zip(ch, ch[1:]): + prev[q, r] = p + nxt[p, r] = q + self.prev = prev + self.nxt = nxt + allowed = set(mutable) + lower = {} + upper = {} + for k, (regs, F0, sec, idx) in enumerate(nodes): + lower[k] = basis(tuple(x for r in regs for x in lower[prev[k, r]])) if k in allowed else F0 + if k in allowed: + for r in regs: + j = nxt.get((k, r)) + if j is None: + continue + if (cut_equality and sec == 'A' and nodes[j][2] == 'cut') or (nodes[j][2] == 'end' and r in eq_end): + lower[k] = basis(tuple(lower[k]) + tuple(nodes[j][1])) + elif sec != 'end': + for r in regs: + j = nxt.get((k, r)) + if j is not None and nodes[j][2] == 'end' and r in eq_end and span(F0) != span(nodes[j][1]): + raise Infeasible(('fixed vertex differs from its warp frame', k, sec, idx, r)) + for k in reversed(range(len(nodes))): + regs, F0, sec, idx = nodes[k] + if k in allowed: + U = set(span(FULL9)) + for r in regs: + U.intersection_update(span(upper[nxt[k, r]])) + for r in regs: + if r in caps and nodes[nxt[k, r]][2] in ('tail', 'end'): + U.intersection_update(span(caps[r])) + upper[k] = basis(tuple(U)) + if not leq(lower[k], upper[k]): + raise Infeasible(('L not inside U at mutable vertex', k, sec, idx)) + else: + upper[k] = F0 + if not leq(lower[k], F0): + raise Infeasible(('fixed vertex below its forced lower frame', k, sec, idx)) + for r in regs: + if (k, r) in nxt and not leq(F0, upper[nxt[k, r]]): + raise Infeasible(('fixed vertex above its successor cap', k, sec, idx)) + self.lower = lower + self.upper = upper + nodes = [((regs, lower[k], sec, idx) if (k in allowed and lower[k] == upper[k]) else (regs, F0, sec, idx)) + for k, (regs, F0, sec, idx) in enumerate(nodes)] + self.nodes = nodes + self.var = [k for k in mutable if lower[k] != upper[k]] + self.varset = set(self.var) + self.dom = {k: self._domain(k) for k in self.var} + adj = collections.defaultdict(set) + for (k, r), j in prev.items(): + if k in self.varset and j in self.varset: + adj[k].add(j) + adj[j].add(k) + comps = [] + remaining = set(self.var) + while remaining: + root = min(remaining) + stack = [root] + remaining.remove(root) + comp = [] + while stack: + k = stack.pop() + comp.append(k) + for j in adj[k] & remaining: + remaining.remove(j) + stack.append(j) + comps.append(sorted(comp)) + self.components = sorted(comps, key=lambda z: (-len(z), min(z))) + + def _domain(self, k): + L, U = self.lower[k], self.upper[k] + extras = [] + current = L + for v in U: + if v not in span(current): + extras.append(v) + current = basis(tuple(current) + (v,)) + d = len(extras) + if d > 5: + raise ValueError(('domain too large', k, d)) + spaces = {()} + frontier = [()] + while frontier: + nxt = [] + for S in frontier: + sp = set(span(S)) + for v in range(1, 1 << d): + if v not in sp: + T = basis(S + (v,)) + if T not in spaces: + spaces.add(T) + nxt.append(T) + frontier = nxt + + def lift(v): + z = 0 + for i, x in enumerate(extras): + if v >> i & 1: + z ^= x + return z + return sorted({basis(tuple(L) + tuple(lift(v) for v in S)) for S in spaces}) + + def frame(self, assign, k): + return assign[k] if k in self.varset else self.nodes[k][1] + + def profile(self, assign): + H_ = collections.Counter() + for (k, r), j in self.prev.items(): + d = len(self.frame(assign, k)) - len(self.frame(assign, j)) + if d: + H_[d] += 1 + return H_ + + +def solve_component(g, c, comp, max_tuples=VE_MAX_TUPLES): + """min-sum variable elimination over one component (frames.solve_component_ve); (cost, assignment) or None""" + cset = set(comp) + factors = [] + for (k, r), j in g.prev.items(): + if k in cset and j in cset: + tab = {} + for F in g.dom[j]: + for G in g.dom[k]: + if leq(F, G): + tab[(F, G)] = c[len(G) - len(F)] + factors.append(([j, k], tab)) + elif k in cset: + Fj = g.nodes[j][1] + factors.append(([k], {(F,): c[len(F) - len(Fj)] for F in g.dom[k]})) + elif j in cset: + Fk = g.nodes[k][1] + factors.append(([j], {(F,): c[len(Fk) - len(F)] for F in g.dom[j]})) + adj = {k: set() for k in comp} + for s, _ in factors: + if len(s) == 2: + adj[s[0]].add(s[1]) + adj[s[1]].add(s[0]) + gg = {v: set(nb) for v, nb in adj.items()} + order = [] + + def fill(v): + nb = list(gg[v]) + cnt = 0 + for i in range(len(nb)): + for j in range(i + 1, len(nb)): + if nb[j] not in gg[nb[i]]: + cnt += 1 + return cnt + while gg: + v = min(gg, key=lambda x: (fill(x), len(gg[x]), x)) + nb = list(gg[v]) + for i in range(len(nb)): + for j in range(i + 1, len(nb)): + gg[nb[i]].add(nb[j]) + gg[nb[j]].add(nb[i]) + for u in nb: + gg[u].discard(v) + del gg[v] + order.append(v) + active = [(list(s), dict(f)) for s, f in factors] + back = [] + for v in order: + group = [(s, f) for s, f in active if v in s] + rest = [(s, f) for s, f in active if v not in s] + cs, cf = list(group[0][0]), dict(group[0][1]) + for s, f in group[1:]: + common = [x for x in s if x in cs] + new = [x for x in s if x not in cs] + idx_s = {x: i for i, x in enumerate(s)} + idx_c = {x: i for i, x in enumerate(cs)} + byc = collections.defaultdict(list) + for key, val in f.items(): + byc[tuple(key[idx_s[x]] for x in common)].append((tuple(key[idx_s[x]] for x in new), val)) + nf = {} + for key, val in cf.items(): + for nk, nv in byc.get(tuple(key[idx_c[x]] for x in common), ()): + nf[key + nk] = val + nv + cs, cf = cs + new, nf + if len(cf) > max_tuples: + return None + vi = cs.index(v) + ns = cs[:vi] + cs[vi + 1:] + best = {} + arg = {} + for key, val in cf.items(): + ctx = key[:vi] + key[vi + 1:] + if ctx not in best or val < best[ctx]: + best[ctx] = val + arg[ctx] = key[vi] + back.append((v, ns, arg)) + active = rest + ([(ns, best)] if ns else [([], {(): min(best.values())})]) + total = sum(f.get((), 0) for s, f in active if not s) + assign = {} + for v, ns, arg in reversed(back): + assign[v] = arg[tuple(assign[x] for x in ns)] + return total, assign + + +def optimal_frames(g, c=None): + """exact optimum of the frame graph: exhaustive elimination per component plus fixed boundary edges""" + c = c or weights() + assign = {} + total = 0 + for comp in g.components: + res = solve_component(g, c, comp) if len(comp) <= VE_MAX_COMPONENT else None + if res is None: + raise ValueError(('component too wide for exact elimination', len(comp))) + cost, a = res + assign.update(a) + total += cost + fixed = 0 + for (k, r), j in g.prev.items(): + if k not in g.varset and j not in g.varset: + fixed += c[len(g.nodes[k][1]) - len(g.nodes[j][1])] + prof = g.profile(assign) + cost = total + fixed + if cost != profile_cost(prof, c): + raise ValueError('component accounting mismatch') + for (k, r), j in g.prev.items(): + if not leq(g.frame(assign, j), g.frame(assign, k)): + raise ValueError('returned assignment is not nested') + return dict(cost=cost, profile=prof, assign=assign) + + +def frame_optimum(w, caps=None): + """certified-model optimum of a BORROW-WORD; caps: {original register: cap frame at its last vertex before its end}""" + w2, meta = build_problem(w) + vcaps = {} + if caps: + al = aliases(w, meta) + vcaps = {al[r][-1]: basis(tuple(U)) for r, U in caps.items()} + g = FrameGraph(w2, meta['eq_end'], caps=vcaps) + res = optimal_frames(g) + cd = centre_descents(w) + prof = collections.Counter(res['profile']) + prof.update(cd) + return dict(cost=res['cost'] + profile_cost(cd), profile=dict(sorted(prof.items())), graph=g, meta=meta, + assign=res['assign'], variables=len(g.var), components=len(g.components), + largest_component=max((len(x) for x in g.components), default=0)) diff --git a/research/rank7-skip-restore-optimum/restore_bound.py b/research/rank7-skip-restore-optimum/restore_bound.py new file mode 100644 index 0000000000..cc03aa4fdc --- /dev/null +++ b/research/rank7-skip-restore-optimum/restore_bound.py @@ -0,0 +1,562 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Lower bound on the certified local cost of EVERY exact restore-only rewrite of a BORROW-WORD (stdlib only). + +A restore-only rewrite keeps the precondition, compensation, initial corrections, A (with its prelude), cut, warps, B, +start frames, helper end frames, removed helpers and buffers, and replaces the restore by an arbitrary scalar gate +sequence; all frames (A, B and restore) are re-solved. It is exact when PR2833's auditor (BORROW-WORD branch, vendored +unchanged) passes. The bound is + + bound(w) = LB_forced(w) + sum of forced restore-phase extras, + +where LB_forced is the exact frame optimum of w with an EMPTY restore and the forced entry caps, and the extras are +charged by the lemmas below (README.md, section "Proof"): + Lemma 1 auditor semantics: exact => every restored helper c ends with its own input row x_c and no live register keeps + a restored input c outside c (the auditor's forward `require`s at the end of restore); + Lemma 2 forced coordinates: restore-entry rows are linearly independent, so x_c = sum_q M[c][q] e_q is unique and every + exact restore realizes row c of its linear map equal to M[c]; + Lemma 3 forced caps: M[c][r] != 0 (r != c) => r is read on a path to c whose gate frames are nested inside E_c, hence + r's restore-entry frame F_r <= E_c; + Lemma 4 merge: replacing every register's restore-phase climbs by one end climb gives a feasible assignment of the + capped empty-restore problem and costs sum_r ov_r less (subadditive weights); + Lemma 5 delivery/cleaning: a receiver's content leaves r through a gate reading r at a frame inside E_c; a non-restored + register holding a restored input must be cleaned (written) below FULL (span of restored-input parts of FULL + registers never shrinks and ends at 0); + Lemma 6 departure (dual vectors): if r stays inside frame G until it jumps to a frame outside E_c for every c in O, + the nonzero dual vector d_r is supported on Z = {r} u {y : L_y <= G} and M[O][Z] d_r = 0; full column rank + of M[O][Z] therefore excludes that departure; + Lemma 7 lifts: content that sits at frame F (or inside a restored source's end V) and must reach a receiver that + cannot sit there is carried upward by a register that sits there; a non-restored carrier makes a visit + (>= 2c1 - c2), a blocked one needs >= 3 restore-phase jumps. +Marius-Paul Dumitrean, with substantial AI assistance (Claude Code). +""" +import collections +import copy +from fractions import Fraction as Q + +import frames_exact as FX + +AL = FX._load('rank7sro_audit_local', FX.HERE / 'vendor' / 'audit_local.py') # PR2833 auditor (walg_apply, run) +V = FX.V +basis, span, leq, join, meet, FULL9 = FX.basis, FX.span, FX.leq, FX.join, FX.meet, FX.FULL9 + + +# ------------------------------------------------------------------------------------------------ exact algebra +def live_registers(w): + n = 2 * V + w['report']['R'] + removed = set(w['removed']) + return [q for q in range(n) if q not in removed] + + +def restored(w): + return set(map(int, w['helper_final'])) + + +def is_target(q): + return V <= q < 2 * V + + +def program_pre_restore(w): + """the auditor's forward program up to the end of B (corrections, precondition, compensation, A, cut, B with warps)""" + corr = [['corr', t['target'], t['source'], tuple(t['operator_word']), Q(t['coefficient'])] for t in w['initial_corrections']] + prog = corr + 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, []): + prog.append(['warp', w['warps'][op - 1][1], op]) + if p < len(w['B']): + prog.append(w['B'][p]) + return prog + + +def entry_rows(w): + rows = {r: {(r, ()): Q(1)} for r in live_registers(w)} + for e in program_pre_restore(w): + AL.walg_apply(e, rows, False, 10 ** 6) + return rows + + +def run_restore(restore, rows): + rows = {r: dict(x) for r, x in rows.items()} + for e in restore: + AL.walg_apply(e, rows, False, 10 ** 6) + return rows + + +def end_conditions(w, rows_final, rows_entry=None): + """Lemma 1 end-of-restore conditions: (dirty restored helpers, leaks, changed targets)""" + R = restored(w) + dirty = sorted(c for c in R if rows_final[c] != {(c, ()): Q(1)}) + leaks = {} + for r, row in rows_final.items(): + ks = sorted({var for var, word in row if var in R and var != r}) + if ks: + leaks[r] = ks + targets = sorted(t for t in rows_final if is_target(t) and rows_entry is not None and rows_final[t] != rows_entry[t]) + return dirty, leaks, targets + + +def _axpy(dst, src, f): + for k, x in src.items(): + y = dst.get(k, Q(0)) + f * x + if y: + dst[k] = y + else: + dst.pop(k, None) + + +def coordinates(rows, targets): + """coordinates of target rows in the basis of `rows` (Gaussian elimination with combination tracking, Fractions); + raises if the rows are dependent or a target is outside their span""" + order = lambda k: (k[0], len(k[1]), k[1]) + piv = {} + for q in sorted(rows): + v = dict(rows[q]) + comb = {q: Q(1)} + while v: + k = min(v, key=order) + if k in piv: + pr, pc = piv[k] + f = -v[k] / pr[k] + _axpy(v, pr, f) + _axpy(comb, pc, f) + else: + piv[k] = (v, comb) + break + else: + raise ValueError(('restore-entry rows are dependent', q)) + out = {} + for name, t in targets.items(): + v = dict(t) + comb = {} + while v: + k = min(v, key=order) + if k not in piv: + raise ValueError(('target outside the span of the entry rows', name, k)) + pr, pc = piv[k] + f = v[k] / pr[k] + _axpy(v, pr, -f) + _axpy(comb, pc, f) + out[name] = comb + return out, len(piv) + + +def restore_map(w, restore=None): + """register-level linear map of a restore program (final_r = sum_q map[r][q] entry_q)""" + restore = w['restore'] if restore is None else restore + M = {q: {q: Q(1)} for q in live_registers(w)} + for g in restore: + if g[0] == 'add': + t, s, c = g[1], g[2], Q(g[3], g[4]) + row = dict(M[t]) + for k, x in M[s].items(): + y = row.get(k, Q(0)) + c * x + if y: + row[k] = y + else: + row.pop(k, None) + M[t] = row + else: + q = Q(g[2], g[3]) + M[g[1]] = {k: q * x for k, x in M[g[1]].items()} + return M + + +def end_frames(w): + n = 2 * V + w['report']['R'] + E = {} + for q in range(n): + if q < V: + E[q] = FULL9 + elif q < 2 * V: + E[q] = FX.perp_port(w['ports'][q - V]) + else: + E[q] = FULL9 + for q, U in w['helper_final'].items(): + E[int(q)] = basis(tuple(U)) + return E + + +def rank(rows): + m = [list(r) for r in rows if any(r)] + if not m: + return 0 + rk = 0 + ncol = len(m[0]) + for c in range(ncol): + piv = next((i for i in range(rk, len(m)) if m[i][c] != 0), None) + if piv is None: + continue + m[rk], m[piv] = m[piv], m[rk] + for i in range(len(m)): + if i != rk and m[i][c] != 0: + f = m[i][c] / m[rk][c] + m[i] = [a - f * b for a, b in zip(m[i], m[rk])] + rk += 1 + return rk + + +# ------------------------------------------------------------------------------------------------ frames +def forced_caps(M, E, R): + """Lemma 3: cap[r] = intersection of E_c over restored c != r with M[c][r] != 0; receivers per register""" + capf = {} + recv = collections.defaultdict(list) + for c in sorted(R): + for r, x in M[c].items(): + if r == c or not x: + continue + recv[r].append(c) + capf.setdefault(r, set(span(FULL9))) + capf[r] &= set(span(tuple(E[c]))) + return {r: basis(tuple(U)) for r, U in capf.items()}, {r: sorted(v) for r, v in recv.items()} + + +def empty_restore(w): + w0 = dict(w) + w0['restore'] = [] + return w0 + + +def lb_forced(w, caps): + return FX.frame_optimum(empty_restore(w), caps=caps) + + +def entry_bounds(w, lb): + """per live register: L (forward lower bound) and U (cap from its other registers) at its last pre-restore vertex, + in the capped empty-restore graph (valid for every exact restore-only rewrite)""" + g = lb['graph'] + al = FX.aliases(w, lb['meta']) + removed = set(w['removed']) + out = {} + mutable = set(g.mutable) + for q, segs in al.items(): + if q in removed: + continue + v = segs[-1] + last = None + for k in g.chains[v]: + if g.nodes[k][2] in ('tail', 'end'): + break + last = k + L = tuple(g.lower[last]) + if last in mutable: + U = set(span(FULL9)) + for t in g.nodes[last][0]: + if t == v: + continue + j = g.nxt.get((last, t)) + if j is not None: + U &= set(span(tuple(g.upper[j]))) + U = basis(tuple(U)) + else: + U = tuple(lb['assign'].get(last, g.nodes[last][1])) + out[q] = (L, U) + return out + + +def subspaces_between(A, B): + """all subspaces S with A <= S <= B, sorted by (dim, basis)""" + extras = [] + cur = basis(tuple(A)) + for v in basis(tuple(B)): + if v not in span(cur): + extras.append(v) + cur = basis(cur + (v,)) + d = len(extras) + spaces = {()} + frontier = [()] + while frontier: + nxt = [] + for Sb in frontier: + sp = set(span(Sb)) + for v in range(1, 1 << d): + if v not in sp: + T = basis(Sb + (v,)) + if T not in spaces: + spaces.add(T) + nxt.append(T) + frontier = nxt + + def lift(v): + z = 0 + for i, x in enumerate(extras): + if v >> i & 1: + z ^= x + return z + return sorted({basis(tuple(A) + tuple(lift(v) for v in Sb)) for Sb in spaces}, key=lambda s: (len(s), s)) + + +def compositions(D, kmin): + out = [] + + def rec(rem, pre): + if rem == 0: + if len(pre) >= kmin: + out.append(tuple(pre)) + return + for a in range(1, rem + 1): + rec(rem - a, pre + [a]) + rec(D, []) + return out + + +# ------------------------------------------------------------------------------------------------ the bound +def bound(w, rows=None, M=None, need_lb=None): + """the restore lower bound with its complete certificate (JSON-serializable)""" + c = FX.weights() + visit_unit = 2 * c[1] - c[2] + R = restored(w) + E = end_frames(w) + if rows is None: + rows = entry_rows(w) + if M is None: + Mc, rk = coordinates(rows, {x: {(x, ()): Q(1)} for x in R}) + M = {q: dict(v) for q, v in Mc.items()} + caps, recv = forced_caps(M, E, R) + lb = need_lb if need_lb is not None else lb_forced(w, caps) + LU = entry_bounds(w, lb) + live = [q for q in LU if not is_target(q)] + L = {q: LU[q][0] for q in LU} + U = {q: LU[q][1] for q in LU} + SL = {q: set(span(L[q])) for q in live} + SE = {q: set(span(E[q])) for q in live} + if not all(len(E[x]) < 9 for x in R): + raise ValueError('a restored helper ends at FULL') + if any(M[x].get(t) for x in R for t in range(V, 2 * V)): + raise ValueError('a restored helper needs a target row') + leak = {x: (sorted({var for var, word in rows[x] if var in R and var != x}) if x not in R else []) for x in live} + cap = {x: caps.get(x, FULL9) for x in live} + + def P_at(G, x): + SG = set(span(G)) + return [y for y in live if y != x and SL[y] <= SG and SG <= SE[y]] + dep_cache = {} + + def departure_impossible(x, G): + key = (x, G) + if key not in dep_cache: + SG = set(span(G)) + Z = [x] + [y for y in live if y != x and SL[y] <= SG] + O = [cc for cc in sorted(R) if cc != x and not leq(E[x], E[cc])] + mat = [[M[cc].get(q, Q(0)) for q in Z] for cc in O] + dep_cache[key] = (rank([r_ for r_ in mat if any(r_)]) == len(Z), len(Z)) + return dep_cache[key][0] + + def partner_exists(x, X): + if not leq(L[x], X): + return False + for s in live: + if s == x: + continue + J = join(L[x], L[s]) + if len(J) < 9 and leq(J, X) and leq(J, E[s]): + return True + return False + status = {} + info = {} + for x in live: + rx = recv.get(x, []) + if not rx and not leak[x]: + continue + rX = [cc for cc in rx if not leq(E[x], E[cc])] + blocking = [cc for cc in rX if not partner_exists(x, meet(U[x], E[cc]))] + leakblock = bool(leak[x]) and not partner_exists(x, U[x]) + status[x] = 'BLOCKED' if (blocking or leakblock) else 'OPEN' + info[x] = dict(receivers=rx, leaks=leak[x], blocking=blocking, leak_blocked=leakblock) + beta, min3, why = {}, {}, {} + for x, st in status.items(): + if st != 'BLOCKED': + continue + dE = len(E[x]) + FU = meet(U[x], cap[x], E[x]) + rX = [cc for cc in recv.get(x, []) if not leq(E[x], E[cc])] + rcap = meet(E[x], *[E[cc] for cc in rX]) if rX else E[x] + fmax = min(len(rcap), 8) + if not leq(L[x], FU): + raise ValueError(('empty restore-entry interval', x)) + dmin, dmax = len(L[x]), len(FU) + best2 = None + excluded = [] + for G in (subspaces_between(L[x], rcap) if leq(L[x], rcap) else []): + f = len(G) + if f >= dE or f > fmax or f == dmin: + continue + if not P_at(G, x): + excluded.append(dict(frame=list(G), why='no register can sit at G')) + continue + if departure_impossible(x, G): + excluded.append(dict(frame=list(G), why='departure from G: M[O][Z] full column rank', Z=dep_cache[(x, G)][1])) + continue + dG = len(meet(G, FU)) + for d in range(dmin, min(dmax, dG, f - 1) + 1): + o = c[f - d] + c[dE - f] - c[dE - d] + if best2 is None or o < best2[0]: + best2 = (o, d, f, G) + best3 = None + for d in range(dmin, dmax + 1): + for parts in compositions(dE - d, 3): + if d + parts[0] > fmax: + continue + o = sum(c[a] for a in parts) - c[sum(parts)] + if best3 is None or o < best3[0]: + best3 = (o, d, parts) + if best2 is None and best3 is None: + raise ValueError(('no admissible restore chain', x)) + beta[x] = min(b[0] for b in (best2, best3) if b is not None) + min3[x] = best3[0] if best3 is not None else None + why[x] = dict(two_jump=(dict(overhead=best2[0], entry_dim=best2[1], visit_dim=best2[2], visit_frame=list(best2[3])) + if best2 else None), + three_or_more=(dict(overhead=best3[0], entry_dim=best3[1], jumps=list(best3[2])) if best3 else None), + excluded_two_jump_frames=excluded, entry_dims=[dmin, dmax], first_frame_cap=list(rcap)) + + def blocked_cheap_lifter(h): + """a blocked register has no gate at its entry frame: carrying content upward needs >= 3 restore-phase jumps""" + return min3[h] is None or min3[h] < beta[h] + visit_unit + groups = [] + open_info = {} + for x, st in sorted(status.items()): + if st != 'OPEN' or x in R or not recv.get(x): + continue + FU = meet(U[x], cap[x], E[x]) + feasible = [] + rejected = [] + for F in subspaces_between(L[x], FU): + if len(F) >= 9: + continue + P = P_at(F, x) + if not P: + rejected.append(dict(frame=list(F), why='no reader at F')) + continue + if departure_impossible(x, F): + rejected.append(dict(frame=list(F), why='departure from F: M[O][Z] full column rank', Z=dep_cache[(x, F)][1])) + continue + feasible.append((F, P)) + if not feasible: + groups.append(dict(members=[x], kind='forced-visit', register=x)) + open_info[x] = dict(kind='forced-visit', rejected_skip_frames=rejected) + continue + payers = {x} + charged = True + frames_ = [] + for F, P in feasible: + SF = set(span(F)) + needy = [] + for cc in recv[x]: + if set(span(L[cc])) <= SF: + continue + if any(h in R and (SE[h] & SE[cc]) > SF for h in P): + continue + needy.append(cc) + if not needy: + charged = False + frames_.append(dict(frame=list(F), free=True)) + break + N = [h for h in P if h not in R] + frames_.append(dict(frame=list(F), needy_receivers=needy, carriers=N)) + payers |= set(N) + if not charged: + open_info[x] = dict(kind='free-skip', skip_frames=frames_) + continue + cheap = sorted(h for h in payers if status.get(h) == 'BLOCKED' and blocked_cheap_lifter(h)) + if cheap: + open_info[x] = dict(kind='uncharged (blocked carrier could lift inside its forced visit)', carriers=cheap) + continue + groups.append(dict(members=sorted(payers), kind='zero-sum', register=x)) + open_info[x] = dict(kind='zero-sum', skip_frames=frames_, rejected_skip_frames=rejected) + lifts = [] + for cc in sorted(R): + for q in sorted(M[cc]): + if q == cc or q not in R or not M[cc][q]: + continue + Vq = E[q] + SV = set(span(Vq)) + if leq(E[cc], Vq) or leq(L[cc], Vq): + continue + VE = meet(Vq, E[cc]) + SVE = set(span(VE)) + free = [h for h in live if h in R and h not in (q, cc) and SL[h] <= SVE and not (SE[h] & SE[cc]) <= SV] + if free: + continue + N = sorted(h for h in live if h not in R and SL[h] <= SVE) + if not N or any(status.get(h) == 'BLOCKED' and blocked_cheap_lifter(h) for h in N): + continue + lifts.append(dict(members=N, kind='lift', receiver=cc, source=q, region=list(Vq))) + merged = [] + for grp in groups + lifts: + P = set(grp['members']) + hit = [m for m in merged if m['members'] & P] + mem = set(P) + parts = [grp] + for m in hit: + mem |= m['members'] + parts += m['parts'] + merged = [m for m in merged if m not in hit] + [dict(members=mem, parts=parts)] + merged = sorted(merged, key=lambda m: min(m['members'])) + extras_blocked = sum(beta.values()) + extras_open = len(merged) * visit_unit + return dict(bound=lb['cost'] + extras_blocked + extras_open, LB_forced=lb['cost'], LB_profile={str(k): v for k, v in lb['profile'].items()}, + forced_caps=len(caps), caps={str(r): dict(cap=list(U), receivers=recv[r]) for r, U in sorted(caps.items())}, + blocked=len(beta), extras_blocked=extras_blocked, groups=len(merged), extras_open=extras_open, + beta={str(x): v for x, v in sorted(beta.items())}, why={str(x): v for x, v in sorted(why.items())}, + status={str(x): v for x, v in sorted(status.items())}, info={str(x): v for x, v in sorted(info.items())}, + open_info={str(x): v for x, v in sorted(open_info.items())}, + merged=[dict(members=sorted(m['members']), parts=[dict((k, v) for k, v in p.items() if k != 'members') for p in m['parts']]) + for m in merged], + _lb=lb, _LU=LU, _M=M, _E=E, _rows=rows) + + +# ------------------------------------------------------------------------------------------------ literal itineraries +def literal_restore_chains(w): + """per register: literal frame at restore entry and its literal restore-phase jumps (the auditor's climb order)""" + R_ = w['report']['R'] + n = 2 * V + R_ + start = [(p,) for p in w['ports']] + [()] * (V + R_) + for q, U in w.get('start_extra', {}).items(): + start[int(q)] = basis(tuple(U)) + E = end_frames(w) + cur = [basis(tuple(s)) for s in start] + npre = w.get('prelude_events', 0) + for e in w['A'][:npre]: + if e[0] == 'warp': + cur[e[1]] = basis(tuple(e[4])) + else: + for q in FX.regs_of(e): + cur[q] = basis(tuple(e[-1])) + for e in w['A'][npre:]: + for q in FX.regs_of(e): + cur[q] = basis(tuple(e[-1])) + 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, []): + rec = w['warps'][op - 1] + if cur[rec[1]] != basis(tuple(rec[3])): + raise ValueError(('literal warp frame mismatch', op)) + cur[rec[1]] = basis(tuple(rec[4])) + if p < len(w['B']): + for q in FX.regs_of(w['B'][p]): + cur[q] = basis(tuple(w['B'][p][-1])) + entry = list(cur) + seq = collections.defaultdict(list) + for i, e in enumerate(w['restore']): + for q in FX.regs_of(e): + F = basis(tuple(e[-1])) + if not leq(cur[q], F): + raise ValueError(('literal restore frame not monotone', i, q)) + if len(F) > len(cur[q]): + seq[q].append(('R%d' % i, len(F), len(F) - len(cur[q]))) + cur[q] = F + c = FX.weights() + out = {} + for q in live_registers(w): + if not leq(cur[q], E[q]): + raise ValueError(('literal end frame below current frame', q)) + jumps = list(seq.get(q, [])) + if len(E[q]) > len(cur[q]): + jumps.append(('end', len(E[q]), len(E[q]) - len(cur[q]))) + tot = sum(j for _, _, j in jumps) + ov = sum(c[j] for _, _, j in jumps) - (c[tot] if tot else 0) + out[q] = dict(entry_dim=len(entry[q]), entry_frame=list(entry[q]), jumps=[list(j) for j in jumps], overhead=ov) + return out diff --git a/research/rank7-skip-restore-optimum/run_registered.py b/research/rank7-skip-restore-optimum/run_registered.py new file mode 100644 index 0000000000..a9772619b4 --- /dev/null +++ b/research/rank7-skip-restore-optimum/run_registered.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Registered check (standard library only): complete package inventory (MANIFEST.json) and pins (PINS.json); verify.py +and census.py rerun in a temporary directory, their regenerated receipts byte-equal to certificates/; lane K's stored +receipts (evidence/laneK/: the r12-harness NEGATIVE certificates, the cross-check of lane K's current bound.py and +lbforced.py) bound to this package's recomputation. Structure follows our PR2942/PR2979 run_registered.py (Mason Hale's +PR2917 lineage). Marius-Paul Dumitrean, with substantial AI assistance (Claude Code). +""" +import hashlib +import json +import os +import subprocess +import sys +import tempfile +from pathlib import Path + +P = Path(__file__).resolve().parent +LANEK = {'bound.py': '6b1479b436c4f01bb32f771aa06af3d2260adee5dd5a5e2bf568b0192cee69d8', + 'lbforced.py': 'bd81e3f4460f61ef81e15e76ab25be5f8a9d7b71bb7dcbbf7a87873ca5398341'} + + +def require(ok, message): + if not ok: + raise SystemExit('FAIL: ' + message) + + +def sha(p): + return hashlib.sha256(p.read_bytes()).hexdigest() + + +def tree(): + require(not any(f.is_symlink() for f in P.rglob('*')), 'no symlinks') + return {f.relative_to(P).as_posix(): sha(f) for f in P.rglob('*') + if f.is_file() and f.name != 'MANIFEST.json' and '__pycache__' not in f.parts} + + +def read(rel): + return json.loads((P / rel).read_bytes()) + + +def main(): + manifest = read('MANIFEST.json') + require(tree() == manifest, 'complete package inventory (MANIFEST.json)') + pins = read('PINS.json') + require(all(sha(P / rel) == h for rel, h in pins.items()), 'PINS.json') + with tempfile.TemporaryDirectory(prefix='rank7-skip-restore-') as tmp: + out = Path(tmp) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1') + for key in ('PYTHONOPTIMIZE', 'PYTHONPATH', 'PYTHONSTARTUP'): + env.pop(key, None) + for script in ('verify.py', 'census.py'): + log = out / (script + '.log') + with log.open('w') as stream: + r = subprocess.run([sys.executable, '-B', '-W', 'error', str(P / script), '--work', str(out / 'regen')], + env=env, stdin=subprocess.DEVNULL, stdout=stream, stderr=subprocess.STDOUT, cwd=str(out)) + text = log.read_text() + if r.returncode: + print(text[-6000:]) + raise SystemExit(r.returncode) + print('PASS', script, text.strip().splitlines()[-1][:200], flush=True) + regen = sorted(f.name for f in (out / 'regen').iterdir()) + stored = sorted(f.name for f in (P / 'certificates').iterdir()) + require(regen == stored, 'regenerated receipt set equals certificates/ (%s vs %s)' % (regen, stored)) + for name in regen: + require((out / 'regen' / name).read_bytes() == (P / 'certificates' / name).read_bytes(), 'receipt ' + name) + res = read('certificates/RESULT.json') + require(res['status'] == 'PASS_RANK7_SKIP_RESTORE_OPTIMUM' and res['no_new_kappa'] and res['providers'] == 2, 'RESULT status') + for prov in ('base', 'extra'): + cert = read('certificates/BOUND-3042-%s.json' % prov) + neg = read('evidence/laneK/NEGATIVE-3042-%s.json' % prov) + require(cert['bound'] == cert['certified_cost'] == neg['certified_cost'] == neg['LB_plus_forced'], 'lane K certified cost ' + prov) + require(cert['LB_forced'] == neg['LB_forced'] and cert['LB_profile'] == neg['LB_profile'], 'lane K LB_forced ' + prov) + require(cert['forced_caps'] == neg['forced_caps'] == len(neg['caps']), 'lane K cap count ' + prov) + require(all(cert['caps'][r]['cap'] == v['cap'] and cert['caps'][r]['receivers'] == v['receivers'] for r, v in neg['caps'].items()), + 'lane K caps (frames and receivers) ' + prov) + require(cert['literal_visits'] == neg['visits'] and cert['literal_visit_units'] == neg['sum_forced_extras'], 'lane K visits ' + prov) + require((cert['blocked'], cert['extras_blocked']) == (neg['blocked'], neg['blocked_units']), 'lane K blocked ' + prov) + require(cert['extras_open'] == neg['open_units'] and cert['payer_groups'] == neg['open_but_forced'], 'lane K open-but-forced ' + prov) + cross = read('evidence/laneK/CROSSCHECK.json') + require(cross['status'] == 'PASS_LANEK_CROSSCHECK' and cross['laneK_files'] == LANEK, 'cross-check names the current lane K files') + require(all(sha(P / 'evidence/laneK' / f) == h for f, h in LANEK.items()), 'pinned lane K files') + require(len(cross['rows']) == 8 and all(r['agree'] for r in cross['rows']), 'lane K current bound agrees on 4 words x 2 restores') + require(tree() == manifest, 'inventory unchanged by the replay') + print('PASS_RANK7_SKIP_RESTORE_OPTIMUM_REGISTERED cost=%d LB_forced=%d forced=%d caps=%d (both providers; calibration gap %d; ' + 'no new kappa)' % (res['certified_cost'], res['LB_forced'], res['forced_extras'], res['forced_caps'], res['calibration_gap_2979'])) + + +if __name__ == '__main__': + main() diff --git a/research/rank7-skip-restore-optimum/vendor/audit_local.py b/research/rank7-skip-restore-optimum/vendor/audit_local.py new file mode 100644 index 0000000000..8224873d04 --- /dev/null +++ b/research/rank7-skip-restore-optimum/vendor/audit_local.py @@ -0,0 +1,501 @@ +"""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)< E (used for B-phase warps and for A-phase prelude warps)""" + inv=ginv(cols,h);require(inv is not None,'G not invertible') + require(all(gmul(cols,inv[t])==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<0 else list(to_),list(to_) if op_>0 else list(fr_),h) + require(cur[r_]==basis(fr_),'prelude warp frame mismatch '+str((r_,op_))) + cur[r_]=basis(to_) + else: + for q in registers(e):climb(q,e[-1]) + for e in Aord: + for q in registers(e):climb(q,e[-1]) + lev={int(t):basis(U) for t,U in w.get('target_levels',{}).items()} + require(all(cur[v+t]==lev.get(t,()) for t in range(v)),'target centre levels') + for q,U in zip(w['centers'],w['center_frames']): + U=basis(U);require(cur[q]==U,'center frame') + served={lev.get(e[1]-v,()) for e in w['cut'] if e[2]==q} + for T in sorted(served,key=lambda x:-len(x)): + require(contained(T,U),'center path not nested') + if T!=U:paid[len(U)-len(T)]+=1 + U=T + byposition={} + for op,rec in enumerate(warps,1):byposition.setdefault(rec[0],[]).append(op) + B=w['B'];forward=[] # chronological program of the (recorded) non-target word + for e in Aord:forward.append(e) + for p in range(len(B)+1): + for op in byposition.get(p,[]): + _,lender,cols,U,E=warps[op-1] + require(cur[lender]==basis(U),'warp frame mismatch '+str((op,lender,cur[lender],basis(U)))) + cur[lender]=basis(E);forward.append(['warp',lender,op]) + if p 2: + x /= 2 + k += 1 + lo, hi = log_unit(x) + l2, u2 = log_unit(Q(2)) + lo, hi = lo+k*l2, hi+k*u2 + # Outward rational rounding keeps later certificates compact. + return Q((lo*GRID).__floor__(), GRID), Q((hi*GRID).__ceil__(), GRID) + + +def exp_bounds(x): + require(0 <= x < 1, "exponential range") + term = total = Q(1) + for j in range(1, 13): + term *= x/j + total += term + tail = term*x/13/(1-x/14) + return total, total+tail + + +def moment(m, W, entries, saving): + lo = hi = Q(0) + for t, count in entries: + t, count = int(t), int(count) + require(0 < t < m and count > 0, "improper child") + l, u = log_bounds(Q(m, t)) + lower = exp_bounds(saving*l)[0] + upper = exp_bounds(saving*u)[1] + lo += Q(t*count, m*W)*lower + hi += Q(t*count, m*W)*upper + return Q((lo*GRID).__floor__(), GRID), Q((hi*GRID).__ceil__(), GRID) + diff --git a/research/rank7-skip-restore-optimum/vendor/gk_common.py b/research/rank7-skip-restore-optimum/vendor/gk_common.py new file mode 100644 index 0000000000..0e5fde920d --- /dev/null +++ b/research/rank7-skip-restore-optimum/vendor/gk_common.py @@ -0,0 +1,94 @@ +"""Shared helpers for the complex shared-donor-kernel / entrance-gauge word. Apache-2.0. +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. + +A "gk word" is PR #433's FULL-WORD.json.gz with optional extension keys (absent in #433's word, so every default is +#433's behaviour): + start_extra {register: entrance frame (list of F2^9 vectors)} helpers that start at a nonzero frame (width 9 - dim) + target_levels {target: frame} frame a target reaches through nonzero-frame compensation +Entrance gauges are ordinary gates at the head of A (target += c * helper at the entrance frame); kernel updates are +ordinary gates at the head of A (donor += q * pivot at the entrance frame). +""" +import math +from collections import Counter + +V, K, T, L, M = 120, 4, 8, 9, 73 +DATA = 2 * K * V * T # 7680 +FULL = tuple(1 << i for i in range(8, -1, -1)) + + +def basis(vs): + b = {} + for x in vs: + for p in sorted(b, reverse=True): + if x >> p & 1: x ^= b[p] + if x: + p = x.bit_length() - 1 + for q in b: + if b[q] >> p & 1: b[q] ^= x + b[p] = x + return tuple(b[p] for p in sorted(b, reverse=True)) + + +def widths_of(word): + """residual width of every helper: 9 - dim(entrance frame); 9 when the word has no extension""" + R = word['report']['R'] if 'R' not in word else word['R'] + w = [L] * R + for r, E in word.get('start_extra', {}).items(): + assert 2 * V <= int(r) < 2 * V + R + w[int(r) - 2 * V] = L - len(basis(E)) + return w + + +def split_pad(p): + """a pad of rank p is paid as nested commuting children of rank <= 51 (so that 73^2 > 2*child^2); rank 1 stays 1""" + if p == 0: return [] + n = -(-p // 51); return [p // n + (1 if i < p % n else 0) for i in range(n)] + + +def tile(items): + """Bank tiling of unhosted residuals. items: list of (rep, helper, width); a bank has M = 73 cells. + * width-9 residuals (no wrapper acts on them): first fit in the given order, packed from offset 0, eight per bank, pad rank 1 + (PR #433/#442's tiling and routes [2, slot]); + * ENTERING residuals (width w < 9, paid wrappers, e = 9 - w spectators): banks of their own in which every entering helper is the ONLY + owner of its bank family in its invocation (the one-helper rule of PR #458 extended to banks): bank j holds the j-th entering + helper of each replica, residuals packed from offset 0 in replica order (at most one helper per replica, hence per invocation). + The spectators of an entering helper are the first e cells of the bank beyond every residual cell of the bank (the pad, which no call + uses for a residual, is paid as before: rank 73 - sum of widths; the spectators are borrowed inside it and not deducted). + Returns (assign, banks, pads): assign[(rep, helper)] = (bank, offset, width, pure, spectators) with pure = the bank holds only width-9 + residuals and spectators = () for width 9; pads = Counter of pad ranks (split into children of rank <= 51).""" + assign = {}; pads = Counter(); fill = [] + for z, (rep, h, w) in enumerate(items): # width 9: first fit, as PR #433 (all widths 9 reproduces it exactly) + if w != L: continue + for b, f in enumerate(fill): + if f + w <= M: break + else: + b = len(fill); fill.append(0) + assign[(rep, h)] = (b, fill[b], w, True, ()); fill[b] += w + nwide = len(fill); byrep = {} + for rep, h, w in items: + if w < L: byrep.setdefault(rep, []).append((h, w)) + cells = [0] * max((len(v) for v in byrep.values()), default=0); emax = [0] * len(cells); place = {} + for rep in sorted(byrep): # the j-th entering helper of every replica goes to entering bank j + for j, (h, w) in enumerate(byrep[rep]): + place[(rep, h)] = (nwide + j, cells[j], w); cells[j] += w; emax[j] = max(emax[j], L - w) + for j in range(len(cells)): assert cells[j] + emax[j] <= M, ('entering bank without room for its spectators', j) + for (rep, h), (b, off, w) in place.items(): + assign[(rep, h)] = (b, off, w, False, tuple(range(cells[b - nwide], cells[b - nwide] + L - w))) + fill += cells + for f in fill: + for part in split_pad(M - f): pads[part] += 1 + return assign, len(fill), pads + + +def route(off, w, pure, sp=()): + """owner route of a banked helper residual: PR #433's [2, slot] for width 9 (pure width-9 bank); an entering helper (w < 9) is + [2, offset, width, [spectator cells]] with e = 9 - w spectators""" + if w == L: assert pure and not sp; return [2, off // L] + assert not pure and len(sp) == L - w; return [2, off, w, list(sp)] + + +def unhosted_stock(widths): + """live stock and padding histogram of the unhosted (parent) template, per stage x nine""" + R = len(widths) + _, nb, pads = tile([(rep, h, widths[h]) for rep in range(T) for h in range(R)]) + return DATA + L * nb, Counter({r: z * L for r, z in pads.items()}) diff --git a/research/rank7-skip-restore-optimum/vendor/moment.py b/research/rank7-skip-restore-optimum/vendor/moment.py new file mode 100644 index 0000000000..7d697cb452 --- /dev/null +++ b/research/rank7-skip-restore-optimum/vendor/moment.py @@ -0,0 +1,113 @@ +"""Independent prospective ordinary five-stage cost, never supplier admission. + +Consumes a raw one-invocation ledger made from the actual source/internal/target +paths. No packed profile is used as an input. Missing physical/finite/compiler +obligations must remain explicit in the accompanying report. +""" +from collections import Counter +from decimal import Decimal, localcontext, ROUND_FLOOR +from fractions import Fraction as F +from functools import lru_cache +from math import factorial +import hashlib, json, sys +from pathlib import Path + +DYAD = 1 << 224 + +def floor(x): return F(x.numerator*DYAD//x.denominator, DYAD) +def ceil(x): return -floor(-x) + +@lru_cache(None) +def logarithm(x): + """Mercator bounds after binary reduction; ln(2) via two Mercator sums. + + For 1 <= y < 2, log(y) is an alternating series in z=y-1. + We instead reduce to 1 <= y < 3/2, and bound log(3/2) and + log(2) by the same alternating series at z=1/2 and z=1/3, + using log(2)=log(3/2)+log(4/3). All sums are exact rationals. + """ + assert x >= 1 + k = 0 + while x >= 2: x /= 2; k += 1 + j = int(x >= F(3, 2)) + if j: x /= F(3, 2) + def mercator(y): + z=y-1 + assert 0 <= z <= F(1,2) + # An even partial sum is below log; the next term bounds its tail. + t=z; s=F(0) + for n in range(1, 225): + s += (t if n & 1 else -t)/n + t *= z + return s, s+t/225 + a,b=mercator(x); c,d=mercator(F(3,2)); e,f=mercator(F(4,3)) + return floor(a+(k+j)*c+k*e), ceil(b+(k+j)*d+k*f) + +def exponential(l,u): + assert 0 <= l <= u < F(1,10) + def poly(x): + s=t=F(1) + for j in range(1,25): t=t*x/j; s+=t + return s,t + lo,_=poly(l);hi,last=poly(u) + return floor(lo),ceil(hi+last*u/25/(1-u/26)) + +def moment(H,m,W,a,bad=False): + lo=hi=F(0) + for r,n in H.items(): + assert 0 < r < m and n > 0 + l,u=logarithm(F(m,r)); e,f=exponential(a*l,a*u) + p=F(r*n,m*W);lo+=p*e;hi+=p*f + if bad: + # Existing envelope shape, only conditionally portable to the new cover. + l,u=logarithm(F(m));e,f=exponential(a*l,a*u) + p=F(32*m*sum(H.values()),10**16*W) + lo+=p*e;hi+=p*f + return floor(lo),ceil(hi) + +def decimal(x): + with localcontext() as c: + c.prec=70 + return str(Decimal(x.numerator)/Decimal(x.denominator)) + +def certify(H,m,W,bad=False): + with localcontext() as c: + c.prec=70 + terms=[(Decimal(r*n)/Decimal(m*W),(Decimal(m)/Decimal(r)).ln()) for r,n in H.items()] + fallback=Decimal(32*m*sum(H.values()))/Decimal(10**16*W) if bad else Decimal(0) + lm=Decimal(m).ln();lo=Decimal(0);hi=Decimal('.003') + for _ in range(210): + a=(lo+hi)/2 + if sum(p*(a*l).exp() for p,l in terms)+fallback*(a*lm).exp()<1:lo=a + else:hi=a + q=int(((lo+hi)/2*10**24).to_integral_value(rounding=ROUND_FLOOR)) + lo=F(q,10**24);hi=lo+F(1,10**24) + lv=moment(H,m,W,lo,bad);hv=moment(H,m,W,hi,bad) + assert lv[1]<1= LB_forced + forced extras = %d = certified cost of WORD-%s.') % (name, b['bound'], name), + seconds=None) + return cert, dict(sol=sol, rows=rows, M=Mc, b=b, lit=lit, seconds=round(time.monotonic() - t0, 2)) + + +def normal45_facts(w, b): + """the four normal-45 visits: eight pairwise-distinct 6-dim entry lower bounds inside V45; no partner""" + LU = b['_LU'] + E = b['_E'] + V45 = E[NORMAL45['pivots'][0]] + eight = NORMAL45['visitors'] + NORMAL45['pivots'] + require(all(E[p] == V45 and len(V45) == 7 for p in NORMAL45['pivots']), 'pivots end at V45') + Ls = {q: LU[q][0] for q in eight} + require(all(len(Ls[q]) == 6 and FX.leq(Ls[q], V45) for q in eight), 'eight 6-dim entry frames inside V45') + require(len(set(Ls.values())) == 8, 'pairwise distinct') + require(len(FX.basis(tuple(v for q in eight for v in Ls[q]))) == 7, 'they span V45') + live = [q for q in LU if not RB.is_target(q)] + rows = [] + for r in NORMAL45['visitors']: + recv = b['caps'][str(r)]['receivers'] + for c in recv: + X = FX.meet(LU[r][1], E[c]) + require(X == Ls[r], 'U_r meet E_c = L_r for visitor %d receiver %d' % (r, c)) + require(not any(s != r and FX.leq(LU[s][0], Ls[r]) and FX.leq(Ls[r], E[s]) for s in live), 'no partner for %d' % r) + rows.append(dict(register=r, receivers=recv, entry_lower=list(Ls[r]), beta=b['beta'][str(r)])) + return dict(V45=list(V45), entry_lower_bounds={str(q): list(Ls[q]) for q in eight}, visitors=rows) + + +# ------------------------------------------------------------------------------------------------ calibration and erratum +def calibration(name): + """the same bound on PR #2979's words (same A/B): the unforced part of its restore overhead is exactly what PR #3042 removed""" + w = load_word(name) + sol = FX.frame_optimum(w) + require(sol['cost'] == EXPECT['cost2979'] and iprof(sol['profile']) == PR2979_PROFILE, 'PR2979 certified optimum') + b = RB.bound(w) + lit = RB.literal_restore_chains(w) + visits = {q: x['overhead'] for q, x in lit.items() if x['overhead']} + beta = {int(x): v for x, v in b['beta'].items()} + unit = 2 * FX.weights()[1] - FX.weights()[2] + blocked_excess = {str(q): visits.get(q, 0) - v for q, v in sorted(beta.items()) if visits.get(q, 0) != v} + require(all(visits.get(q, 0) >= v for q, v in beta.items()), 'every blocked register pays at least its forced extra') + in_group = set() + group_excess = [] + for m in b['merged']: + vis = {q: visits[q] for q in m['members'] if q in visits and q not in beta} + require(sum(vis.values()) >= unit, 'every payer group pays at least one visit') + in_group |= set(vis) + if sum(vis.values()) > unit: + group_excess.append(dict(members_visiting={str(q): v for q, v in sorted(vis.items())}, forced=unit, + excess=sum(vis.values()) - unit, kinds=sorted({p['kind'] for p in m['parts']}))) + uncharged = {str(q): v for q, v in sorted(visits.items()) if q not in beta and q not in in_group} + total = sum(blocked_excess.values()) + sum(g['excess'] for g in group_excess) + sum(uncharged.values()) + involved = sorted({int(q) for q in blocked_excess} | {int(q) for q in uncharged} | + {int(q) for g in group_excess for q in g['members_visiting']}) + require(b['bound'] == EXPECT['cost'] and sol['cost'] - b['bound'] == total == EXPECT['cost2979'] - EXPECT['cost'], 'PR2979 bound') + require(set(SKIPS_3042) <= set(involved) and total == len(SKIPS_3042) * unit, 'unforced overhead = the six PR3042 skips') + return dict(word=name, word_sha256=PINS['data/WORD-%s.json.gz' % name], certified_cost=sol['cost'], certified_profile=sprof(sol['profile']), + LB_forced=b['LB_forced'], bound=b['bound'], gap=sol['cost'] - b['bound'], literal_visits=len(visits), + literal_visit_units=sum(visits.values()), blocked_excess=blocked_excess, group_excess=group_excess, + uncharged_visits=uncharged, unforced_total=total, registers_involved=involved, pr3042_skips=SKIPS_3042, + realized_by_pr3042=EXPECT['cost2979'] - EXPECT['cost']) + + +def erratum(): + spec = json.loads((HERE / 'data/EDITS-3042.json').read_bytes()) + out = {} + for prov in ('base', 'extra'): + w = load_word('2979-' + prov) + f = load_word('3042-' + prov) + c0 = FX.frame_optimum(w) + lit0 = RB.literal_restore_chains(w) + edits = {e['id']: e for e in spec['edits'][prov]} + require(sorted(edits) == ['R1_E42', 'R2_E7'], 'two declared blocks') + + def apply(ids): + x = copy.deepcopy(w) + for e in sorted((edits[i] for i in ids), key=lambda e: -e['start']): + require(e['section'] == 'restore' and x['restore'][e['start']:e['stop']] == e['old'], 'literal preimage ' + e['id']) + x['restore'][e['start']:e['stop']] = copy.deepcopy(e['new']) + return x + rows = {} + for ids in (['R1_E42'], ['R2_E7'], ['R1_E42', 'R2_E7']): + x = apply(ids) + s = FX.frame_optimum(x) + lit = RB.literal_restore_chains(x) + changed = sorted(q for q in lit if lit[q]['overhead'] != lit0[q]['overhead']) + dp = {str(k): iprof(s['profile']).get(k, 0) - iprof(c0['profile']).get(k, 0) for k in range(1, 9) + if iprof(s['profile']).get(k, 0) != iprof(c0['profile']).get(k, 0)} + rows['+'.join(ids)] = dict(delta_units=s['cost'] - c0['cost'], profile_delta=dp, skipped_registers=changed, + literal_skip_units=sum(lit0[q]['overhead'] - lit[q]['overhead'] for q in changed)) + if len(ids) == 2: + require(x['restore'] == f['restore'] and all(x[k] == f[k] for k in f if k not in ('restore', 'report', 'cleanup')), + 'both blocks reproduce the PR3042 word') + require(rows['R1_E42']['delta_units'] == -19984 and rows['R1_E42']['skipped_registers'] == [22, 40, 54, 63], 'R1_E42') + require(rows['R2_E7']['delta_units'] == -9992 and rows['R2_E7']['skipped_registers'] == [5, 73], 'R2_E7') + require(rows['R1_E42+R2_E7']['delta_units'] == -29976, 'total') + out[prov] = rows + require(out['base'] == out['extra'], 'providers agree') + sizes = {e['id']: '%d -> %d' % (len(e['old']), len(e['new'])) for e in spec['edits']['base']} + require(sizes == {'R1_E42': '26 -> 33', 'R2_E7': '13 -> 15'}, 'declared block sizes') + return dict(certified=out['base'], providers_identical=True, declared_block_gates=sizes, pr3042_readme=PR3042_README, + corrections=dict(R1_E42='-19,984 units/call (four skips: 63, 54, 40, 22; -8 H1 + 4 H2), not -14,888 for 63, 54, 40', + R2_E7='-9,992 units/call (two skips: 73, 5; -4 H1 + 2 H2), not -14,938 for 22, 73, 5', + total='-29,976 units/call (-12 H1 + 6 H2 = 6 x 4,996), not -29,826; final words, profile and kappa unaffected')) + + +# ------------------------------------------------------------------------------------------------ controls +def controls(state): + w = load_word('3042-base') + st = state['3042-base'] + rows, sol, b = st['rows'], st['sol'], st['b'] + base = sol['cost'] + out = {} + # auditor semantics: appended gates between non-restored FULL registers pass with cost delta 0 + sem = [] + for g in (['add', 0, 1, 1, 1, list(FX.FULL9)], ['add', 62, 70, 1, 1, list(FX.FULL9)]): + x = copy.deepcopy(w) + x['restore'].append(g) + r = price_and_audit(x, rows, base) + require(r['exact'] and r['delta'] == 0 and r['auditor']['status'] == 'PASS_INDEPENDENT_EXACT_BORROWING_WORD', 'appended ' + str(g[:5])) + sem.append(dict(appended=g[:5], **r)) + x = copy.deepcopy(w) + x['restore'].append(['add', 249, 251, 1, 1, list(b['_E'][249])]) + r = price_and_audit(x, rows, base) + require(not r['exact'] and r['auditor']['status'] == 'FAIL', 'a gate into a restored helper is rejected') + sem.append(dict(appended=['add', 249, 251, 1, 1], **r)) + out['auditor_semantics'] = sem + # attainment: two third-party restore rewrites (different gate sequences) tie the bound + att = [] + for label, block in (('PR3056 three-ADD contraction of restore[175:179]', PR3056_175), ('PR3060 four-gate tariff word of restore[175:179]', PR3060_175)): + x = copy.deepcopy(w) + require(x['restore'][175:179] == OLD_175, 'literal block') + x['restore'][175:179] = copy.deepcopy(block) + r = price_and_audit(x, rows, base) + require(r['exact'] and r['delta'] == 0 and r['auditor']['status'] == 'PASS_INDEPENDENT_EXACT_BORROWING_WORD', label) + att.append(dict(control=label, gates=len(x['restore']), **r)) + out['attainment'] = att + rej = [] + + def rejected(label, fn): + try: + fn() + except (AssertionError, ValueError, KeyError) as ex: + rej.append(dict(control=label, rejected=True, reason=str(ex)[:160])) + return + raise AssertionError('control was not rejected: ' + label) + # 1-2 source binding + rejected('mislabeled provider (extra export under the base pin)', + lambda: require(sha(HERE / 'data/WORD-3042-extra.json.gz') == PINS['data/WORD-3042-base.json.gz'], 'pinned export mismatch')) + raw = bytearray((HERE / 'data/WORD-3042-base.json.gz').read_bytes()) + raw[len(raw) // 2] ^= 1 + rejected('one flipped byte in the base export', lambda: require(hashlib.sha256(bytes(raw)).hexdigest() == PINS['data/WORD-3042-base.json.gz'], 'pinned export mismatch')) + # 3 wrong cap: weakening one forced cap lowers LB_forced below the cost, and the recomputed caps differ + caps = {int(r): tuple(v['cap']) for r, v in b['caps'].items()} + weak = dict(caps) + weak.pop(2) + lb_weak = FX.frame_optimum(RB.empty_restore(w), caps=weak)['cost'] + require(lb_weak < b['LB_forced'], 'the cap of register 2 is load-bearing') + rejected('certificate with the cap of register 2 dropped (LB %d)' % lb_weak, + lambda: require(lb_weak + b['extras_blocked'] + b['extras_open'] == base and len(weak) == len(caps), 'tight sum fails without the cap')) + # 4 dropped visit + rejected('certificate with the forced visit of register 44 dropped', + lambda: require(b['LB_forced'] + b['extras_blocked'] - b['beta']['44'] + b['extras_open'] == base, 'tight sum fails')) + # 5 perturbed entry row + def perturbed(): + rows2 = {q: dict(v) for q, v in rows.items()} + rows2[70] = dict(rows2[70]) + rows2[70][(70, ())] = rows2[70][(70, ())] * 2 + Mc2, rk2 = RB.coordinates(rows2, {x: {(x, ()): Q(1)} for x in RB.restored(w)}) + rmap = RB.restore_map(w) + require(all({q: v for q, v in rmap[x].items() if v} == Mc2[x] for x in RB.restored(w)), 'restore does not realize the perturbed coordinates') + rejected('perturbed restore-entry row of register 70', perturbed) + # 6-8 fake cheaper restores that violate exactness (cheaper certified frames, rejected by Lemma 1 and by the auditor) + fakes = [] + for label, edit in (('empty restore', lambda x: x.__setitem__('restore', [])), + ('deleted R44 475 += -1/2*498 (keeps a restored input in 475)', lambda x: x['restore'].pop(44)), + ('deleted R82 584 += -1*439 (restored 584 not its own input)', lambda x: x['restore'].pop(82))): + x = copy.deepcopy(w) + edit(x) + r = price_and_audit(x, rows, base) + require(r['feasible'] and r['delta'] < 0, 'fake restore is cheaper: ' + label) + require(not r['exact'] and r['auditor']['status'] == 'FAIL', 'fake restore rejected twice: ' + label) + fakes.append(dict(control=label, **r)) + rejected('fake cheaper restore: %s (delta %d)' % (label, r['delta']), + lambda r=r: require(r['exact'], 'Lemma 1 end conditions fail (%d dirty restored, %d leaks); auditor: %s' % ( + r['dirty'], r['leaks'], r['auditor'].get('reason', '')))) + out['fake_cheaper_restores'] = fakes + # 9 wrong claimed cost + rejected('claimed cost 10,868,103,086', lambda: require(base == 10868103086, 'recomputed certified cost differs')) + # 10 optimality claim for PR2979's words (calibration: the bound leaves a gap) + rejected('optimality claimed for PR2979 base', lambda: require(state['2979-base']['gap'] == 0, 'PR2979 gap 29,976')) + # 11 ablation of the departure lemma: rows restricted to receivers containing the frame + abl = ablation(w, b) + rejected('departure lemma with rows restricted to receivers containing the frame (bound %d)' % abl['bound'], + lambda: require(abl['bound'] == base, 'the restricted lemma no longer certifies optimality')) + # 12 caps taken from the restore map of the emptied word (lane K's fixed bug class) instead of forced coordinates + w0 = RB.empty_restore(w) + caps_bug, _ = RB.forced_caps(RB.restore_map(w0), b['_E'], RB.restored(w0)) + b0 = RB.bound(w0) + require(b0['bound'] == base and b0['forced_caps'] == EXPECT['caps'], 'the bound depends only on A/B (caps from coordinates)') + rejected('caps from the restore map of the emptied word (%d caps)' % len(caps_bug), lambda: require(len(caps_bug) == EXPECT['caps'], 'no caps')) + out['rejection'] = rej + out['ablation'] = abl + out['empty_restore_word_bound'] = dict(bound=b0['bound'], forced_caps=b0['forced_caps']) + require(len(rej) >= 8, 'rejection controls') + return out + + +def ablation(w, b): + """departure test with rows restricted to restored c whose end contains the departure frame: the (1,3) splits of the + eight (2,2) registers are admitted and the bound drops by 8 x (c2 + c2 - c4 - (c1 + c3 - c4))""" + c = FX.weights() + E = b['_E'] + LU = b['_LU'] + M = b['_M'] + R = RB.restored(w) + live = [q for q in LU if not RB.is_target(q)] + drop = 0 + admitted = [] + for x, why in b['why'].items(): + x = int(x) + for ex in why['excluded_two_jump_frames']: + if 'departure' not in ex['why']: + continue + G = tuple(ex['frame']) + SG = set(FX.span(G)) + Z = [x] + [y for y in live if y != x and set(FX.span(LU[y][0])) <= SG] + O = [cc for cc in sorted(R) if cc != x and FX.leq(G, E[cc]) and not FX.leq(E[x], E[cc])] + mat = [[M[cc].get(q, Q(0)) for q in Z] for cc in O] + if RB.rank([r_ for r_ in mat if any(r_)]) < len(Z): + dE = len(E[x]) + d = len(LU[x][0]) + f = len(G) + o = c[f - d] + c[dE - f] - c[dE - d] + if o < b['beta'][str(x)]: + admitted.append(dict(register=x, frame=list(G), overhead=o, beta=b['beta'][str(x)])) + best = {} + for a in admitted: + best[a['register']] = min(best.get(a['register'], a['beta']), a['overhead']) + drop = sum(b['beta'][str(x)] - v for x, v in best.items()) + return dict(admitted=admitted, registers=sorted(best), bound=b['bound'] - drop, drop=drop) + + +# ------------------------------------------------------------------------------------------------ main +def canonical(x): + return json.dumps(x, indent=1, sort_keys=True, default=str) + '\n' + + +def strip(cert): + return {k: v for k, v in cert.items() if not k.startswith('_') and k != 'seconds'} + + +def main(): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument('--work', type=Path, help='write RESULT.json and the regenerated certificates here') + a = ap.parse_args() + t0 = time.monotonic() + n = authenticate() + certs = {} + state = {} + for prov in ('base', 'extra'): + name = '3042-' + prov + cert, st = certify(name, load_word(name)) + certs['BOUND-%s.json' % name] = strip(cert) + state[name] = st + print('PASS', name, 'cost', cert['certified_cost'], '= LB_forced', cert['LB_forced'], '+ forced', cert['extras_blocked'] + cert['extras_open'], + '(caps %d, blocked %d, groups %d, visits %d)' % (cert['forced_caps'], cert['blocked'], cert['payer_groups'], cert['literal_visits']), + st['seconds'], 's', flush=True) + a_ = dict(certs['BOUND-3042-base.json']) + b_ = dict(certs['BOUND-3042-extra.json']) + for k in ('word', 'word_sha256', 'theorem'): + a_.pop(k) + b_.pop(k) + require(canonical(a_) == canonical(b_), 'both providers give the identical certificate') + cal = {} + for prov in ('base', 'extra'): + cal[prov] = calibration('2979-' + prov) + state['2979-' + prov] = dict(gap=cal[prov]['gap']) + require({k: v for k, v in cal['base'].items() if k not in ('word', 'word_sha256')} == + {k: v for k, v in cal['extra'].items() if k not in ('word', 'word_sha256')}, 'calibration agrees') + certs['CALIBRATION-2979.json'] = cal + print('PASS calibration: bound on PR2979 words', cal['base']['bound'], 'gap', cal['base']['gap'], '= unforced overhead of', + cal['base']['registers_involved'], flush=True) + err = erratum() + certs['ERRATUM-3042.json'] = err + print('PASS erratum: R1_E42', err['certified']['R1_E42']['delta_units'], err['certified']['R1_E42']['skipped_registers'], + 'R2_E7', err['certified']['R2_E7']['delta_units'], err['certified']['R2_E7']['skipped_registers'], flush=True) + ctl = controls(state) + certs['CONTROLS.json'] = ctl + print('PASS controls: auditor semantics %d, attainment %d, rejection %d, ablation drop %d' % ( + len(ctl['auditor_semantics']), len(ctl['attainment']), len(ctl['rejection']), ctl['ablation']['drop']), flush=True) + result = dict(status='PASS_RANK7_SKIP_RESTORE_OPTIMUM', providers=2, pinned_inputs=n, certified_cost=EXPECT['cost'], + LB_forced=EXPECT['lb'], forced_caps=EXPECT['caps'], forced_extras=EXPECT['forced'], blocked=EXPECT['blocked'], + payer_groups=EXPECT['groups'], calibration_gap_2979=cal['base']['gap'], rejection_controls=len(ctl['rejection']), + certificates={k: hashlib.sha256(canonical(v).encode()).hexdigest() for k, v in sorted(certs.items())}, + no_new_kappa=True) + if a.work: + a.work.mkdir(parents=True, exist_ok=True) + for k, v in certs.items(): + (a.work / k).write_text(canonical(v)) + (a.work / 'RESULT.json').write_text(canonical(result)) + else: + for k, v in list(certs.items()) + [('RESULT.json', result)]: + stored = (HERE / 'certificates' / k).read_text() + require(stored == canonical(v), 'regenerated certificate differs from certificates/' + k) + print('PASS_RANK7_SKIP_RESTORE_OPTIMUM providers=2 cost=%d LB_forced=%d forced=%d caps=%d blocked=%d groups=%d rejections=%d ' + 'calibration_gap=%d no_new_kappa (%.1f s)' % (EXPECT['cost'], EXPECT['lb'], EXPECT['forced'], EXPECT['caps'], EXPECT['blocked'], + EXPECT['groups'], len(ctl['rejection']), cal['base']['gap'], time.monotonic() - t0)) + + +if __name__ == '__main__': + main()