diff --git a/research/rank7-group-b-native-widths-audit/MASTER-HANDOFF.md b/research/rank7-group-b-native-widths-audit/MASTER-HANDOFF.md new file mode 100644 index 0000000000..ed2e0e6841 --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/MASTER-HANDOFF.md @@ -0,0 +1,82 @@ +# Master handoff: rank7-group-b-native-widths-audit + +## Result + +Group B of #2979: both providers and both orientations emit residual pairs +`0:260` (helper 299, cold, width **7**) and `114:260` (helpers 448/449/484/485, +entrance `[51]`, width **6**) under shared +`W = ⟨256,128,64,34,17,11,4⟩`. Adapter and `LOCAL-CHECKS` hashes match the +retained `FULL-NATIVE-RECEIPT.json`. These widths join all **3330** T74 fill +placements. No new kappa. + +**Not headlined (soft-overlap trap):** guide margins `+42541` / single-299 +`-58943` — already on deferred tip `f795116d` and in `#2979` `STAGE-PRICES.json` +/ group-A registered margins. Do not open a CrocSwap PR that reprints them. + +## Pins + +- Base / selected main: `6f100d4bb5083f8c35d96fd95a539811c62f245c` +- Selected κ: `0.001672660197076918` +- Task card: `independent-moment` (priority revision 6) +- Predecessor head #2979: `be191346391661f4d35fc0d1508d0a6029572576` +- Branch: `cursor/group-b-native-widths-60b9` +- Content tip SHA: `5241640244d2521818a6fe3b1f6c34e99d67a4e3` +- Publish tip (package+handoff): branch HEAD of `cursor/group-b-native-widths-60b9` (content package commit `5241640244d2521818a6fe3b1f6c34e99d67a4e3`; docs-only handoff commits may follow) +- Package: `research/rank7-group-b-native-widths-audit/` + +## Exact commands + +```sh +python3 -I -B research/rank7-group-b-native-widths-audit/verify.py +python3 -I -O -B research/rank7-group-b-native-widths-audit/verify.py +python3 -I -B research/rank7-group-b-native-widths-audit/test_verify.py -v +python3 -I -B scripts/research_package.py --package research/rank7-group-b-native-widths-audit --check-only +python3 -I -B scripts/research_package.py --package research/rank7-group-b-native-widths-audit +``` + +## Expected PASS lines + +```text +PASS_GROUP_B_NATIVE_WIDTHS providers=2 helpers=5 residual_widths=7,6,6,6,6 pairs=299:0:260,448:114:260,449:114:260,484:114:260,485:114:260 placements=3330 adapter_pinned both_orientations no_new_kappa +PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check) +PASS_REGISTERED_RESEARCH_PACKAGE research/rank7-group-b-native-widths-audit outcome=partial +``` + +(`-O` verify must print the same `PASS_GROUP_B_NATIVE_WIDTHS` line; `need`/`require` +admission stays enforced.) + +## Closest priors + +| Prior | Relation | +|---|---| +| `research/rank7-group-a-entrance-audit/` | Methodology predecessor (native section); different helpers/W | +| `research/rank7-joint-endframes/` (#2979 @ `be191346…`) | Source WORD / FULL-NATIVE / adapters | +| `research/rank7-group-b-single-control-audit/` (`f795116d`) | Deferred soft-overlap margins; this package answers its native OQ | +| #2993 `rank7-joint-frame-audit` | Frame invoices; not imported | + +## What is new vs soft-overlap traps + +- **New:** phase-exact residual classes `0:260` / `114:260`, entrance `[51]` vs + cold `[]`, climb/wrapper/scalar clocks in both orientations, adapter pin + match, native-width → T74 join for helpers `{299,448,449,484,485}`. +- **Do not claim as new:** joint/single guide margins, width inventory + `7/6/6/6/6` alone without native residual binding, or 3330 placements alone + (those were the deferred single-control headline). + +## Open next questions + +1. Complete peer-native / private-cleanup dependency closure for group B. +2. Physical movement, precision/tape, supplier caps and outer release for the + unchanged #2979 source. + +## Leave-alone + +Open CrocSwap #3392, #3386, #3374, #3349; deferred V45 `1910fd12`; deferred +group-B single-control `f795116d`; blocked W=532 unpaid F17 terms; merged +tariff series through #2883; do not reprint #3259 / `p104-pooled-cut-independent`. + +## Attribution + +Wentao Li ``. Prepared by Wentao Li with substantial AI +assistance. No `Co-authored-by: Victor Li`. Do **not** open a CrocSwap PR from +this worker (master publishes). diff --git a/research/rank7-group-b-native-widths-audit/NOTICE.md b/research/rank7-group-b-native-widths-audit/NOTICE.md new file mode 100644 index 0000000000..dfd2cb6d02 --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/NOTICE.md @@ -0,0 +1,24 @@ +# NOTICE + +This package is licensed under the Apache License, Version 2.0. +It consumes pinned source archives from `research/rank7-joint-endframes/` +(PR #2979 and attributed predecessors) and reuses the native-binding +methodology of `research/rank7-group-a-entrance-audit/` without modifying +those packages. + +Predecessor credit (do not alter historical notices elsewhere): + +- Marius-Paul Dumitrean / mdumitrean #2979 — joint rank-7 end-frames, WORD / + FULL-NATIVE / RESIDUAL-ADAPTER receipts. +- DreamingOfClouds / PR458 lineage — `bw_transport` / `bw_emit` residual + producer (producer only; not independent evidence). +- Sagar Thakrar — retained Gaussian-integer exact kernel + (`frontier1094-recipes-exact-seed76/clifford.py`). +- Nick Petalas / group-A entrance audit — mixed-entrance native binding pattern + adapted here to group B. +- Deferred fork tip `f795116d` (`rank7-group-b-single-control-audit`) — already + registered STAGE-PRICES margins; this package answers its native-binding open + question and does not reprint those margins. + +Author: Wentao Li +Prepared by Wentao Li with substantial AI assistance. diff --git a/research/rank7-group-b-native-widths-audit/README.md b/research/rank7-group-b-native-widths-audit/README.md new file mode 100644 index 0000000000..a76fd6e2ee --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/README.md @@ -0,0 +1,103 @@ +# Group B's native residual widths through the shipped T74 fill + +**Finite native/interface audit; no new kappa or supplier admission.** + +Both literal PR2979 providers pass the mixed-entrance check for group B. +Helpers 448, 449, 484 and 485 enter at `[51]` and end at +`W = [256,128,64,34,17,11,4]`. Their emitted residual width is **six**, not +the terminal dimension seven. Helper 299 enters at zero and uses width +**seven**. Exact native identities include global phase and both orientations. +These widths bind to all 3,330 group-B placements in the shipped T74 +allocation. Adapter and `LOCAL-CHECKS` hashes match the retained +`FULL-NATIVE-RECEIPT.json`. + +This package deliberately does **not** headline the already-registered guide +margins `+42541` / single-299 `-58943`. Those facts reprint `#2979` +`STAGE-PRICES.json` and match the deferred soft-overlap tip `f795116d` +(`research/rank7-group-b-single-control-audit/`). The contribution here is the +native residual / wrapper binding that tip left open. + +### Existing coverage and the added check + +`research/rank7-group-a-entrance-audit/` already binds group A's native +residuals for helpers 331/450/451/508/509 under a different shared word +`W_A = [256,128,64,38,20,10,1]`. Group B is outside that package. + +The deferred group-B single-control audit already checked joint versus +single-299 guide margins and placement counts. It recorded an open question +asking whether emitted mixed-entrance wrappers and native residual recipes +match widths `7/6/6/6/6` in both orientations. This package answers that +question with an independent source-bound native replay. + +## Exact native statement and source binding + +The source is [PR2979][2979] at +`be191346391661f4d35fc0d1508d0a6029572576`; the base is canonical main +`6f100d4bb5083f8c35d96fd95a539811c62f245c`, priority revision 6 +(κ = `0.001672660197076918`). [SOURCES.json](SOURCES.json) records exact Git +blobs and SHA256 hashes. The native producer, exact kernel and retained +emitter are authenticated before execution. No frozen predecessor is modified. + +For entrance `E` and terminal `U`, write the native residual as +`S(E,U) = T_U T_E^-1`. The source compiler produces `S = L F_w R`, where +`F_w` is the retained coordinate Fourier primitive on the first `w` address +axes. A separate exact Gaussian-integer kernel checks all 512 columns of +that identity, and the emitted inverse wrappers satisfy + +```text +L^-1 S(E,U) R^-1 = F_w, +w = dim(U) - dim(E). +``` + +| Helper(s) | Entrance | Parent terminal dimension | Parent width | Joint/final width | +|---|---|---:|---:|---:| +| 299 | zero | 8 | 8 | 7 | +| 448, 449, 484, 485 | span(51) | 8 | 7 | 6 | + +Here `51 = 34 xor 17` lies in the span of `W`. Treating the entering helpers +as cold would select the wrong native operator even if a rank field were +edited to six. The cold right wrapper and the entering right wrapper are not +interchangeable: the all-column check rejects that substitution. A different +contained line, `[4]`, has the same dimension but also fails with the actual +`[51]` recipe. + +The verifier regenerates both complete emitted programs with the unchanged +transport/emitter and reconstructs the full serialized adapter file using +the original generation convention. The uncompressed `LOCAL-CHECKS.json` +and `RESIDUAL-ADAPTERS.json` hashes match PR2979's retained native receipt. +Both regenerated event streams also match the counts and canonical event +digests inside that pinned receipt. + +## Reproduction + +```sh +python3 -I -B research/rank7-group-b-native-widths-audit/verify.py +python3 -I -O -B research/rank7-group-b-native-widths-audit/verify.py +python3 -I -B research/rank7-group-b-native-widths-audit/test_verify.py -v +python3 -I -B scripts/research_package.py --package research/rank7-group-b-native-widths-audit --check-only +python3 -I -B scripts/research_package.py --package research/rank7-group-b-native-widths-audit +``` + +Expected verify line: + +```text +PASS_GROUP_B_NATIVE_WIDTHS providers=2 helpers=5 residual_widths=7,6,6,6,6 pairs=299:0:260,448:114:260,449:114:260,484:114:260,485:114:260 placements=3330 adapter_pinned both_orientations no_new_kappa +``` + +## Open next questions + +1. Can the checked group-B direct paths and endpoints be joined to the + complete native dependency closure of their private cleanup? +2. Do the complete physical, precision/tape and outer obligations admit the + unchanged PR2979 source after independent review? + +## Credit + +Builds on #2979 (Dugongue / mdumitrean), the DreamingOfClouds / PR458 emitter +lineage, Sagar Thakrar's exact kernel, Nick Petalas's group-A entrance native +audit, and the deferred group-B single-control tip `f795116d` (which this +package does not reprint). New check by Wentao Li. Apache-2.0. + +Prepared by Wentao Li with substantial AI assistance. + +[2979]: https://github.com/CrocSwap/integer-mult-bounds/pull/2979 diff --git a/research/rank7-group-b-native-widths-audit/RESULT.json b/research/rank7-group-b-native-widths-audit/RESULT.json new file mode 100644 index 0000000000..e4b4ec9210 --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/RESULT.json @@ -0,0 +1,7778 @@ +{ + "invoice": { + "bins": 149184, + "calls": { + "base": 250, + "extra": 416 + }, + "complete": { + "1": 1645680, + "2": 470196, + "3": 159468, + "4": 71928, + "48": 28190, + "5": 13716, + "8": 5328 + }, + "group_placements": 3330, + "group_rows_sha256": "e5e573f14471eb13708c2cf25916852d0ec89e75dac7182c5346fd5abaf7b867", + "group_widths": { + "299": 7, + "448": 6, + "449": 6, + "484": 6, + "485": 6 + }, + "idle": { + "1": 17310, + "3": 4956, + "48": 28190, + "5": 1728 + }, + "nominal_physical_stock": { + "centres": 8, + "helpers": 408, + "live": 66304, + "private": 91, + "scratch": 2, + "status": "declaration reconciled; movement, physical realization and precision not proved", + "total": 66813 + }, + "normalization": "sum(n_r * (r/73)^(1-a)) / (896*74)", + "rank_mass": 4816512, + "roles": 271728, + "supplier_caps": { + "bit": { + "cap_or_outer_coupling_replayed": false, + "changed_by_this_audit": false + }, + "complex": { + "input_profile_recounted": true, + "root_and_admission_replayed": false, + "source_claimed_endpoint": "1729033982646513517717/1000000000000000000000000" + } + }, + "supplier_status": "Neither supplier cap is independently admitted here; no new kappa.", + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + }, + "width_mass": 3283 + }, + "native": { + "base": { + "adapter_sha256": "e1befeb697875416d93ff291ec931b6267bf7961cbb5afb2d96786c9d05e028a", + "bindings": { + "299": { + "backward": { + "buffers": [ + [ + 17174, + "alloc" + ], + [ + 22472, + "free" + ] + ], + "climbs": [ + { + "index": 9502, + "new": [ + 290 + ], + "old": [], + "rank": 1 + }, + { + "index": 9519, + "new": [ + 273, + 51 + ], + "old": [ + 290 + ], + "rank": 1 + }, + { + "index": 13065, + "new": [ + 273, + 145, + 51 + ], + "old": [ + 273, + 51 + ], + "rank": 1 + }, + { + "index": 13516, + "new": [ + 273, + 145, + 79, + 51 + ], + "old": [ + 273, + 145, + 51 + ], + "rank": 1 + }, + { + "index": 13636, + "new": [ + 271, + 143, + 79, + 45, + 30 + ], + "old": [ + 273, + 145, + 79, + 51 + ], + "rank": 1 + }, + { + "index": 15947, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 271, + 143, + 79, + 45, + 30 + ], + "rank": 2 + } + ], + "compact_helper": 299, + "direct_scalar_count": 102, + "direct_scalar_indices": [ + 7129, + 7130, + 7131, + 7132, + 7133, + 7134, + 7135, + 7136, + 7137, + 7138, + 7139, + 7140, + 7141, + 7142, + 7143, + 7144, + 7145, + 7146, + 7147, + 7481, + 7488, + 7495, + 7496, + 7497, + 7498, + 7499, + 7500, + 7501, + 7511, + 7512, + 7513, + 7514, + 7519, + 7536, + 7545, + 7563, + 9503, + 9516, + 9517, + 9518, + 9520, + 9574, + 9575, + 12369, + 13067, + 13090, + 13517, + 13637, + 15948, + 16070, + 16071, + 16072, + 17347, + 17348, + 17349, + 17419, + 18127, + 18329, + 18341, + 20000, + 20001, + 20032, + 20033, + 20034, + 20035, + 20044, + 21664, + 21682, + 21691, + 21708, + 21713, + 21714, + 21715, + 21716, + 21726, + 21727, + 21728, + 21729, + 21730, + 21731, + 21732, + 21739, + 21746, + 22080, + 22081, + 22082, + 22083, + 22084, + 22085, + 22086, + 22087, + 22088, + 22089, + 22090, + 22091, + 22092, + 22093, + 22094, + 22095, + 22096, + 22097, + 22098 + ], + "direct_scalar_sha256": "78db47f7fd0099fc2850084bcd04844d72f30d1e5868f2de1265e7c7ec6827b7", + "entrance": [], + "private_uses": [ + 17347, + 17348, + 17349, + 17419, + 18127, + 18329, + 18341, + 20000, + 20001, + 20032, + 20033, + 20034, + 20035, + 20044, + 21664, + 21682, + 21691, + 21708, + 21713, + 21714, + 21715, + 21716, + 21726, + 21727, + 21728, + 21729, + 21730, + 21731, + 21732, + 21739, + 21746, + 22080, + 22081, + 22082, + 22083, + 22084, + 22085, + 22086, + 22087, + 22088, + 22089, + 22090, + 22091, + 22092, + 22093, + 22094, + 22095, + 22096, + 22097, + 22098 + ], + "recipe_key": "0:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6337, + "pre" + ], + [ + 22563, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17174, + "alloc" + ], + [ + 22472, + "free" + ] + ], + "climbs": [ + { + "index": 9502, + "new": [ + 290 + ], + "old": [], + "rank": 1 + }, + { + "index": 9519, + "new": [ + 273, + 51 + ], + "old": [ + 290 + ], + "rank": 1 + }, + { + "index": 13065, + "new": [ + 273, + 145, + 51 + ], + "old": [ + 273, + 51 + ], + "rank": 1 + }, + { + "index": 13516, + "new": [ + 273, + 145, + 79, + 51 + ], + "old": [ + 273, + 145, + 51 + ], + "rank": 1 + }, + { + "index": 13636, + "new": [ + 271, + 143, + 79, + 45, + 30 + ], + "old": [ + 273, + 145, + 79, + 51 + ], + "rank": 1 + }, + { + "index": 15947, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 271, + 143, + 79, + 45, + 30 + ], + "rank": 2 + } + ], + "compact_helper": 299, + "direct_scalar_count": 102, + "direct_scalar_indices": [ + 7129, + 7130, + 7131, + 7132, + 7133, + 7134, + 7135, + 7136, + 7137, + 7138, + 7139, + 7140, + 7141, + 7142, + 7143, + 7144, + 7145, + 7146, + 7147, + 7481, + 7488, + 7495, + 7496, + 7497, + 7498, + 7499, + 7500, + 7501, + 7511, + 7512, + 7513, + 7514, + 7519, + 7536, + 7545, + 7563, + 9503, + 9516, + 9517, + 9518, + 9520, + 9574, + 9575, + 12369, + 13067, + 13090, + 13517, + 13637, + 15948, + 16070, + 16071, + 16072, + 17347, + 17348, + 17349, + 17419, + 18127, + 18329, + 18341, + 20000, + 20001, + 20032, + 20033, + 20034, + 20035, + 20044, + 21664, + 21682, + 21691, + 21708, + 21713, + 21714, + 21715, + 21716, + 21726, + 21727, + 21728, + 21729, + 21730, + 21731, + 21732, + 21739, + 21746, + 22080, + 22081, + 22082, + 22083, + 22084, + 22085, + 22086, + 22087, + 22088, + 22089, + 22090, + 22091, + 22092, + 22093, + 22094, + 22095, + 22096, + 22097, + 22098 + ], + "direct_scalar_sha256": "78db47f7fd0099fc2850084bcd04844d72f30d1e5868f2de1265e7c7ec6827b7", + "entrance": [], + "private_uses": [ + 17347, + 17348, + 17349, + 17419, + 18127, + 18329, + 18341, + 20000, + 20001, + 20032, + 20033, + 20034, + 20035, + 20044, + 21664, + 21682, + 21691, + 21708, + 21713, + 21714, + 21715, + 21716, + 21726, + 21727, + 21728, + 21729, + 21730, + 21731, + 21732, + 21739, + 21746, + 22080, + 22081, + 22082, + 22083, + 22084, + 22085, + 22086, + 22087, + 22088, + 22089, + 22090, + 22091, + 22092, + 22093, + 22094, + 22095, + 22096, + 22097, + 22098 + ], + "recipe_key": "0:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6337, + "pre" + ], + [ + 22563, + "post" + ] + ] + } + }, + "448": { + "backward": { + "buffers": [ + [ + 17208, + "alloc" + ], + [ + 22506, + "free" + ] + ], + "climbs": [ + { + "index": 12939, + "new": [ + 459, + 38, + 21 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13092, + "new": [ + 260, + 132, + 75, + 38, + 21 + ], + "old": [ + 459, + 38, + 21 + ], + "rank": 2 + }, + { + "index": 14468, + "new": [ + 256, + 128, + 75, + 34, + 17, + 4 + ], + "old": [ + 260, + 132, + 75, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15906, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 256, + 128, + 75, + 34, + 17, + 4 + ], + "rank": 1 + } + ], + "compact_helper": 448, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12009, + 12011, + 12940, + 13093, + 14469, + 15908, + 15910, + 17435, + 17436, + 18328, + 18391 + ], + "direct_scalar_sha256": "a73dbd0c2b3e4940eeefa5015826c5c3c59d0c9244df60c7c180a957761ea92a", + "entrance": [ + 51 + ], + "private_uses": [ + 17435, + 17436, + 18328, + 18391 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6486, + "pre" + ], + [ + 22597, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17208, + "alloc" + ], + [ + 22506, + "free" + ] + ], + "climbs": [ + { + "index": 12939, + "new": [ + 459, + 38, + 21 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13092, + "new": [ + 260, + 132, + 75, + 38, + 21 + ], + "old": [ + 459, + 38, + 21 + ], + "rank": 2 + }, + { + "index": 14468, + "new": [ + 256, + 128, + 75, + 34, + 17, + 4 + ], + "old": [ + 260, + 132, + 75, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15906, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 256, + 128, + 75, + 34, + 17, + 4 + ], + "rank": 1 + } + ], + "compact_helper": 448, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12009, + 12011, + 12940, + 13093, + 14469, + 15908, + 15910, + 17435, + 17436, + 18328, + 18391 + ], + "direct_scalar_sha256": "a73dbd0c2b3e4940eeefa5015826c5c3c59d0c9244df60c7c180a957761ea92a", + "entrance": [ + 51 + ], + "private_uses": [ + 17435, + 17436, + 18328, + 18391 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6486, + "pre" + ], + [ + 22597, + "post" + ] + ] + } + }, + "449": { + "backward": { + "buffers": [ + [ + 17209, + "alloc" + ], + [ + 22507, + "free" + ] + ], + "climbs": [ + { + "index": 12941, + "new": [ + 448, + 51, + 11 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13097, + "new": [ + 260, + 132, + 64, + 51, + 11 + ], + "old": [ + 448, + 51, + 11 + ], + "rank": 2 + }, + { + "index": 14474, + "new": [ + 260, + 132, + 64, + 34, + 17, + 11 + ], + "old": [ + 260, + 132, + 64, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15911, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 260, + 132, + 64, + 34, + 17, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 449, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12013, + 12015, + 12942, + 13098, + 14475, + 15913, + 15915, + 17433, + 17434, + 18326, + 18390 + ], + "direct_scalar_sha256": "7c8b530977cd6217146365320b30a572f5fdab2dfd3f59e5d3f6cf21aee8ac70", + "entrance": [ + 51 + ], + "private_uses": [ + 17433, + 17434, + 18326, + 18390 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6487, + "pre" + ], + [ + 22598, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17209, + "alloc" + ], + [ + 22507, + "free" + ] + ], + "climbs": [ + { + "index": 12941, + "new": [ + 448, + 51, + 11 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13097, + "new": [ + 260, + 132, + 64, + 51, + 11 + ], + "old": [ + 448, + 51, + 11 + ], + "rank": 2 + }, + { + "index": 14474, + "new": [ + 260, + 132, + 64, + 34, + 17, + 11 + ], + "old": [ + 260, + 132, + 64, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15911, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 260, + 132, + 64, + 34, + 17, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 449, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12013, + 12015, + 12942, + 13098, + 14475, + 15913, + 15915, + 17433, + 17434, + 18326, + 18390 + ], + "direct_scalar_sha256": "7c8b530977cd6217146365320b30a572f5fdab2dfd3f59e5d3f6cf21aee8ac70", + "entrance": [ + 51 + ], + "private_uses": [ + 17433, + 17434, + 18326, + 18390 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6487, + "pre" + ], + [ + 22598, + "post" + ] + ] + } + }, + "484": { + "backward": { + "buffers": [ + [ + 17216, + "alloc" + ], + [ + 22514, + "free" + ] + ], + "climbs": [ + { + "index": 13089, + "new": [ + 273, + 145, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13091, + "new": [ + 260, + 132, + 75, + 38, + 21 + ], + "old": [ + 273, + 145, + 51 + ], + "rank": 2 + }, + { + "index": 14465, + "new": [ + 260, + 132, + 68, + 38, + 21, + 15 + ], + "old": [ + 260, + 132, + 75, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15909, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 260, + 132, + 68, + 38, + 21, + 15 + ], + "rank": 1 + } + ], + "compact_helper": 482, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12044, + 13090, + 13093, + 14466, + 15910, + 15946, + 15948, + 17419, + 17420, + 17435, + 18328, + 18329 + ], + "direct_scalar_sha256": "38547d9ccd30f60d68b2fa71397266b5c6dcac1d4ea80c45935381abf3e772bf", + "entrance": [ + 51 + ], + "private_uses": [ + 17419, + 17420, + 17435, + 18328, + 18329 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6520, + "pre" + ], + [ + 22617, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17216, + "alloc" + ], + [ + 22514, + "free" + ] + ], + "climbs": [ + { + "index": 13089, + "new": [ + 273, + 145, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13091, + "new": [ + 260, + 132, + 75, + 38, + 21 + ], + "old": [ + 273, + 145, + 51 + ], + "rank": 2 + }, + { + "index": 14465, + "new": [ + 260, + 132, + 68, + 38, + 21, + 15 + ], + "old": [ + 260, + 132, + 75, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15909, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 260, + 132, + 68, + 38, + 21, + 15 + ], + "rank": 1 + } + ], + "compact_helper": 482, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12044, + 13090, + 13093, + 14466, + 15910, + 15946, + 15948, + 17419, + 17420, + 17435, + 18328, + 18329 + ], + "direct_scalar_sha256": "38547d9ccd30f60d68b2fa71397266b5c6dcac1d4ea80c45935381abf3e772bf", + "entrance": [ + 51 + ], + "private_uses": [ + 17419, + 17420, + 17435, + 18328, + 18329 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6520, + "pre" + ], + [ + 22617, + "post" + ] + ] + } + }, + "485": { + "backward": { + "buffers": [ + [ + 17217, + "alloc" + ], + [ + 22515, + "free" + ] + ], + "climbs": [ + { + "index": 13094, + "new": [ + 324, + 196, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13096, + "new": [ + 260, + 132, + 64, + 51, + 11 + ], + "old": [ + 324, + 196, + 51 + ], + "rank": 2 + }, + { + "index": 14471, + "new": [ + 256, + 128, + 64, + 51, + 11, + 4 + ], + "old": [ + 260, + 132, + 64, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15914, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 256, + 128, + 64, + 51, + 11, + 4 + ], + "rank": 1 + } + ], + "compact_helper": 483, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12045, + 13095, + 13098, + 14472, + 15915, + 15949, + 15951, + 17417, + 17418, + 17433, + 18326, + 18327 + ], + "direct_scalar_sha256": "e711c148b09db54845342b20860a691b9d4d5963162062aa96bedeea9f7667f8", + "entrance": [ + 51 + ], + "private_uses": [ + 17417, + 17418, + 17433, + 18326, + 18327 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6521, + "pre" + ], + [ + 22618, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17217, + "alloc" + ], + [ + 22515, + "free" + ] + ], + "climbs": [ + { + "index": 13094, + "new": [ + 324, + 196, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13096, + "new": [ + 260, + 132, + 64, + 51, + 11 + ], + "old": [ + 324, + 196, + 51 + ], + "rank": 2 + }, + { + "index": 14471, + "new": [ + 256, + 128, + 64, + 51, + 11, + 4 + ], + "old": [ + 260, + 132, + 64, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15914, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 256, + 128, + 64, + 51, + 11, + 4 + ], + "rank": 1 + } + ], + "compact_helper": 483, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12045, + 13095, + 13098, + 14472, + 15915, + 15949, + 15951, + 17417, + 17418, + 17433, + 18326, + 18327 + ], + "direct_scalar_sha256": "e711c148b09db54845342b20860a691b9d4d5963162062aa96bedeea9f7667f8", + "entrance": [ + 51 + ], + "private_uses": [ + 17417, + 17418, + 17433, + 18326, + 18327 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6521, + "pre" + ], + [ + 22618, + "post" + ] + ] + } + } + }, + "climb_recipes": { + "[[256,128,64,51,11,4],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 16, + 33, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 49, + 34, + 4, + 8, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 51, + 35, + 0, + 0, + 1, + 3, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[256,128,75,34,17,4],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 73, + 74, + 4, + 64, + 16, + 32, + 128, + 256 + ], + "offset": 23, + "phase": 0, + "quadratic_rows": [ + 67, + 67, + 0, + 64, + 0, + 0, + 11, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,64,34,17,11],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 32, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 260, + 1, + 2, + 256, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,64,51,11],[256,128,64,51,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 32, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 260, + 1, + 2, + 256, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,64,51,11],[260,132,64,34,17,11]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 16, + 33, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 49, + 34, + 4, + 8, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 51, + 35, + 0, + 0, + 1, + 3, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,68,38,21,15],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 33, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 260, + 1, + 2, + 256, + 264, + 272, + 288, + 320, + 384 + ], + "offset": 110, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,75,38,21],[256,128,75,34,17,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 16, + 33, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 263, + 257, + 258, + 256, + 8, + 272, + 288, + 64, + 384 + ], + "offset": 111, + "phase": 0, + "quadratic_rows": [ + 7, + 7, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,75,38,21],[260,132,68,38,21,15]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 1, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 73, + 74, + 12, + 64, + 16, + 32, + 128, + 256 + ], + "offset": 31, + "phase": 3, + "quadratic_rows": [ + 67, + 67, + 8, + 76, + 0, + 0, + 11, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[271,143,79,45,30],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 18, + 1, + 35, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 264, + 7, + 265, + 266, + 256, + 272, + 288, + 320, + 384 + ], + "offset": 125, + "phase": 0, + "quadratic_rows": [ + 271, + 271, + 259, + 259, + 0, + 0, + 0, + 0, + 271 + ] + } + }, + "spectator_axes": 7 + }, + "[[273,145,51],[260,132,75,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 35, + 65, + 129, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 24, + 27, + 337, + 322, + 20, + 72, + 256, + 288, + 384 + ], + "offset": 205, + "phase": 1, + "quadratic_rows": [ + 331, + 347, + 16, + 67, + 86, + 0, + 27, + 0, + 3 + ] + } + }, + "spectator_axes": 7 + }, + "[[273,145,51],[273,145,79,51]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 17, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 79, + 65, + 66, + 68, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 15, + 15, + 15, + 15, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[273,145,79,51],[271,143,79,45,30]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 16, + 33, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 3, + 257, + 274, + 20, + 24, + 256, + 288, + 64, + 384 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 259, + 275, + 16, + 16, + 14, + 0, + 0, + 0, + 3 + ] + } + }, + "spectator_axes": 8 + }, + "[[273,51],[273,145,51]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 145, + 129, + 2, + 4, + 8, + 144, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 0, + 0, + 0, + 17, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[290],[273,51]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 258, + 33, + 290, + 4, + 8, + 48, + 256, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 32, + 34, + 0, + 0, + 32, + 19, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[324,196,51],[260,132,64,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 1, + 32, + 64, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 11, + 320, + 9, + 10, + 4, + 16, + 32, + 256, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[448,51,11],[260,132,64,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 18, + 32, + 64, + 128, + 258, + 1, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 452, + 1, + 2, + 388, + 8, + 16, + 32, + 256 + ], + "offset": 258, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 68, + 0, + 0, + 0, + 132, + 320, + 384 + ] + } + }, + "spectator_axes": 7 + }, + "[[459,38,21],[260,132,75,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 17, + 33, + 64, + 128, + 257, + 2, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 0, + 2, + 2, + 1 + ], + "matrix_rows": [ + 143, + 384, + 321, + 322, + 388, + 328, + 16, + 32, + 256 + ], + "offset": 301, + "phase": 3, + "quadratic_rows": [ + 463, + 463, + 271, + 463, + 0, + 0, + 11, + 11, + 271 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[273,145,51]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 16, + 32, + 66, + 128, + 256, + 3, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 145, + 385, + 2, + 4, + 8, + 400, + 32, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 273, + 0, + 0, + 0, + 273, + 0, + 0, + 384, + 145 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[324,196,51]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 18, + 32, + 64, + 128, + 258, + 3, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 196, + 1, + 2, + 388, + 8, + 16, + 32, + 448 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 324, + 0, + 0, + 0, + 324, + 384, + 196 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[448,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 1, + 32, + 64, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 0, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 11, + 448, + 9, + 10, + 4, + 16, + 32, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 192, + 192, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[459,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 35, + 65, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 1, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 216, + 219, + 305, + 290, + 20, + 264, + 32, + 320, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 491, + 507, + 16, + 259, + 278, + 3, + 259, + 259, + 219 + ] + } + }, + "spectator_axes": 7 + }, + "[[],[290]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 290, + 1, + 258, + 4, + 8, + 16, + 288, + 64, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 34, + 0, + 0, + 0, + 34, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + } + }, + "controls": { + "cold_wrapper_alias": "phase-exact all-column residual", + "omitted_entrance": "entrance-relative width", + "phase": "phase-exact all-column residual", + "wrong_entrance_line": "phase-exact all-column residual" + }, + "local_checks_sha256": "f2a8160669dba42701bf43a9cd18ba47e4a2ac16a5eb6dac2b77e41eaec5cbdc", + "parent_residual_comparison": { + "299": { + "entrance": [], + "joint_recipe_key": "0:260", + "parent": { + "columns": 512, + "orientations": 2, + "rank": 8, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 1 + }, + "parent_terminal": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + }, + "448": { + "entrance": [ + 51 + ], + "joint_recipe_key": "114:260", + "parent": { + "columns": 512, + "orientations": 2, + "rank": 7, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 128, + 259, + 4, + 8, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 2, + 4, + 8, + 64, + 128, + 256, + 19, + 32 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 49, + 48, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 2 + }, + "parent_terminal": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "residuals": { + "0:260": { + "columns": 512, + "orientations": 2, + "rank": 7, + "recipe": { + "entrance_rank": 0, + "frame": 0, + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 138, + 265, + 4, + 11, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 49, + 4, + 59, + 64, + 128, + 256, + 25, + 42 + ], + "offset": 127, + "phase": 3, + "quadratic_rows": [ + 18, + 33, + 0, + 0, + 49, + 50, + 0, + 0, + 0 + ] + }, + "terminal": 260, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "vectors": [] + }, + "spectator_axes": 2 + }, + "114:260": { + "columns": 512, + "orientations": 2, + "rank": 6, + "recipe": { + "entrance_rank": 1, + "frame": 114, + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 130, + 4, + 3, + 257, + 1, + 8, + 16, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 6, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 24, + 27, + 4, + 64, + 128, + 256, + 57, + 42, + 32 + ], + "offset": 63, + "phase": 2, + "quadratic_rows": [ + 35, + 51, + 0, + 24, + 10, + 3, + 0, + 0, + 0 + ] + }, + "terminal": 260, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "vectors": [ + 51 + ] + }, + "spectator_axes": 3 + } + } + }, + "extra": { + "adapter_sha256": "cc366668c225431a1e5d0f856dbe7ba079c8e2fa1dc3ad0ceeecb9f0796aff77", + "bindings": { + "299": { + "backward": { + "buffers": [ + [ + 17174, + "alloc" + ], + [ + 22472, + "free" + ] + ], + "climbs": [ + { + "index": 9502, + "new": [ + 290 + ], + "old": [], + "rank": 1 + }, + { + "index": 9519, + "new": [ + 273, + 51 + ], + "old": [ + 290 + ], + "rank": 1 + }, + { + "index": 13065, + "new": [ + 273, + 145, + 51 + ], + "old": [ + 273, + 51 + ], + "rank": 1 + }, + { + "index": 13516, + "new": [ + 273, + 145, + 79, + 51 + ], + "old": [ + 273, + 145, + 51 + ], + "rank": 1 + }, + { + "index": 13636, + "new": [ + 271, + 143, + 79, + 45, + 30 + ], + "old": [ + 273, + 145, + 79, + 51 + ], + "rank": 1 + }, + { + "index": 15947, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 271, + 143, + 79, + 45, + 30 + ], + "rank": 2 + } + ], + "compact_helper": 299, + "direct_scalar_count": 102, + "direct_scalar_indices": [ + 7129, + 7130, + 7131, + 7132, + 7133, + 7134, + 7135, + 7136, + 7137, + 7138, + 7139, + 7140, + 7141, + 7142, + 7143, + 7144, + 7145, + 7146, + 7147, + 7481, + 7488, + 7495, + 7496, + 7497, + 7498, + 7499, + 7500, + 7501, + 7511, + 7512, + 7513, + 7514, + 7519, + 7536, + 7545, + 7563, + 9503, + 9516, + 9517, + 9518, + 9520, + 9574, + 9575, + 12369, + 13067, + 13090, + 13517, + 13637, + 15948, + 16070, + 16071, + 16072, + 17347, + 17348, + 17349, + 17419, + 18127, + 18329, + 18341, + 20000, + 20001, + 20032, + 20033, + 20034, + 20035, + 20044, + 21664, + 21682, + 21691, + 21708, + 21713, + 21714, + 21715, + 21716, + 21726, + 21727, + 21728, + 21729, + 21730, + 21731, + 21732, + 21739, + 21746, + 22080, + 22081, + 22082, + 22083, + 22084, + 22085, + 22086, + 22087, + 22088, + 22089, + 22090, + 22091, + 22092, + 22093, + 22094, + 22095, + 22096, + 22097, + 22098 + ], + "direct_scalar_sha256": "78db47f7fd0099fc2850084bcd04844d72f30d1e5868f2de1265e7c7ec6827b7", + "entrance": [], + "private_uses": [ + 17347, + 17348, + 17349, + 17419, + 18127, + 18329, + 18341, + 20000, + 20001, + 20032, + 20033, + 20034, + 20035, + 20044, + 21664, + 21682, + 21691, + 21708, + 21713, + 21714, + 21715, + 21716, + 21726, + 21727, + 21728, + 21729, + 21730, + 21731, + 21732, + 21739, + 21746, + 22080, + 22081, + 22082, + 22083, + 22084, + 22085, + 22086, + 22087, + 22088, + 22089, + 22090, + 22091, + 22092, + 22093, + 22094, + 22095, + 22096, + 22097, + 22098 + ], + "recipe_key": "0:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6337, + "pre" + ], + [ + 22563, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17174, + "alloc" + ], + [ + 22472, + "free" + ] + ], + "climbs": [ + { + "index": 9502, + "new": [ + 290 + ], + "old": [], + "rank": 1 + }, + { + "index": 9519, + "new": [ + 273, + 51 + ], + "old": [ + 290 + ], + "rank": 1 + }, + { + "index": 13065, + "new": [ + 273, + 145, + 51 + ], + "old": [ + 273, + 51 + ], + "rank": 1 + }, + { + "index": 13516, + "new": [ + 273, + 145, + 79, + 51 + ], + "old": [ + 273, + 145, + 51 + ], + "rank": 1 + }, + { + "index": 13636, + "new": [ + 271, + 143, + 79, + 45, + 30 + ], + "old": [ + 273, + 145, + 79, + 51 + ], + "rank": 1 + }, + { + "index": 15947, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 271, + 143, + 79, + 45, + 30 + ], + "rank": 2 + } + ], + "compact_helper": 299, + "direct_scalar_count": 102, + "direct_scalar_indices": [ + 7129, + 7130, + 7131, + 7132, + 7133, + 7134, + 7135, + 7136, + 7137, + 7138, + 7139, + 7140, + 7141, + 7142, + 7143, + 7144, + 7145, + 7146, + 7147, + 7481, + 7488, + 7495, + 7496, + 7497, + 7498, + 7499, + 7500, + 7501, + 7511, + 7512, + 7513, + 7514, + 7519, + 7536, + 7545, + 7563, + 9503, + 9516, + 9517, + 9518, + 9520, + 9574, + 9575, + 12369, + 13067, + 13090, + 13517, + 13637, + 15948, + 16070, + 16071, + 16072, + 17347, + 17348, + 17349, + 17419, + 18127, + 18329, + 18341, + 20000, + 20001, + 20032, + 20033, + 20034, + 20035, + 20044, + 21664, + 21682, + 21691, + 21708, + 21713, + 21714, + 21715, + 21716, + 21726, + 21727, + 21728, + 21729, + 21730, + 21731, + 21732, + 21739, + 21746, + 22080, + 22081, + 22082, + 22083, + 22084, + 22085, + 22086, + 22087, + 22088, + 22089, + 22090, + 22091, + 22092, + 22093, + 22094, + 22095, + 22096, + 22097, + 22098 + ], + "direct_scalar_sha256": "78db47f7fd0099fc2850084bcd04844d72f30d1e5868f2de1265e7c7ec6827b7", + "entrance": [], + "private_uses": [ + 17347, + 17348, + 17349, + 17419, + 18127, + 18329, + 18341, + 20000, + 20001, + 20032, + 20033, + 20034, + 20035, + 20044, + 21664, + 21682, + 21691, + 21708, + 21713, + 21714, + 21715, + 21716, + 21726, + 21727, + 21728, + 21729, + 21730, + 21731, + 21732, + 21739, + 21746, + 22080, + 22081, + 22082, + 22083, + 22084, + 22085, + 22086, + 22087, + 22088, + 22089, + 22090, + 22091, + 22092, + 22093, + 22094, + 22095, + 22096, + 22097, + 22098 + ], + "recipe_key": "0:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6337, + "pre" + ], + [ + 22563, + "post" + ] + ] + } + }, + "448": { + "backward": { + "buffers": [ + [ + 17208, + "alloc" + ], + [ + 22506, + "free" + ] + ], + "climbs": [ + { + "index": 12939, + "new": [ + 459, + 38, + 21 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13092, + "new": [ + 260, + 132, + 75, + 38, + 21 + ], + "old": [ + 459, + 38, + 21 + ], + "rank": 2 + }, + { + "index": 14468, + "new": [ + 256, + 128, + 75, + 34, + 17, + 4 + ], + "old": [ + 260, + 132, + 75, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15906, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 256, + 128, + 75, + 34, + 17, + 4 + ], + "rank": 1 + } + ], + "compact_helper": 448, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12009, + 12011, + 12940, + 13093, + 14469, + 15908, + 15910, + 17435, + 17436, + 18328, + 18391 + ], + "direct_scalar_sha256": "a73dbd0c2b3e4940eeefa5015826c5c3c59d0c9244df60c7c180a957761ea92a", + "entrance": [ + 51 + ], + "private_uses": [ + 17435, + 17436, + 18328, + 18391 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6486, + "pre" + ], + [ + 22597, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17208, + "alloc" + ], + [ + 22506, + "free" + ] + ], + "climbs": [ + { + "index": 12939, + "new": [ + 459, + 38, + 21 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13092, + "new": [ + 260, + 132, + 75, + 38, + 21 + ], + "old": [ + 459, + 38, + 21 + ], + "rank": 2 + }, + { + "index": 14468, + "new": [ + 256, + 128, + 75, + 34, + 17, + 4 + ], + "old": [ + 260, + 132, + 75, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15906, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 256, + 128, + 75, + 34, + 17, + 4 + ], + "rank": 1 + } + ], + "compact_helper": 448, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12009, + 12011, + 12940, + 13093, + 14469, + 15908, + 15910, + 17435, + 17436, + 18328, + 18391 + ], + "direct_scalar_sha256": "a73dbd0c2b3e4940eeefa5015826c5c3c59d0c9244df60c7c180a957761ea92a", + "entrance": [ + 51 + ], + "private_uses": [ + 17435, + 17436, + 18328, + 18391 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6486, + "pre" + ], + [ + 22597, + "post" + ] + ] + } + }, + "449": { + "backward": { + "buffers": [ + [ + 17209, + "alloc" + ], + [ + 22507, + "free" + ] + ], + "climbs": [ + { + "index": 12941, + "new": [ + 448, + 51, + 11 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13097, + "new": [ + 260, + 132, + 64, + 51, + 11 + ], + "old": [ + 448, + 51, + 11 + ], + "rank": 2 + }, + { + "index": 14474, + "new": [ + 260, + 132, + 64, + 34, + 17, + 11 + ], + "old": [ + 260, + 132, + 64, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15911, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 260, + 132, + 64, + 34, + 17, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 449, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12013, + 12015, + 12942, + 13098, + 14475, + 15913, + 15915, + 17433, + 17434, + 18326, + 18390 + ], + "direct_scalar_sha256": "7c8b530977cd6217146365320b30a572f5fdab2dfd3f59e5d3f6cf21aee8ac70", + "entrance": [ + 51 + ], + "private_uses": [ + 17433, + 17434, + 18326, + 18390 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6487, + "pre" + ], + [ + 22598, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17209, + "alloc" + ], + [ + 22507, + "free" + ] + ], + "climbs": [ + { + "index": 12941, + "new": [ + 448, + 51, + 11 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13097, + "new": [ + 260, + 132, + 64, + 51, + 11 + ], + "old": [ + 448, + 51, + 11 + ], + "rank": 2 + }, + { + "index": 14474, + "new": [ + 260, + 132, + 64, + 34, + 17, + 11 + ], + "old": [ + 260, + 132, + 64, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15911, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 260, + 132, + 64, + 34, + 17, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 449, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12013, + 12015, + 12942, + 13098, + 14475, + 15913, + 15915, + 17433, + 17434, + 18326, + 18390 + ], + "direct_scalar_sha256": "7c8b530977cd6217146365320b30a572f5fdab2dfd3f59e5d3f6cf21aee8ac70", + "entrance": [ + 51 + ], + "private_uses": [ + 17433, + 17434, + 18326, + 18390 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6487, + "pre" + ], + [ + 22598, + "post" + ] + ] + } + }, + "484": { + "backward": { + "buffers": [ + [ + 17216, + "alloc" + ], + [ + 22514, + "free" + ] + ], + "climbs": [ + { + "index": 13089, + "new": [ + 273, + 145, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13091, + "new": [ + 260, + 132, + 75, + 38, + 21 + ], + "old": [ + 273, + 145, + 51 + ], + "rank": 2 + }, + { + "index": 14465, + "new": [ + 260, + 132, + 68, + 38, + 21, + 15 + ], + "old": [ + 260, + 132, + 75, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15909, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 260, + 132, + 68, + 38, + 21, + 15 + ], + "rank": 1 + } + ], + "compact_helper": 482, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12044, + 13090, + 13093, + 14466, + 15910, + 15946, + 15948, + 17419, + 17420, + 17435, + 18328, + 18329 + ], + "direct_scalar_sha256": "38547d9ccd30f60d68b2fa71397266b5c6dcac1d4ea80c45935381abf3e772bf", + "entrance": [ + 51 + ], + "private_uses": [ + 17419, + 17420, + 17435, + 18328, + 18329 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6520, + "pre" + ], + [ + 22617, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17216, + "alloc" + ], + [ + 22514, + "free" + ] + ], + "climbs": [ + { + "index": 13089, + "new": [ + 273, + 145, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13091, + "new": [ + 260, + 132, + 75, + 38, + 21 + ], + "old": [ + 273, + 145, + 51 + ], + "rank": 2 + }, + { + "index": 14465, + "new": [ + 260, + 132, + 68, + 38, + 21, + 15 + ], + "old": [ + 260, + 132, + 75, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15909, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 260, + 132, + 68, + 38, + 21, + 15 + ], + "rank": 1 + } + ], + "compact_helper": 482, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12044, + 13090, + 13093, + 14466, + 15910, + 15946, + 15948, + 17419, + 17420, + 17435, + 18328, + 18329 + ], + "direct_scalar_sha256": "38547d9ccd30f60d68b2fa71397266b5c6dcac1d4ea80c45935381abf3e772bf", + "entrance": [ + 51 + ], + "private_uses": [ + 17419, + 17420, + 17435, + 18328, + 18329 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6520, + "pre" + ], + [ + 22617, + "post" + ] + ] + } + }, + "485": { + "backward": { + "buffers": [ + [ + 17217, + "alloc" + ], + [ + 22515, + "free" + ] + ], + "climbs": [ + { + "index": 13094, + "new": [ + 324, + 196, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13096, + "new": [ + 260, + 132, + 64, + 51, + 11 + ], + "old": [ + 324, + 196, + 51 + ], + "rank": 2 + }, + { + "index": 14471, + "new": [ + 256, + 128, + 64, + 51, + 11, + 4 + ], + "old": [ + 260, + 132, + 64, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15914, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 256, + 128, + 64, + 51, + 11, + 4 + ], + "rank": 1 + } + ], + "compact_helper": 483, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12045, + 13095, + 13098, + 14472, + 15915, + 15949, + 15951, + 17417, + 17418, + 17433, + 18326, + 18327 + ], + "direct_scalar_sha256": "e711c148b09db54845342b20860a691b9d4d5963162062aa96bedeea9f7667f8", + "entrance": [ + 51 + ], + "private_uses": [ + 17417, + 17418, + 17433, + 18326, + 18327 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6521, + "pre" + ], + [ + 22618, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17217, + "alloc" + ], + [ + 22515, + "free" + ] + ], + "climbs": [ + { + "index": 13094, + "new": [ + 324, + 196, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13096, + "new": [ + 260, + 132, + 64, + 51, + 11 + ], + "old": [ + 324, + 196, + 51 + ], + "rank": 2 + }, + { + "index": 14471, + "new": [ + 256, + 128, + 64, + 51, + 11, + 4 + ], + "old": [ + 260, + 132, + 64, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15914, + "new": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "old": [ + 256, + 128, + 64, + 51, + 11, + 4 + ], + "rank": 1 + } + ], + "compact_helper": 483, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12045, + 13095, + 13098, + 14472, + 15915, + 15949, + 15951, + 17417, + 17418, + 17433, + 18326, + 18327 + ], + "direct_scalar_sha256": "e711c148b09db54845342b20860a691b9d4d5963162062aa96bedeea9f7667f8", + "entrance": [ + 51 + ], + "private_uses": [ + 17417, + 17418, + 17433, + 18326, + 18327 + ], + "recipe_key": "114:260", + "terminal": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "wrappers": [ + [ + 6521, + "pre" + ], + [ + 22618, + "post" + ] + ] + } + } + }, + "climb_recipes": { + "[[256,128,64,51,11,4],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 16, + 33, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 49, + 34, + 4, + 8, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 51, + 35, + 0, + 0, + 1, + 3, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[256,128,75,34,17,4],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 73, + 74, + 4, + 64, + 16, + 32, + 128, + 256 + ], + "offset": 23, + "phase": 0, + "quadratic_rows": [ + 67, + 67, + 0, + 64, + 0, + 0, + 11, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,64,34,17,11],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 32, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 260, + 1, + 2, + 256, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,64,51,11],[256,128,64,51,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 32, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 260, + 1, + 2, + 256, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 9, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,64,51,11],[260,132,64,34,17,11]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 16, + 33, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 49, + 34, + 4, + 8, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 51, + 35, + 0, + 0, + 1, + 3, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,68,38,21,15],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 33, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 260, + 1, + 2, + 256, + 264, + 272, + 288, + 320, + 384 + ], + "offset": 110, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,75,38,21],[256,128,75,34,17,4]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 16, + 33, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 263, + 257, + 258, + 256, + 8, + 272, + 288, + 64, + 384 + ], + "offset": 111, + "phase": 0, + "quadratic_rows": [ + 7, + 7, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[260,132,75,38,21],[260,132,68,38,21,15]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 1, + 1, + 2, + 1, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 73, + 74, + 12, + 64, + 16, + 32, + 128, + 256 + ], + "offset": 31, + "phase": 3, + "quadratic_rows": [ + 67, + 67, + 8, + 76, + 0, + 0, + 11, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[271,143,79,45,30],[256,128,64,34,17,11,4]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 18, + 1, + 35, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 264, + 7, + 265, + 266, + 256, + 272, + 288, + 320, + 384 + ], + "offset": 125, + "phase": 0, + "quadratic_rows": [ + 271, + 271, + 259, + 259, + 0, + 0, + 0, + 0, + 271 + ] + } + }, + "spectator_axes": 7 + }, + "[[273,145,51],[260,132,75,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 35, + 65, + 129, + 3, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 0, + 2, + 0, + 2 + ], + "matrix_rows": [ + 24, + 27, + 337, + 322, + 20, + 72, + 256, + 288, + 384 + ], + "offset": 205, + "phase": 1, + "quadratic_rows": [ + 331, + 347, + 16, + 67, + 86, + 0, + 27, + 0, + 3 + ] + } + }, + "spectator_axes": 7 + }, + "[[273,145,51],[273,145,79,51]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 17, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 79, + 65, + 66, + 68, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 15, + 15, + 15, + 15, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[273,145,79,51],[271,143,79,45,30]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 16, + 33, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 3, + 257, + 274, + 20, + 24, + 256, + 288, + 64, + 384 + ], + "offset": 102, + "phase": 0, + "quadratic_rows": [ + 259, + 275, + 16, + 16, + 14, + 0, + 0, + 0, + 3 + ] + } + }, + "spectator_axes": 8 + }, + "[[273,51],[273,145,51]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 145, + 129, + 2, + 4, + 8, + 144, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 0, + 0, + 0, + 17, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[290],[273,51]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 258, + 33, + 290, + 4, + 8, + 48, + 256, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 32, + 34, + 0, + 0, + 32, + 19, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[324,196,51],[260,132,64,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 1, + 32, + 64, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 11, + 320, + 9, + 10, + 4, + 16, + 32, + 256, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[448,51,11],[260,132,64,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 18, + 32, + 64, + 128, + 258, + 1, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 452, + 1, + 2, + 388, + 8, + 16, + 32, + 256 + ], + "offset": 258, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 68, + 0, + 0, + 0, + 132, + 320, + 384 + ] + } + }, + "spectator_axes": 7 + }, + "[[459,38,21],[260,132,75,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 17, + 33, + 64, + 128, + 257, + 2, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 3, + 1, + 0, + 0, + 2, + 2, + 1 + ], + "matrix_rows": [ + 143, + 384, + 321, + 322, + 388, + 328, + 16, + 32, + 256 + ], + "offset": 301, + "phase": 3, + "quadratic_rows": [ + 463, + 463, + 271, + 463, + 0, + 0, + 11, + 11, + 271 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[273,145,51]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 16, + 32, + 66, + 128, + 256, + 3, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 145, + 385, + 2, + 4, + 8, + 400, + 32, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 273, + 0, + 0, + 0, + 273, + 0, + 0, + 384, + 145 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[324,196,51]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 18, + 32, + 64, + 128, + 258, + 3, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 196, + 1, + 2, + 388, + 8, + 16, + 32, + 448 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 324, + 0, + 0, + 0, + 324, + 384, + 196 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[448,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 1, + 32, + 64, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 0, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 11, + 448, + 9, + 10, + 4, + 16, + 32, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 192, + 192, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[459,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 35, + 65, + 1, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 1, + 0, + 2, + 1, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 216, + 219, + 305, + 290, + 20, + 264, + 32, + 320, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 491, + 507, + 16, + 259, + 278, + 3, + 259, + 259, + 219 + ] + } + }, + "spectator_axes": 7 + }, + "[[],[290]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 290, + 1, + 258, + 4, + 8, + 16, + 288, + 64, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 34, + 0, + 0, + 0, + 34, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + } + }, + "controls": { + "cold_wrapper_alias": "phase-exact all-column residual", + "omitted_entrance": "entrance-relative width", + "phase": "phase-exact all-column residual", + "wrong_entrance_line": "phase-exact all-column residual" + }, + "local_checks_sha256": "f2a8160669dba42701bf43a9cd18ba47e4a2ac16a5eb6dac2b77e41eaec5cbdc", + "parent_residual_comparison": { + "299": { + "entrance": [], + "joint_recipe_key": "0:260", + "parent": { + "columns": 512, + "orientations": 2, + "rank": 8, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 275, + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 1, + 3, + 2, + 2, + 3, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 49, + 4, + 8, + 35, + 64, + 128, + 256, + 51 + ], + "offset": 237, + "phase": 2, + "quadratic_rows": [ + 33, + 18, + 0, + 0, + 18, + 1, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 1 + }, + "parent_terminal": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + }, + "448": { + "entrance": [ + 51 + ], + "joint_recipe_key": "114:260", + "parent": { + "columns": 512, + "orientations": 2, + "rank": 7, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 128, + 259, + 4, + 8, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 2, + 4, + 8, + 64, + 128, + 256, + 19, + 32 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 49, + 48, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 2 + }, + "parent_terminal": [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + } + }, + "residuals": { + "0:260": { + "columns": 512, + "orientations": 2, + "rank": 7, + "recipe": { + "entrance_rank": 0, + "frame": 0, + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 138, + 265, + 4, + 11, + 1, + 2, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 3, + 2, + 2, + 2 + ], + "matrix_rows": [ + 50, + 49, + 4, + 59, + 64, + 128, + 256, + 25, + 42 + ], + "offset": 127, + "phase": 3, + "quadratic_rows": [ + 18, + 33, + 0, + 0, + 49, + 50, + 0, + 0, + 0 + ] + }, + "terminal": 260, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "vectors": [] + }, + "spectator_axes": 2 + }, + "114:260": { + "columns": 512, + "orientations": 2, + "rank": 6, + "recipe": { + "entrance_rank": 1, + "frame": 114, + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 66, + 130, + 4, + 3, + 257, + 1, + 8, + 16, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 6, + "right": { + "linear_Z4": [ + 3, + 3, + 2, + 1, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 24, + 27, + 4, + 64, + 128, + 256, + 57, + 42, + 32 + ], + "offset": 63, + "phase": 2, + "quadratic_rows": [ + 35, + 51, + 0, + 24, + 10, + 3, + 0, + 0, + 0 + ] + }, + "terminal": 260, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "vectors": [ + 51 + ] + }, + "spectator_axes": 3 + } + } + } + }, + "native_to_owner_join": { + "base": { + "299": { + "helper_index": 75, + "native_pair": "0:260", + "width": 7 + }, + "448": { + "helper_index": 224, + "native_pair": "114:260", + "width": 6 + }, + "449": { + "helper_index": 225, + "native_pair": "114:260", + "width": 6 + }, + "484": { + "helper_index": 258, + "native_pair": "114:260", + "width": 6 + }, + "485": { + "helper_index": 259, + "native_pair": "114:260", + "width": 6 + } + }, + "extra": { + "299": { + "helper_index": 75, + "native_pair": "0:260", + "width": 7 + }, + "448": { + "helper_index": 224, + "native_pair": "114:260", + "width": 6 + }, + "449": { + "helper_index": 225, + "native_pair": "114:260", + "width": 6 + }, + "484": { + "helper_index": 258, + "native_pair": "114:260", + "width": 6 + }, + "485": { + "helper_index": 259, + "native_pair": "114:260", + "width": 6 + } + } + }, + "schema_version": 1, + "status": "PASS_GROUP_B_NATIVE_WIDTHS" +} diff --git a/research/rank7-group-b-native-widths-audit/SOURCES.json b/research/rank7-group-b-native-widths-audit/SOURCES.json new file mode 100644 index 0000000000..1548f12ccf --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/SOURCES.json @@ -0,0 +1,126 @@ +{ + "schema_version": 1, + "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/frontier1094-recipes-exact-seed76/clifford.py", + "usage": "input", + "git_blob": "6f1e6a38febde7eb7a7341d317522e6650d84408", + "sha256": "d5e42ddabd141b7bfbd70fe13908f3c3a06aeccebeab90623596bfb1988b97fb" + }, + { + "path": "research/rank7-joint-endframes/CLAIM.json", + "usage": "input", + "git_blob": "8ec2ce4e440c0b584ee982c551e526a011c9324c", + "sha256": "436e0d297cbdf195445d3697d496ac675e95210b79e70ce602a6a6667a4c6ce9", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/CLAIM.json" + }, + { + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "usage": "input", + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/allocation/DISPATCH.json" + }, + { + "path": "research/rank7-joint-endframes/allocation/FILL.json.gz", + "usage": "input", + "git_blob": "8d4fd644d60ba2c98106dc770803b647afdf0963", + "sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/allocation/FILL.json.gz" + }, + { + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "usage": "input", + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/allocation/ORDER.json" + }, + { + "path": "research/rank7-joint-endframes/allocation/PROFILE.json", + "usage": "input", + "git_blob": "46a83eeda67ab67cccbffe8b7ad8e44368b40ea7", + "sha256": "94a819747f3ced41f1544ada0036c983fc0c92847b9644380f877a06cd7931cf", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/allocation/PROFILE.json" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz" + }, + { + "path": "research/rank7-joint-endframes/data/PARENT-base.json.gz", + "usage": "input", + "git_blob": "1ca8287d6ae5eb45d87db65b369be8d09ba692b2", + "sha256": "54ca34c749e3228d7e2df3d8dbf7aa1568c2872490166997c5962f12fd03da35", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/data/PARENT-base.json.gz" + }, + { + "path": "research/rank7-joint-endframes/data/PARENT-extra.json.gz", + "usage": "input", + "git_blob": "c39913ce24cbce4c841eabcc9b1e5a18e4ccc754", + "sha256": "eded756dfe8f411c3d1f80a3ac16516f0ea5dd6f9866728b2179b157630fa7b6", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/data/PARENT-extra.json.gz" + }, + { + "path": "research/rank7-joint-endframes/data/WORD-base.json.gz", + "usage": "input", + "git_blob": "d9aa96a93fea5f7395e7783aef0bc117c0a0ae89", + "sha256": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/data/WORD-base.json.gz" + }, + { + "path": "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "usage": "input", + "git_blob": "74f6cb64595c21f7726ae77e69437868620bdcee", + "sha256": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/data/WORD-extra.json.gz" + }, + { + "path": "research/rank7-joint-endframes/evidence/FULL-NATIVE-RECEIPT.json", + "usage": "input", + "git_blob": "87ac21d0878479877bb75961b3c054843711d4d4", + "sha256": "6d27c89d5e3a2c7f28387e4b20c462b0dff6c9fa92aacdde715d4b29cc286d41", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/evidence/FULL-NATIVE-RECEIPT.json" + }, + { + "path": "research/two-sided-helper-extraction/vendor/fastnative/vendor/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/two-sided-helper-extraction/vendor/fastnative/vendor/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/two-sided-helper-extraction/vendor/fastnative/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } + ] +} diff --git a/research/rank7-group-b-native-widths-audit/TASK.json b/research/rank7-group-b-native-widths-audit/TASK.json new file mode 100644 index 0000000000..41b8870e56 --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/TASK.json @@ -0,0 +1,118 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ] + }, + "scope_status": "refined", + "actual_scope": "PR2979 group B only: exact emitted wrapper pairs, native residual ranks/widths and climbs for helpers 299/448/449/484/485 under shared W=<256,128,64,34,17,11,4>, adapter pins against FULL-NATIVE-RECEIPT, and native-width-to-T74-fill join. Explicitly excludes STAGE-PRICES guide margins and single-299 control reprint.", + "scope_change_reason": "Deferred tip f795116d already registered joint +42541 / single-299 -58943 / widths 7/6/6/6/6 / 3330 placements as soft-overlap against #2979 STAGE-PRICES and group-A margins. The still-missing obligation is the native residual/wrapper binding (deferred open question 1), adapted from rank7-group-a-entrance-audit.", + "bottleneck_link": "A paid-profile saving cannot be used if its helper width is not the width of the native residual supplied to the owner geometry. This audit joins that boundary for group B without reprinting already-registered guide margins.", + "budget_minutes": 60, + "stop_rule": "Finish this finite native/interface and fill-join audit. No new lowering census, STAGE-PRICES margin reprint, supplier admission or selected-frontier change. Stop at source mismatch, failed exact identity or unresolved full admission.", + "outcome": "partial", + "evidence": "RESULT.json: both providers/orientations; residual widths 7/6/6/6/6; entrance [] for 299 and [51] for entering helpers; adapter and LOCAL-CHECKS pins; T74 placements 3330; semantic controls reject cold-wrapper alias, wrong entrance line, phase and width corruption.", + "author": "Wentao Li", + "ai_assistance": "Substantial AI assistance for derivation, implementation, checking and writing.", + "open_questions": [ + { + "question": "Can the checked group-B direct paths and endpoints be joined to the complete native dependency closure of their private cleanup?", + "why_it_matters": "Direct path equality does not independently validate every peer native warp, frame and physical implementation used by cleanup.", + "first_step": "Count private-touch events for 299/448/449/484/485 from RESULT.json bindings and bind each peer transition and warp to the full emitted source stream.", + "blocked_by": "Other helper and lender native recipes, common-chart bindings and complete physical execution remain inherited." + }, + { + "question": "Do the complete physical, precision/tape and outer obligations admit the unchanged PR2979 source after independent review?", + "why_it_matters": "The recounted recursive histogram and nominal physical families alone do not certify either supplier cap or a multiplication exponent.", + "first_step": "Use the exact PR2979 source head and existing native/owner evidence to audit physical/prefix release inputs, then independently check both supplier caps and their outer coupling.", + "blocked_by": "Full physical movement/storage realization, all private endpoints, precision/tape, bit supplier and outer release were not replayed." + } + ], + "existing_checks": [ + { + "pr": 2979, + "head": "be191346391661f4d35fc0d1508d0a6029572576", + "scope": "Joint construction, WORD/FULL-NATIVE/RESIDUAL-ADAPTER receipts and STAGE-PRICES; native producer retained, not newly discovered." + }, + { + "package": "research/rank7-group-a-entrance-audit", + "scope": "Group-A native residual binding methodology reused; helpers 331/450/451/508/509 and W_A are outside this package." + }, + { + "package": "research/rank7-group-b-single-control-audit", + "tip": "f795116d", + "scope": "Deferred soft-overlap: already registered guide margins +42541/-58943 and placement counts; this package answers its native-binding open question instead of reprinting those margins." + }, + { + "pr": 2993, + "head": "34a7003866390618b8e8006dc483e7a37a37903f", + "scope": "All-group local frame invoices; not imported here." + } + ], + "dependency_heads": { + "2979": "be191346391661f4d35fc0d1508d0a6029572576" + }, + "selection": { + "track": "independent-verification", + "task_id": "independent-moment", + "scope_key": "group-b-native-widths", + "method": "Handoff from deferred group-B single-control: bind emitted native residuals/wrappers for helpers 299/448/449/484/485; do not reprint STAGE-PRICES margins.", + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2612" + }, + "unchecked_obligations": [ + "Complete native/warp dependency closure and physical realization of peers", + "Normalized private endpoint rows for all group-B private buffers", + "Physical stock adequacy, movement, prefix/precision/tape", + "Complex root/packing cap, bit cap, outer release and inherited all-size/compiler/analytic hypotheses", + "STAGE-PRICES guide margins (already registered elsewhere; intentionally not reprinted)" + ], + "result_kind": "finite native/interface audit; no defect found in stated scope", + "refresh_checkpoint": { + "at_utc": "2026-10-18T00:50:00Z", + "canonical_main": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "priority_revision": 6, + "selected_kappa": "0.001672660197076918", + "changes": "Pin CrocSwap tip 6f100d4; leave alone open #3392/#3386/#3374/#3349 and deferred f795116d/1910fd12." + } +} diff --git a/research/rank7-group-b-native-widths-audit/VERIFY.json b/research/rank7-group-b-native-widths-audit/VERIFY.json new file mode 100644 index 0000000000..a6ff5c3cc6 --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/VERIFY.json @@ -0,0 +1,45 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/frontier1094-recipes-exact-seed76/clifford.py", + "research/rank7-joint-endframes/CLAIM.json", + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/FILL.json.gz", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/PROFILE.json", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "research/rank7-joint-endframes/data/PARENT-base.json.gz", + "research/rank7-joint-endframes/data/PARENT-extra.json.gz", + "research/rank7-joint-endframes/data/WORD-base.json.gz", + "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "research/rank7-joint-endframes/evidence/FULL-NATIVE-RECEIPT.json", + "research/two-sided-helper-extraction/vendor/fastnative/vendor/native/new/code/borrow/bw_emit.py", + "research/two-sided-helper-extraction/vendor/fastnative/vendor/native/new/code/borrow/bw_transport.py", + "research/two-sided-helper-extraction/vendor/fastnative/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Exact source-bound group-B native mixed-entrance residuals, wrapper/climb clocks, adapter pins, T74 width join and semantic controls; no STAGE-PRICES margin reprint." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/test_verify.py", + "-v" + ], + "timeout_seconds": 180, + "checks": "Native entrance/phase, wrapper/lifetime, scalar chronology/cleanup, owner geometry, actual-width mismatch, and source/event-receipt corruption/duplicate JSON." + } + ] +} diff --git a/research/rank7-group-b-native-widths-audit/common.py b/research/rank7-group-b-native-widths-audit/common.py new file mode 100644 index 0000000000..ce6016375c --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/common.py @@ -0,0 +1,84 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Bounded source loading for the group-B native-widths audit.""" + +import gzip +import hashlib +import io +import json +import sys +import types +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +SOURCE = "research/rank7-joint-endframes/" +ENGINE = "research/two-sided-helper-extraction/vendor/fastnative/vendor/native/new/code/borrow/" +COMPILER = ENGINE + "vendor/clifford/clifford_exact.py" +KERNEL = "research/frontier1094-recipes-exact-seed76/clifford.py" +HELPERS = (299, 448, 449, 484, 485) +W = [256, 128, 64, 34, 17, 11, 4] +ENTRANCE = [51] +WRONG_ENTRANCE = [4] +LIMIT = 64 * 1024 * 1024 + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def unique(pairs): + result = dict(pairs) + require(len(result) == len(pairs), "duplicate JSON key") + return result + + +def decode(raw, compressed=False): + if compressed: + with gzip.GzipFile(fileobj=io.BytesIO(raw)) as stream: + raw = stream.read(LIMIT + 1) + require(len(raw) <= LIMIT, "decoded input capacity") + return json.loads(raw, object_pairs_hook=unique) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def encoded(value): + return (json.dumps(value, sort_keys=True, separators=(",", ":")) + "\n").encode() + + +def authenticate(root=ROOT): + rows = decode((PACKAGE / "SOURCES.json").read_bytes())["files"] + pins = {r["path"]: r["sha256"] for r in rows if r["usage"] == "input"} + declared = set(decode((PACKAGE / "VERIFY.json").read_bytes())["inputs"]) + require(set(pins) == declared and len(pins) <= 24, "exact live input inventory") + blobs = {} + for name, sha in pins.items(): + path = root / name + require(path.stat().st_size <= LIMIT, "raw input capacity") + raw = path.read_bytes() + require(digest(raw) == sha, "source SHA256: " + name) + blobs[name] = raw + return blobs + + +def data(blobs, relative): + return decode(blobs[SOURCE + relative], relative.endswith(".gz")) + + +def module(raw, name): + """Compile authenticated bytes directly, without consulting a .pyc file.""" + result = types.ModuleType(name) + sys.modules[name] = result + exec(compile(raw, name, "exec"), result.__dict__) + return result + + +def reject(action, reason): + try: + action() + except (ValueError, AssertionError) as error: + return str(error) + raise ValueError("control accepted: " + reason) diff --git a/research/rank7-group-b-native-widths-audit/invoice.py b/research/rank7-group-b-native-widths-audit/invoice.py new file mode 100644 index 0000000000..c2741e178f --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/invoice.py @@ -0,0 +1,156 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent time-major width, source-window and complete histogram recount. + +The window convention is the retained PR2839 owner contract. This does not +reprove its native physical realization, movement or precision bounds. +Adapted from research/rank7-group-a-entrance-audit/invoice.py for group B. +""" + +from collections import Counter, defaultdict + +from common import HELPERS, data, digest, encoded, require + + +def widths(word): + live = [r for r in range(224, 704) if r not in word["removed"]] + require(len(live) == 408, "408 helper names") + result = [] + for h in live: + end_rank = len(word["helper_final"][str(h)]) if str(h) in word["helper_final"] else 9 + start = word["start_extra"].get(str(h), []) + result.append(end_rank - len(start)) + require(all(type(r) is int and 0 < r <= 9 for r in result), "positive native widths") + return live, result + + +def windows(template, order): + ranks = {} + for item in template["idle_children"]: + c, r = item["child"], item["rank"] + require(c not in ranks or ranks[c] == r, "unique source capacity") + ranks[c] = r + require(set(ranks) == set(range(18)), "18 idle children") + pairs = {e["stage"]: e["pair"] for e in template["recipe"] if e["kind"] == "local"} + blocks, stage = defaultdict(list), None + for event in template["execution_schedule"]: + kind = event["kind"] + if kind in ("bank_padding_cover_sweep", "translate_every_live_family"): + continue + if kind == "local_cover_sweep": + stage = event["stage"] + require(stage is not None, "initial local source event") + blocks[stage].append(event) + progress, last, result = [0] * 74, {}, {} + for time, (stage, replica) in enumerate(order): + require(0 <= replica < 74 and progress[replica] == stage, "source chronology") + progress[replica] += 1 + for event in blocks[stage]: + kind = event["kind"] + if kind == "local_cover_sweep": + last[replica, pairs[stage]] = time + elif kind == "bridge": + for pair in (event["src"], event["dst"]): + last[replica, pair] = time + elif kind == "idle_cover_sweep": + for child in event["child_indices"]: + if child not in ranks: + continue # Template padding children carry no helper slots. + require((replica, child) not in result, "one idle deadline") + result[replica, child] = (ranks[child], last.get((replica, event["pair"]), -1), time) + else: + require(kind in ("terminal", "terminal_Y_translations"), "known event") + require(progress == [9] * 74 and len(result) == 74 * 18, "all source windows") + return result + + +def recount(fill, order, dispatch, template, plan, words, local): + require(len(order) == len(dispatch) == 666 and [x[:2] for x in dispatch] == order, + "complete dispatch binding") + require(fill["columns"] == ["time", "helper", "owner_replica", "child", "port", "offset"], + "literal fill columns") + require(not fill["dispatch_overrides"], "no hidden provider override") + bounds = windows(template, order) + for event in template["execution_schedule"]: + if event["kind"] != "idle_cover_sweep": + continue + require(len(event["child_indices"]) == 2, "two ordered source sides") + for side, child in enumerate(event["child_indices"]): + if (0, child) in bounds: + require(plan["pairs"][str(child)] == event["pair"] and + plan["sides"][str(child)] == side, "source child family binding") + inventories = {tag: widths(word) for tag, word in words.items()} + names, ws = inventories["base"] + require(inventories["extra"] == (names, ws), "provider width equality") + tags = {"gauge44": "base", "extra": "extra"} + require(len(fill["rows"]) == 666 * 408, "all 271728 roles") + roles, families, bins = set(), set(), defaultdict(list) + group_rows = [] + for row in fill["rows"]: + require(len(row) == 6 and all(type(x) is int for x in row), "integer role record") + t, h, owner, child, port, offset = row + require(0 <= t < 666 and 0 <= h < 408 and 0 <= port < 112, "role domain") + require((t, h) not in roles, "unique helper role") + roles.add((t, h)) + require((owner, child) in bounds, "existing source bin") + cap, begin, end = bounds[owner, child] + require(begin < t <= end, "source availability") + family = (t, owner, 2 * plan["pairs"][str(child)] + plan["sides"][str(child)], port) + require(family not in families, "distinct per-call physical families") + families.add(family) + tag = tags[dispatch[t][2]] + width = inventories[tag][1][h] + require(0 <= offset and offset + width <= cap, "capacity at literal offset") + bins[owner, child, port].append((offset, width)) + if names[h] in HELPERS: + group_rows.append([*row, names[h], width]) + idle, occupied = Counter(), 0 + for (owner, child), (capacity, _, _) in sorted(bounds.items()): + for port in range(112): + cursor = 0 + for offset, width in sorted(bins.get((owner, child, port), [])): + require(offset == cursor, "nonoverlapping compact prefix") + cursor += width + occupied += cursor + if cursor < capacity: + idle[capacity - cursor] += 1 + complete = Counter(idle) + calls = Counter(tags[row[2]] for row in dispatch) + for tag, n in calls.items(): + complete.update({int(r): n * c for r, c in local[tag].items()}) + require(len(roles) == 666 * 408 and len(group_rows) == 666 * 5, "complete group coverage") + require(occupied == sum(ws) * 666, "used width conservation") + return {"calls": dict(calls), "roles": len(roles), "bins": 74 * 18 * 112, + "group_placements": len(group_rows), "group_rows_sha256": digest(encoded(group_rows)), + "group_widths": {str(h): ws[names.index(h)] for h in HELPERS}, + "width_inventory": dict(sorted(Counter(ws).items())), "width_mass": sum(ws), + "idle": dict(sorted(idle.items())), "complete": dict(sorted(complete.items())), + "rank_mass": sum(r * n for r, n in complete.items())} + + +def audit(blobs, words, profiles): + result = recount(data(blobs, "allocation/FILL.json.gz"), data(blobs, "allocation/ORDER.json"), + data(blobs, "allocation/DISPATCH.json"), data(blobs, "allocation/vendor/TEMPLATE.json.gz"), + data(blobs, "allocation/vendor/PLAN.json.gz"), words, profiles) + claimed = {int(r): n for r, n in data(blobs, "allocation/PROFILE.json").items()} + require(result["complete"] == claimed, "complete independently recounted invoice") + claim = data(blobs, "CLAIM.json") + require(result["group_widths"] == {"299": 7, "448": 6, "449": 6, "484": 6, "485": 6}, + "native group widths reach owner invoice") + require(result["rank_mass"] == 65088 * 74, "completed mass identity") + private = [set(map(int, word["helper_final"])) for word in words.values()] + require(private[0] == private[1] and len(private[0]) == claim["zero_buffers"] == 91, + "91 private names retained") + nominal = 896 * 74 + 408 + 8 + 91 + 2 + require(claim["live_families"] == 896 * 74 and claim["helpers"] == 408 and + claim["independent_inputs"] == 632, "nominal stock components") + require(nominal == claim["physical_families"] == 66813, "nominal physical stock declaration") + result["nominal_physical_stock"] = {"live": 66304, "helpers": 408, "centres": 8, + "private": 91, "scratch": 2, "total": nominal, + "status": "declaration reconciled; movement, physical realization and precision not proved"} + result["normalization"] = "sum(n_r * (r/73)^(1-a)) / (896*74)" + result["supplier_caps"] = { + "complex": {"source_claimed_endpoint": claim["complex_lower"], + "input_profile_recounted": True, "root_and_admission_replayed": False}, + "bit": {"changed_by_this_audit": False, "cap_or_outer_coupling_replayed": False}} + result["supplier_status"] = "Neither supplier cap is independently admitted here; no new kappa." + return result diff --git a/research/rank7-group-b-native-widths-audit/native.py b/research/rank7-group-b-native-widths-audit/native.py new file mode 100644 index 0000000000..68e84e534a --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/native.py @@ -0,0 +1,281 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Bind emitted group-B mixed-entrance wrappers, then check them with the retained exact kernel. + +Recipe generation follows DreamingOfClouds/PR458's bw_adapters.py. It is a +producer, not independent evidence. The separately implemented Gaussian kernel +is Sagar Thakrar's retained verifier; neither predecessor is new here. +Adapted from research/rank7-group-a-entrance-audit/native.py to helpers +299/448/449/484/485 and shared W = <256,128,64,34,17,11,4>. +""" + +import copy +import os +import subprocess +import sys +from common import COMPILER, ENGINE, ENTRANCE, HELPERS, KERNEL, W, WRONG_ENTRANCE +from common import data, decode, digest, encoded, module, reject, require + + +def bind_program_receipts(programs, checks): + require(set(programs) == set(checks) == {"forward", "backward"}, + "both emitted orientations") + for orientation, events in programs.items(): + row = checks[orientation] + require(row["events"] == len(events) and + row["sha256"] == digest(encoded(events)[:-1]), + "event stream digest in pinned receipt") + + +def generate(blobs, tag, work): + tools = work / "tools" + tools.mkdir() + for name in ("bw_transport.py", "bw_emit.py"): + (tools / name).write_bytes(blobs[ENGINE + name]) + word = work / "WORD.json.gz" + word.write_bytes(blobs[f"research/rank7-joint-endframes/data/WORD-{tag}.json.gz"]) + output = work / "local" + env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1") + env.pop("PYTHONOPTIMIZE", None) + for script, args in (("bw_transport.py", [word, output]), ("bw_emit.py", [output])): + run = subprocess.run([sys.executable, "-I", "-B", str(tools / script), + *map(str, args)], env=env, capture_output=True, + text=True, timeout=120, check=False) + require(run.returncode == 0, script + ": " + run.stderr[-2000:]) + receipt = data(blobs, "evidence/FULL-NATIVE-RECEIPT.json")["providers"][tag] + checks = (output / "LOCAL-CHECKS.json").read_bytes() + require(digest(checks) == receipt["complete_native_files"]["local/LOCAL-CHECKS.json"], + "emitted program receipt") + canonical = decode((output / "CANONICAL-WORD.json.gz").read_bytes(), True) + programs = decode((output / "LOCAL-PROGRAMS.json.gz").read_bytes(), True) + bind_program_receipts(programs, decode(checks)) + return canonical, programs, digest(checks) + + +def adapter_file(compiler, canonical): + """Reconstruct the original serialized file; its exact source receipt must match.""" + frames = canonical["frames"] + pairs = {(canonical["start"][r], canonical["final"][r]) + for r in range(224, 632)} + recipes, warps = {}, {} + for e, u in sorted(pairs): + if u == 1 and e == 0: + continue + entrance, terminal = frames[e], frames[u] + op = compiler.canonical_frame(9, tuple(entrance)).adjoint().then( + compiler.canonical_frame(9, tuple(terminal))) + rec, _ = compiler.lower_child(op) + row = dict(frame=e, vectors=entrance, entrance_rank=len(entrance), + rank=rec["rank"], left=rec["left"], right=rec["right"]) + key = str(e) + if u != 1: + row.update(terminal=u, terminal_vectors=terminal, terminal_rank=len(terminal)) + key = f"{e}:{u}" + recipes[key] = row + for w in canonical["warps"]: + columns = tuple(w["G_columns"]) + matrix = compiler.transpose(columns, 9) + inverse_columns = compiler.transpose(compiler.inv(matrix, 9), 9) + q = tuple((1 << i) ^ sum(compiler.parity(a & b) << j + for j, b in enumerate(inverse_columns)) + for i, a in enumerate(inverse_columns)) + op = compiler.perm(9, matrix).then(compiler.diag(9, q)) + _, rec = compiler.monomial(op) + warps[str(w["op"])] = dict(op=w["op"], from_frame=w["from_frame"], + to_frame=w["to_frame"], G_columns=w["G_columns"], K=rec) + return decode(encoded(dict(status="RESIDUAL_ADAPTER_RECIPES", recipes=recipes, warps=warps))) + + +def conjugate(circuit): + out = [] + for gate in circuit: + if gate[0] == "C": + out.append(("C", gate[1], -gate[2])) + elif gate[0] == "D": + out.append(("D", gate[1], [-a % 4 for a in gate[2]])) + elif gate[0] == "PH": + out.append(("PH", -gate[1] % 4)) + else: + require(gate[0] in ("P", "X"), "real monomial primitive") + out.append(gate) + return out + + +def check_recipe(kernel, rec, entrance, terminal): + width = len(terminal) - len(entrance) + require(type(rec["rank"]) is int and rec["rank"] == width, "entrance-relative width") + require(kernel.well_formed(rec["left"]) and + (rec["right"] is None or kernel.well_formed(rec["right"])), + "serialized monomials") + left = kernel.monomial(rec["left"]) + right = [] if rec["right"] is None else kernel.monomial(rec["right"]) + reference = kernel.adjoint(kernel.canonical_frame(entrance)) + kernel.canonical_frame(terminal) + candidate = right + kernel.fourier(width) + left + wrapped = kernel.adjoint(right) + reference + kernel.adjoint(left) + require(kernel.same_operator(candidate, reference), "phase-exact all-column residual") + require(kernel.same_operator(wrapped, kernel.fourier(width)), "wrapped coordinate factor") + require(kernel.same_operator(conjugate(wrapped), kernel.fourier(width, -1)), + "inverse-transpose coordinate factor") + return {"rank": width, "columns": 512, "orientations": 2, + "spectator_axes": 9 - width, "recipe": rec} + + +def source_events(word, helper): + """Reconstruct all direct scalar clocks and climbs from the original word.""" + private = 704 + helper + touched = {helper, private} + for section in ("precondition", "compensation", "cut"): + require(all(not (touched & set(g[1:3] if g[0] == "add" else g[1:2])) + for g in word[section]), "no uncovered direct source section") + require(all(not (touched & {c["source"], c["target"]}) + for c in word["initial_corrections"]), "no uncovered direct correction") + require(all(w[1] != helper for w in word["warps"]), "no direct lender warp") + scalars, climbs = [], [] + current = word["start_extra"].get(str(helper), []) + for section, phase in (("A", "A"), ("B", "B"), ("restore", "cleanup_tail"), + ("cleanup", "full_frame_cleanup")): + clock = 0 + for gate in word[section]: + regs = gate[1:3] if gate[0] == "add" else gate[1:2] + if touched & set(regs): + require(gate[0] in ("add", "scale"), "no direct source warp") + if helper in regs and current != gate[-1]: + climbs.append([phase, clock, current, gate[-1], len(gate[-1]) - len(current)]) + current = gate[-1] + scalars.append([phase, clock, gate[:-1], gate[-1]]) + clock += gate[0] != "warp" + require(current == W, "source reaches the terminal frame") + return scalars, climbs + + +def scalar_original(operation, kept, backward): + require(operation[0] in ("add", "scale", "copy", "clear"), "known emitted scalar") + count = 2 if operation[0] in ("add", "copy") else 1 + regs = [] + for kind, r in operation[1:1 + count]: + require(kind in ("L", "Z", "C"), "register namespace") + regs.append(-1 if kind == "C" else kept[r] + (704 if kind == "Z" else 0)) + row = [operation[0], *regs, *operation[1 + count:]] + if backward and row[0] == "add": + row[1], row[2], row[3] = row[2], row[1], -row[3] + elif backward and row[0] == "scale": + row[2], row[3] = row[3], row[2] + return row, regs + + +def emitted_binding(word, canonical, stream, helper, backward=False): + """A separate boundary check: entrance pair, climbs, cleanup lifetime and wrappers.""" + kept = [r for r in range(704) if r not in word["removed"]] + require(canonical["helper_origin"] == kept[224:], "original-to-compact binding") + r = kept.index(helper) + e, u = canonical["start"][r], canonical["final"][r] + entrance = word["start_extra"].get(str(helper), []) + require(canonical["frames"][e] == entrance and canonical["frames"][u] == W, + "literal entrance/terminal pair") + wrappers, buffers, climbs, private_uses, scalars, climb_clocks = [], [], [], [], [], [] + scalar_indices = [] + phase, clock = None, 0 + for i, event in enumerate(stream): + if event[0] == "phase": + phase, clock = event[1], 0 + elif event[0] == "residual_adapter" and event[2] == r: + require(event[3:] == [e, u], "emitted wrapper pair") + wrappers.append([i, event[1]]) + elif event[0] == "zero_buffer" and event[2] == r: + buffers.append([i, event[1]]) + elif event[0] == "climb" and event[2] == r: + old, new = (canonical["frames"][f] for f in event[3:5]) + require(event[5] == len(new) - len(old) > 0, "emitted climb rank") + climbs.append({"index": i, "old": old, "new": new, "rank": event[5]}) + climb_clocks.append([phase, clock, old, new, event[5]]) + elif event[0] == "scalar": + row, regs = scalar_original(event[1], kept, backward) + if helper in regs or helper + 704 in regs: + scalars.append([phase, clock, row, canonical["frames"][event[2]]]) + scalar_indices.append(i) + if ["Z", r] in event[1][1:3]: + private_uses.append(i) + clock += 1 + elif event[0] == "warp": + require(event[1] not in (["L", r], ["Z", r]), "no unaccounted direct warp") + elif event[0] == "adapter": + require(event[2] != r, "ordinary adapter cannot replace residual wrapper") + expected_scalars, expected_climbs = source_events(word, helper) + require(scalars == expected_scalars and climb_clocks == expected_climbs, + "source-to-emission direct scalar/climb clocks") + require([x[1] for x in wrappers] == ["pre", "post"], "two residual wrappers") + require([x[1] for x in buffers] == ["alloc", "free"], "private lifetime") + require(private_uses and wrappers[0][0] < buffers[0][0] < min(private_uses) + <= max(private_uses) < buffers[1][0] < wrappers[1][0], "cleanup before post-wrapper") + require(r in canonical["zero_buffers"], "private buffer counted") + current = entrance + for climb in climbs: + require(climb["old"] == current, "complete direct climb chain") + current = climb["new"] + require(current == W and sum(c["rank"] for c in climbs) == len(W) - len(entrance), + "complete entrance-relative path") + return {"compact_helper": r, "recipe_key": f"{e}:{u}", "entrance": entrance, + "terminal": W, "wrappers": wrappers, "buffers": buffers, + "private_uses": private_uses, "climbs": climbs, + "direct_scalar_count": len(scalars), "direct_scalar_indices": scalar_indices, + "direct_scalar_sha256": digest(encoded(scalars))} + + +def audit(blobs, tag, work): + compiler = module(blobs[COMPILER], "group_b_source_compiler") + kernel = module(blobs[KERNEL], "group_b_independent_kernel") + canonical, programs, checks_sha = generate(blobs, tag, work) + adapters = adapter_file(compiler, canonical) + expected = data(blobs, "evidence/FULL-NATIVE-RECEIPT.json")["providers"][tag] + require(digest(encoded(adapters)) == expected["complete_native_files"]["local/RESIDUAL-ADAPTERS.json"], + "complete serialized adapter source receipt") + word = data(blobs, f"data/WORD-{tag}.json.gz") + bindings, recipes, climb_recipes = {}, {}, {} + for h in HELPERS: + bindings[str(h)] = {orientation: emitted_binding(word, canonical, stream, h, orientation == "backward") + for orientation, stream in programs.items()} + row = bindings[str(h)]["forward"] + key = row["recipe_key"] + if key not in recipes: + recipes[key] = check_recipe(kernel, adapters["recipes"][key], row["entrance"], W) + for climb in row["climbs"]: + old, new = climb["old"], climb["new"] + identity = encoded([old, new]).decode().strip() + if identity not in climb_recipes: + op = compiler.canonical_frame(9, tuple(old)).adjoint().then( + compiler.canonical_frame(9, tuple(new))) + candidate, _ = compiler.lower_child(op) + candidate = decode(encoded(candidate)) + climb_recipes[identity] = check_recipe(kernel, candidate, old, new) + entering = bindings["448"]["forward"]["recipe_key"] + cold = bindings["299"]["forward"]["recipe_key"] + rec = adapters["recipes"][entering] + controls = {} + controls["omitted_entrance"] = reject(lambda: check_recipe(kernel, rec, [], W), "entrance") + bad = copy.deepcopy(rec); bad["left"]["phase"] = (bad["left"]["phase"] + 1) % 4 + controls["phase"] = reject(lambda: check_recipe(kernel, bad, ENTRANCE, W), "phase") + bad = copy.deepcopy(rec); bad["right"] = adapters["recipes"][cold]["right"] + controls["cold_wrapper_alias"] = reject(lambda: check_recipe(kernel, bad, ENTRANCE, W), "cold alias") + # A same-rank wrong entrance tests operator semantics, rather than metadata alone. + controls["wrong_entrance_line"] = reject( + lambda: check_recipe(kernel, rec, WRONG_ENTRANCE, W), "wrong line") + parent = data(blobs, f"data/PARENT-{tag}.json.gz") + comparison = {} + for h in (299, 448): + entrance = parent["start_extra"].get(str(h), []) + terminal = parent["helper_final"][str(h)] + require(len(terminal) == 8, "rank-eight parent terminal") + op = compiler.canonical_frame(9, tuple(entrance)).adjoint().then( + compiler.canonical_frame(9, tuple(terminal))) + candidate, _ = compiler.lower_child(op) + comparison[str(h)] = {"entrance": entrance, "parent_terminal": terminal, + "parent": check_recipe(kernel, decode(encoded(candidate)), entrance, terminal), + "joint_recipe_key": cold if h == 299 else entering} + require(all(parent["start_extra"][str(h)] == ENTRANCE and + parent["helper_final"][str(h)] == comparison["448"]["parent_terminal"] + for h in HELPERS[1:]), "four common entering parent pairs") + require(bindings["299"]["forward"]["entrance"] == [] and + all(bindings[str(h)]["forward"]["entrance"] == ENTRANCE for h in HELPERS[1:]), + "group-B entrance inventory") + return {"local_checks_sha256": checks_sha, "adapter_sha256": digest(encoded(adapters)), + "bindings": bindings, "residuals": recipes, "climb_recipes": climb_recipes, + "parent_residual_comparison": comparison, "controls": controls} diff --git a/research/rank7-group-b-native-widths-audit/test_verify.py b/research/rank7-group-b-native-widths-audit/test_verify.py new file mode 100644 index 0000000000..b569e25c47 --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/test_verify.py @@ -0,0 +1,155 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Semantic failures at the actual group-B wrapper and owner boundaries.""" + +import copy +import sys +import tempfile +import unittest +from pathlib import Path + +HERE = Path(__file__).resolve().parent +if str(HERE) not in sys.path: + sys.path.insert(0, str(HERE)) + +import invoice +import native +from common import ENTRANCE, KERNEL, PACKAGE, W, WRONG_ENTRANCE, authenticate, data, decode, module + + +class BoundaryTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.blobs = authenticate() + cls.word = data(cls.blobs, "data/WORD-base.json.gz") + cls.result = decode((PACKAGE / "RESULT.json").read_bytes()) + cls.kernel = module(cls.blobs[KERNEL], "group_b_test_kernel") + cls.tmp = tempfile.TemporaryDirectory(prefix="group-b-tests-") + cls.canonical, cls.programs, _ = native.generate(cls.blobs, "base", Path(cls.tmp.name)) + cls.entering_key = cls.result["native_to_owner_join"]["base"]["448"]["native_pair"] + cls.cold_key = cls.result["native_to_owner_join"]["base"]["299"]["native_pair"] + + @classmethod + def tearDownClass(cls): + cls.tmp.cleanup() + + def bind(self, stream, h=448, backward=False): + return native.emitted_binding(self.word, self.canonical, stream, h, backward) + + def test_native_semantics(self): + recipes = self.result["native"]["base"]["residuals"] + rec = recipes[self.entering_key]["recipe"] + native.check_recipe(self.kernel, rec, ENTRANCE, W) + with self.assertRaisesRegex(ValueError, "phase-exact"): + native.check_recipe(self.kernel, rec, WRONG_ENTRANCE, W) + wrong = copy.deepcopy(rec) + wrong["right"] = recipes[self.cold_key]["recipe"]["right"] + with self.assertRaisesRegex(ValueError, "phase-exact"): + native.check_recipe(self.kernel, wrong, ENTRANCE, W) + wrong = copy.deepcopy(rec) + wrong["left"]["phase"] = (wrong["left"]["phase"] + 1) % 4 + with self.assertRaisesRegex(ValueError, "phase-exact"): + native.check_recipe(self.kernel, wrong, ENTRANCE, W) + with self.assertRaisesRegex(ValueError, "width"): + native.check_recipe(self.kernel, rec, [], W) + + def test_wrapper_and_lifetime_controls(self): + stream = self.programs["forward"] + self.bind(stream) + self.bind(self.programs["backward"], backward=True) + binding = self.result["native"]["base"]["bindings"]["448"]["forward"] + bad = copy.deepcopy(stream) + bad[binding["wrappers"][0][0]][3] = 0 + with self.assertRaisesRegex(ValueError, "wrapper pair"): + self.bind(bad) + bad = copy.deepcopy(stream) + del bad[binding["wrappers"][1][0]] + with self.assertRaisesRegex(ValueError, "two residual wrappers"): + self.bind(bad) + bad = copy.deepcopy(stream) + free = bad.pop(binding["buffers"][1][0]) + bad.insert(binding["private_uses"][0], free) + with self.assertRaisesRegex(ValueError, "cleanup before"): + self.bind(bad) + + def test_scalar_clocks_and_cleanup_controls(self): + stream = self.programs["forward"] + binding = self.result["native"]["base"]["bindings"]["448"]["forward"] + position = binding["private_uses"][0] + bad = copy.deepcopy(stream) + del bad[position] + with self.assertRaisesRegex(ValueError, "scalar/climb clocks"): + self.bind(bad) + bad = copy.deepcopy(stream) + bad[position][1][3] *= -1 + with self.assertRaisesRegex(ValueError, "scalar/climb clocks"): + self.bind(bad) + # Move a direct operation past a disjoint scalar, preserving its own order. + r = binding["compact_helper"] + later = next(i for i in range(position + 1, binding["buffers"][1][0]) + if stream[i][0] == "scalar" and ["Z", r] not in stream[i][1][1:3]) + bad = copy.deepcopy(stream) + moved = bad.pop(position) + bad.insert(later, moved) + with self.assertRaisesRegex(ValueError, "scalar/climb clocks"): + self.bind(bad) + + def recount(self, fill=None, words=None, plan=None): + b = self.blobs + return invoice.recount(fill if fill is not None else data(b, "allocation/FILL.json.gz"), + data(b, "allocation/ORDER.json"), data(b, "allocation/DISPATCH.json"), + data(b, "allocation/vendor/TEMPLATE.json.gz"), + plan if plan is not None else data(b, "allocation/vendor/PLAN.json.gz"), + words if words is not None else {tag: data(b, f"data/WORD-{tag}.json.gz") for tag in ("base", "extra")}, + {tag: data(b, f"data/WORD-{tag}.json.gz")["report"]["local_profile"] for tag in ("base", "extra")}) + + def test_owner_geometry_controls(self): + good = self.recount() + self.assertEqual(good["idle"], {1: 17310, 3: 4956, 5: 1728, 48: 28190}) + fill = data(self.blobs, "allocation/FILL.json.gz") + bad = copy.deepcopy(fill); bad["rows"][1] = bad["rows"][0][:] + with self.assertRaisesRegex(ValueError, "unique helper role"): + self.recount(bad) + bad = copy.deepcopy(fill); bad["rows"].pop() + with self.assertRaisesRegex(ValueError, "271728 roles"): + self.recount(bad) + bad = copy.deepcopy(fill); bad["rows"][0][5] = 48 + with self.assertRaisesRegex(ValueError, "capacity"): + self.recount(bad) + plan = data(self.blobs, "allocation/vendor/PLAN.json.gz") + plan["sides"]["0"] ^= 1 + with self.assertRaisesRegex(ValueError, "source child family"): + self.recount(plan=plan) + + def test_entrance_width_reaches_actual_fill(self): + words = {tag: data(self.blobs, f"data/WORD-{tag}.json.gz") for tag in ("base", "extra")} + for word in words.values(): + del word["start_extra"]["448"] + # Using terminal rank seven as the helper width breaks the actual packing. + with self.assertRaisesRegex(ValueError, "capacity|compact prefix"): + self.recount(words=words) + + def test_source_corruption_and_duplicate_keys(self): + checks = decode((Path(self.tmp.name) / "local/LOCAL-CHECKS.json").read_bytes()) + native.bind_program_receipts(self.programs, checks) + changed = copy.deepcopy(self.programs) + changed["forward"].pop() + with self.assertRaisesRegex(ValueError, "event stream digest"): + native.bind_program_receipts(changed, checks) + changed = copy.deepcopy(self.programs) + changed["forward"][-1][-1] = "changed event" + with self.assertRaisesRegex(ValueError, "event stream digest"): + native.bind_program_receipts(changed, checks) + first = next(iter(self.blobs)) + with tempfile.TemporaryDirectory(prefix="group-b-corruption-") as tmp: + root = Path(tmp) + target = root / first + target.parent.mkdir(parents=True) + target.write_bytes(self.blobs[first] + b"\n# corrupt\n") + with self.assertRaisesRegex(ValueError, "source SHA256"): + authenticate(root) + with self.assertRaisesRegex(ValueError, "duplicate JSON key"): + decode(b'{"frame":0,"frame":115}') + + +if __name__ == "__main__": + unittest.main() diff --git a/research/rank7-group-b-native-widths-audit/verify.py b/research/rank7-group-b-native-widths-audit/verify.py new file mode 100644 index 0000000000..b1d81e4676 --- /dev/null +++ b/research/rank7-group-b-native-widths-audit/verify.py @@ -0,0 +1,71 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Group B native residual / wrapper widths and T74 owner join; no STAGE-PRICES margins.""" + +import json +import sys +import tempfile +from pathlib import Path + +HERE = Path(__file__).resolve().parent +if str(HERE) not in sys.path: + sys.path.insert(0, str(HERE)) + +import invoice +import native +from common import HELPERS, PACKAGE, authenticate, data, decode, require + + +def compute(): + blobs = authenticate() + words = {tag: data(blobs, f"data/WORD-{tag}.json.gz") for tag in ("base", "extra")} + profiles = {tag: word["report"]["local_profile"] for tag, word in words.items()} + native_results = {} + for tag in words: + with tempfile.TemporaryDirectory(prefix="group-b-native-") as work: + native_results[tag] = native.audit(blobs, tag, Path(work)) + result = {"schema_version": 1, "status": "PASS_GROUP_B_NATIVE_WIDTHS", + "native": native_results, + "invoice": invoice.audit(blobs, words, profiles)} + names, widths = invoice.widths(words["base"]) + joins = {} + for tag, record in native_results.items(): + joins[tag] = {} + for h in HELPERS: + binding = record["bindings"][str(h)]["forward"] + key = binding["recipe_key"] + rank = record["residuals"][key]["rank"] + require(rank == widths[names.index(h)] and + binding["compact_helper"] == 224 + names.index(h), "native-to-owner width join") + joins[tag][str(h)] = {"helper_index": names.index(h), "native_pair": key, "width": rank} + result["native_to_owner_join"] = joins + # Headline native facts only; do not register STAGE-PRICES guide margins here. + ranks = [joins["base"][str(h)]["width"] for h in HELPERS] + require(ranks == [7, 6, 6, 6, 6], "emitted residual widths 7/6/6/6/6") + require(result["invoice"]["group_placements"] == 3330, "T74 fill places group B 3330 times") + for tag, record in native_results.items(): + require(set(record["residuals"]) >= { + joins[tag]["299"]["native_pair"], joins[tag]["448"]["native_pair"]}, + "cold and entering residual classes") + require(record["bindings"]["299"]["forward"]["entrance"] == [], "helper299 cold entrance") + require(all(record["bindings"][str(h)]["forward"]["entrance"] == [51] + for h in HELPERS[1:]), "entering helpers at span(51)") + require(authenticate() == blobs, "source stability during replay") + return decode(json.dumps(result).encode()) + + +def main(): + require(sys.argv[1:] in ([], ["--emit"]), "usage: verify.py [--emit]") + result = compute() + if sys.argv[1:]: + print(json.dumps(result, indent=2, sort_keys=True)) + else: + require(decode((PACKAGE / "RESULT.json").read_bytes()) == result, "deterministic receipt") + joins = result["native_to_owner_join"]["base"] + pairs = ",".join(f'{h}:{joins[str(h)]["native_pair"]}' for h in HELPERS) + print(result["status"] + + f" providers=2 helpers=5 residual_widths=7,6,6,6,6 pairs={pairs}" + + " placements=3330 adapter_pinned both_orientations no_new_kappa") + + +if __name__ == "__main__": + main()