diff --git a/research/rank7-group-d-native-widths-audit/MASTER-HANDOFF.md b/research/rank7-group-d-native-widths-audit/MASTER-HANDOFF.md new file mode 100644 index 0000000000..127f7d1acf --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/MASTER-HANDOFF.md @@ -0,0 +1,80 @@ +# Master handoff: rank7-group-d-native-widths-audit + +## Result + +Group D of #2979: both providers and both orientations emit residual pair +`114:263` for helpers 454/455/556/557 (entrance `[51]`, width **6**) under +shared `W = ⟨256,128,64,37,21,8,3⟩`. Adapter and `LOCAL-CHECKS` hashes match +the retained `FULL-NATIVE-RECEIPT.json`. These widths join all **2664** T74 +fill placements. No new kappa. + +**Not headlined (soft-overlap trap):** guide margins `+17170` / single-helper +negatives — already in `#2979` `STAGE-PRICES.json` / joint-frame invoices. 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-d-native-widths-60b9` +- Content tip SHA: `79cfa71e44968c0d6f5ca5df92a038aea12e354a` +- Publish tip: branch HEAD of `cursor/group-d-native-widths-60b9` (docs-only handoff commits may follow content tip) +- Package: `research/rank7-group-d-native-widths-audit/` + +## Exact commands + +```sh +python3.12 -I -B research/rank7-group-d-native-widths-audit/verify.py +python3.12 -I -O -Werror -B research/rank7-group-d-native-widths-audit/verify.py +python3.12 -I -O -Werror -B research/rank7-group-d-native-widths-audit/test_verify.py -v +python3.12 -I -B scripts/research_package.py --package research/rank7-group-d-native-widths-audit --check-only +python3.12 -I -B scripts/research_package.py --package research/rank7-group-d-native-widths-audit +``` + +## Expected PASS lines + +```text +PASS_GROUP_D_NATIVE_WIDTHS providers=2 helpers=4 residual_widths=6,6,6,6 pairs=454:114:263,455:114:263,556:114:263,557:114:263 placements=2664 adapter_pinned both_orientations no_new_kappa +PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check) +PASS_REGISTERED_RESEARCH_PACKAGE research/rank7-group-d-native-widths-audit outcome=partial +``` + +(`-O` verify must print the same `PASS_GROUP_D_NATIVE_WIDTHS` line; `need`/`require` +admission stays enforced.) + +## Closest priors + +| Prior | Relation | +|---|---| +| `research/rank7-group-a-entrance-audit/` | Methodology predecessor; different helpers/W | +| #3411 `research/rank7-group-b-native-widths-audit/` | Leave-alone group-B native style; different helpers/W | +| `research/rank7-group-c-native-widths-audit/` @ `ad6350cbb` | In-flight group-C native; OQ3 asked for this group-D audit | +| `research/rank7-joint-endframes/` (#2979 @ `be191346…`) | Source WORD / FULL-NATIVE / adapters | +| #2993 `rank7-joint-frame-audit` | Frame invoices; not imported | + +## What is new vs soft-overlap traps + +- **New:** phase-exact residual class `114:263`, entrance `[51]`, climb/wrapper/scalar clocks in both orientations, adapter pin match, native-width → T74 join for helpers `{454,455,556,557}` (2664 placements). +- **Do not claim as new:** joint/single guide margins `+17170`, width inventory `6/6/6/6` alone without native residual binding, or placement counts alone. + +## Open next questions + +1. Complete peer-native / private-cleanup dependency closure for group D. +2. Physical movement, precision/tape, supplier caps and outer release for the + unchanged #2979 source. + +## Leave-alone + +Open CrocSwap #3421, #3411, #3392, #3386, #3374, #3349; deferred V45 `1910fd12`; +deferred group-B single-control `f795116d`; deferred stock rho=0; blocked W=532 +unpaid F17 terms; merged tariff series through #2883; do not reprint #3259 / +`p104-pooled-cut-independent`; in-flight group C +`cursor/group-c-native-widths-60b9` @ `ad6350cbb`. + +## 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-d-native-widths-audit/NOTICE.md b/research/rank7-group-d-native-widths-audit/NOTICE.md new file mode 100644 index 0000000000..c41a4000ca --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/NOTICE.md @@ -0,0 +1,27 @@ +# 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/`, +`research/rank7-group-b-native-widths-audit/` and +`research/rank7-group-c-native-widths-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 all-entering group D. +- Leave-alone #3411 / `rank7-group-b-native-widths-audit` — group-B native + residual binding style reused; helpers/W are disjoint. +- In-flight `rank7-group-c-native-widths-audit` @ `ad6350cbb` — group-C native + residual binding style reused; its OQ3 asked for this group-D audit. + +Author: Wentao Li +Prepared by Wentao Li with substantial AI assistance. diff --git a/research/rank7-group-d-native-widths-audit/README.md b/research/rank7-group-d-native-widths-audit/README.md new file mode 100644 index 0000000000..93a9eebc4e --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/README.md @@ -0,0 +1,101 @@ +# Group D'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 entering-residual check for group D. +Helpers 454, 455, 556 and 557 enter at `[51]` and end at +`W = [256,128,64,37,21,8,3]`. Their emitted residual width is **six**, not +the terminal dimension seven. Exact native identities include global phase and +both orientations. These widths bind to all 2,664 group-D placements in the +shipped T74 allocation. Adapter and `LOCAL-CHECKS` hashes match the retained +`FULL-NATIVE-RECEIPT.json`. The four helpers share one residual pair +`114:263`. + +This package deliberately does **not** headline the already-registered guide +margins `+17170` / single-helper negatives from `#2979` +`STAGE-PRICES.json`. The contribution here is the native residual / wrapper +binding for group D, in the style of leave-alone #3411 (group B) and the +in-flight group-C native-widths audit. + +### Existing coverage and the added check + +`research/rank7-group-a-entrance-audit/` binds group A +(`331/450/451/508/509`, `W_A`). Leave-alone #3411 +`research/rank7-group-b-native-widths-audit/` binds group B +(`299/448/449/484/485`, `W_B`). In-flight +`research/rank7-group-c-native-widths-audit/` @ `ad6350cbb` binds group C +(`452/453/532/533`, `W_C`) and left group D as its open next question. +Group D is outside those packages. + +## 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 | +|---|---|---:|---:|---:| +| 454, 455, 556, 557 | span(51) | 8 | 7 | 6 | + +Here `51 = 37 xor 21 xor 3` lies in the span of `W`. Treating an entering +helper as cold would select width seven and break the shipped packing. The +parent right wrapper (width seven) is not interchangeable with the joint +width-six recipe: the all-column check rejects that substitution. A different +contained line, `[3]`, has the same dimension but also fails with the actual +`[51]` recipe. The same-width group-C terminal span +`⟨256,128,64,32,19,11,6⟩` likewise fails against the group-D 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-d-native-widths-audit/verify.py +python3 -I -O -B research/rank7-group-d-native-widths-audit/verify.py +python3 -I -B research/rank7-group-d-native-widths-audit/test_verify.py -v +python3 -I -B scripts/research_package.py --package research/rank7-group-d-native-widths-audit --check-only +python3 -I -B scripts/research_package.py --package research/rank7-group-d-native-widths-audit +``` + +Expected verify line: + +```text +PASS_GROUP_D_NATIVE_WIDTHS providers=2 helpers=4 residual_widths=6,6,6,6 pairs=454:114:263,455:114:263,556:114:263,557:114:263 placements=2664 adapter_pinned both_orientations no_new_kappa +``` + +## Open next questions + +1. Can the checked group-D 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, leave-alone #3411 group-B native widths, and the in-flight group-C +native-widths tip `ad6350cbb`. 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-d-native-widths-audit/RESULT.json b/research/rank7-group-d-native-widths-audit/RESULT.json new file mode 100644 index 0000000000..3e428f0a48 --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/RESULT.json @@ -0,0 +1,5467 @@ +{ + "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": 2664, + "group_rows_sha256": "c8d8cb9db4ea1cb47b31d94ea90f8ba1a3fa2f3a490babb95a3a1c298c4ca26d", + "group_widths": { + "454": 6, + "455": 6, + "556": 6, + "557": 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": { + "454": { + "backward": { + "buffers": [ + [ + 17214, + "alloc" + ], + [ + 22512, + "free" + ] + ], + "climbs": [ + { + "index": 12951, + "new": [ + 448, + 38, + 21 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13418, + "new": [ + 264, + 136, + 64, + 38, + 21 + ], + "old": [ + 448, + 38, + 21 + ], + "rank": 2 + }, + { + "index": 14612, + "new": [ + 264, + 136, + 64, + 37, + 21, + 3 + ], + "old": [ + 264, + 136, + 64, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15936, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 264, + 136, + 64, + 37, + 21, + 3 + ], + "rank": 1 + } + ], + "compact_helper": 454, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12033, + 12035, + 12952, + 13419, + 14613, + 15938, + 15940, + 17423, + 17424, + 18174, + 18385 + ], + "direct_scalar_sha256": "9ba3458f09ad70a2cb950ae67d694a0c01f655859d374e21a31b9758e61beaf0", + "entrance": [ + 51 + ], + "private_uses": [ + 17423, + 17424, + 18174, + 18385 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6492, + "pre" + ], + [ + 22603, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17214, + "alloc" + ], + [ + 22512, + "free" + ] + ], + "climbs": [ + { + "index": 12951, + "new": [ + 448, + 38, + 21 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13418, + "new": [ + 264, + 136, + 64, + 38, + 21 + ], + "old": [ + 448, + 38, + 21 + ], + "rank": 2 + }, + { + "index": 14612, + "new": [ + 264, + 136, + 64, + 37, + 21, + 3 + ], + "old": [ + 264, + 136, + 64, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15936, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 264, + 136, + 64, + 37, + 21, + 3 + ], + "rank": 1 + } + ], + "compact_helper": 454, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12033, + 12035, + 12952, + 13419, + 14613, + 15938, + 15940, + 17423, + 17424, + 18174, + 18385 + ], + "direct_scalar_sha256": "9ba3458f09ad70a2cb950ae67d694a0c01f655859d374e21a31b9758e61beaf0", + "entrance": [ + 51 + ], + "private_uses": [ + 17423, + 17424, + 18174, + 18385 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6492, + "pre" + ], + [ + 22603, + "post" + ] + ] + } + }, + "455": { + "backward": { + "buffers": [ + [ + 17215, + "alloc" + ], + [ + 22513, + "free" + ] + ], + "climbs": [ + { + "index": 12953, + "new": [ + 469, + 51, + 11 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13423, + "new": [ + 259, + 131, + 85, + 51, + 11 + ], + "old": [ + 469, + 51, + 11 + ], + "rank": 2 + }, + { + "index": 14618, + "new": [ + 256, + 128, + 85, + 48, + 8, + 3 + ], + "old": [ + 259, + 131, + 85, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15941, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 256, + 128, + 85, + 48, + 8, + 3 + ], + "rank": 1 + } + ], + "compact_helper": 455, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12037, + 12039, + 12954, + 13424, + 14619, + 15943, + 15945, + 17421, + 17422, + 18172, + 18384 + ], + "direct_scalar_sha256": "c2b9d5e06b0c0b804bb49be48cf11db43c9c55f437cfcceea0a79c6591390173", + "entrance": [ + 51 + ], + "private_uses": [ + 17421, + 17422, + 18172, + 18384 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6493, + "pre" + ], + [ + 22604, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17215, + "alloc" + ], + [ + 22513, + "free" + ] + ], + "climbs": [ + { + "index": 12953, + "new": [ + 469, + 51, + 11 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13423, + "new": [ + 259, + 131, + 85, + 51, + 11 + ], + "old": [ + 469, + 51, + 11 + ], + "rank": 2 + }, + { + "index": 14618, + "new": [ + 256, + 128, + 85, + 48, + 8, + 3 + ], + "old": [ + 259, + 131, + 85, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15941, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 256, + 128, + 85, + 48, + 8, + 3 + ], + "rank": 1 + } + ], + "compact_helper": 455, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12037, + 12039, + 12954, + 13424, + 14619, + 15943, + 15945, + 17421, + 17422, + 18172, + 18384 + ], + "direct_scalar_sha256": "c2b9d5e06b0c0b804bb49be48cf11db43c9c55f437cfcceea0a79c6591390173", + "entrance": [ + 51 + ], + "private_uses": [ + 17421, + 17422, + 18172, + 18384 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6493, + "pre" + ], + [ + 22604, + "post" + ] + ] + } + }, + "556": { + "backward": { + "buffers": [ + [ + 17234, + "alloc" + ], + [ + 22532, + "free" + ] + ], + "climbs": [ + { + "index": 13415, + "new": [ + 328, + 200, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13417, + "new": [ + 264, + 136, + 64, + 38, + 21 + ], + "old": [ + 328, + 200, + 51 + ], + "rank": 2 + }, + { + "index": 14609, + "new": [ + 256, + 128, + 64, + 38, + 21, + 8 + ], + "old": [ + 264, + 136, + 64, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15939, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 256, + 128, + 64, + 38, + 21, + 8 + ], + "rank": 1 + } + ], + "compact_helper": 550, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12062, + 13416, + 13419, + 14610, + 15940, + 16013, + 16015, + 17382, + 17383, + 17423, + 18174, + 18175 + ], + "direct_scalar_sha256": "2a0c273d7f1caa8133a50dc3e35f1426debf4032789f31edfc3f3f9d655abcad", + "entrance": [ + 51 + ], + "private_uses": [ + 17382, + 17383, + 17423, + 18174, + 18175 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6588, + "pre" + ], + [ + 22669, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17234, + "alloc" + ], + [ + 22532, + "free" + ] + ], + "climbs": [ + { + "index": 13415, + "new": [ + 328, + 200, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13417, + "new": [ + 264, + 136, + 64, + 38, + 21 + ], + "old": [ + 328, + 200, + 51 + ], + "rank": 2 + }, + { + "index": 14609, + "new": [ + 256, + 128, + 64, + 38, + 21, + 8 + ], + "old": [ + 264, + 136, + 64, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15939, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 256, + 128, + 64, + 38, + 21, + 8 + ], + "rank": 1 + } + ], + "compact_helper": 550, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12062, + 13416, + 13419, + 14610, + 15940, + 16013, + 16015, + 17382, + 17383, + 17423, + 18174, + 18175 + ], + "direct_scalar_sha256": "2a0c273d7f1caa8133a50dc3e35f1426debf4032789f31edfc3f3f9d655abcad", + "entrance": [ + 51 + ], + "private_uses": [ + 17382, + 17383, + 17423, + 18174, + 18175 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6588, + "pre" + ], + [ + 22669, + "post" + ] + ] + } + }, + "557": { + "backward": { + "buffers": [ + [ + 17235, + "alloc" + ], + [ + 22533, + "free" + ] + ], + "climbs": [ + { + "index": 13420, + "new": [ + 259, + 131, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13422, + "new": [ + 259, + 131, + 85, + 51, + 11 + ], + "old": [ + 259, + 131, + 51 + ], + "rank": 2 + }, + { + "index": 14615, + "new": [ + 259, + 131, + 67, + 37, + 22, + 11 + ], + "old": [ + 259, + 131, + 85, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15944, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 259, + 131, + 67, + 37, + 22, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 551, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12063, + 13421, + 13424, + 14616, + 15945, + 16017, + 16018, + 17380, + 17381, + 17421, + 18172, + 18173 + ], + "direct_scalar_sha256": "b747d0e3606f3a577740a6f0d13642a74391fdaaf79ad2921613bd8e29903801", + "entrance": [ + 51 + ], + "private_uses": [ + 17380, + 17381, + 17421, + 18172, + 18173 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6589, + "pre" + ], + [ + 22670, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17235, + "alloc" + ], + [ + 22533, + "free" + ] + ], + "climbs": [ + { + "index": 13420, + "new": [ + 259, + 131, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13422, + "new": [ + 259, + 131, + 85, + 51, + 11 + ], + "old": [ + 259, + 131, + 51 + ], + "rank": 2 + }, + { + "index": 14615, + "new": [ + 259, + 131, + 67, + 37, + 22, + 11 + ], + "old": [ + 259, + 131, + 85, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15944, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 259, + 131, + 67, + 37, + 22, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 551, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12063, + 13421, + 13424, + 14616, + 15945, + 16017, + 16018, + 17380, + 17381, + 17421, + 18172, + 18173 + ], + "direct_scalar_sha256": "b747d0e3606f3a577740a6f0d13642a74391fdaaf79ad2921613bd8e29903801", + "entrance": [ + 51 + ], + "private_uses": [ + 17380, + 17381, + 17421, + 18172, + 18173 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6589, + "pre" + ], + [ + 22670, + "post" + ] + ] + } + } + }, + "climb_recipes": { + "[[256,128,64,38,21,8],[256,128,64,37,21,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 38, + 3, + 32, + 36, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 2, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[256,128,85,48,8,3],[256,128,64,37,21,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 16, + 33, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 80, + 17, + 2, + 20, + 8, + 64, + 96, + 128, + 256 + ], + "offset": 43, + "phase": 0, + "quadratic_rows": [ + 16, + 0, + 16, + 0, + 5, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[259,131,51],[259,131,85,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 3, + 33, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 86, + 75, + 73, + 10, + 68, + 80, + 32, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 21, + 22, + 0, + 22, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[259,131,67,37,22,11],[256,128,64,37,21,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 33, + 64, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 262, + 3, + 256, + 260, + 264, + 272, + 32, + 320, + 384 + ], + "offset": 43, + "phase": 0, + "quadratic_rows": [ + 2, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[259,131,85,51,11],[256,128,85,48,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 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, + 2, + 0, + 0, + 1, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 273, + 259, + 256, + 4, + 264, + 272, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 19, + 1, + 0, + 0, + 17, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[259,131,85,51,11],[259,131,67,37,22,11]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 16, + 33, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 80, + 1, + 18, + 20, + 8, + 64, + 96, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 16, + 16, + 0, + 6, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[264,136,64,37,21,3],[256,128,64,37,21,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 17, + 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": [ + 264, + 1, + 2, + 4, + 256, + 16, + 32, + 64, + 384 + ], + "offset": 17, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[264,136,64,38,21],[256,128,64,38,21,8]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 17, + 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": [ + 264, + 1, + 2, + 4, + 256, + 16, + 32, + 64, + 384 + ], + "offset": 17, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[264,136,64,38,21],[264,136,64,37,21,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 38, + 3, + 32, + 36, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 2, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[328,200,51],[264,136,64,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 32, + 65, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 3, + 320, + 49, + 34, + 20, + 8, + 32, + 256, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 51, + 35, + 16, + 0, + 21, + 3, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[448,38,21],[264,136,64,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 16, + 34, + 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, + 0, + 3, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 456, + 1, + 2, + 4, + 392, + 16, + 32, + 256 + ], + "offset": 258, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 72, + 0, + 0, + 136, + 320, + 384 + ] + } + }, + "spectator_axes": 7 + }, + "[[469,51,11],[259,131,85,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 32, + 65, + 128, + 257, + 3, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 0, + 3, + 0, + 3, + 2, + 2 + ], + "matrix_rows": [ + 86, + 384, + 193, + 386, + 324, + 8, + 336, + 32, + 256 + ], + "offset": 340, + "phase": 2, + "quadratic_rows": [ + 192, + 470, + 278, + 0, + 278, + 0, + 451, + 67, + 86 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[259,131,51]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 32, + 64, + 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, + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 131, + 385, + 386, + 4, + 8, + 16, + 32, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 259, + 259, + 0, + 0, + 0, + 0, + 0, + 384, + 131 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[328,200,51]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 16, + 34, + 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, + 0, + 3, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 200, + 1, + 2, + 4, + 392, + 16, + 32, + 448 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 328, + 0, + 0, + 328, + 384, + 200 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[448,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 32, + 65, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 3, + 448, + 49, + 34, + 20, + 8, + 32, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 51, + 35, + 16, + 0, + 21, + 3, + 192, + 192, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[469,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 3, + 33, + 64, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 3, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 470, + 267, + 265, + 10, + 260, + 272, + 32, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 213, + 214, + 0, + 214, + 0, + 214, + 214, + 0 + ] + } + }, + "spectator_axes": 7 + } + }, + "controls": { + "omitted_entrance": "entrance-relative width", + "parent_wrapper_alias": "phase-exact all-column residual", + "phase": "phase-exact all-column residual", + "wrong_entrance_line": "phase-exact all-column residual", + "wrong_terminal_span": "phase-exact all-column residual" + }, + "local_checks_sha256": "f2a8160669dba42701bf43a9cd18ba47e4a2ac16a5eb6dac2b77e41eaec5cbdc", + "parent_residual_comparison": { + "454": { + "entrance": [ + 51 + ], + "joint_recipe_key": "114:263", + "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 + ] + }, + "455": { + "entrance": [ + 51 + ], + "joint_recipe_key": "114:263", + "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": { + "114:263": { + "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": [ + 64, + 131, + 259, + 4, + 1, + 2, + 8, + 16, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 6, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 6, + 54, + 8, + 64, + 128, + 256, + 19, + 32, + 52 + ], + "offset": 252, + "phase": 2, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ] + }, + "terminal": 263, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "vectors": [ + 51 + ] + }, + "spectator_axes": 3 + } + } + }, + "extra": { + "adapter_sha256": "cc366668c225431a1e5d0f856dbe7ba079c8e2fa1dc3ad0ceeecb9f0796aff77", + "bindings": { + "454": { + "backward": { + "buffers": [ + [ + 17214, + "alloc" + ], + [ + 22512, + "free" + ] + ], + "climbs": [ + { + "index": 12951, + "new": [ + 448, + 38, + 21 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13418, + "new": [ + 264, + 136, + 64, + 38, + 21 + ], + "old": [ + 448, + 38, + 21 + ], + "rank": 2 + }, + { + "index": 14612, + "new": [ + 264, + 136, + 64, + 37, + 21, + 3 + ], + "old": [ + 264, + 136, + 64, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15936, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 264, + 136, + 64, + 37, + 21, + 3 + ], + "rank": 1 + } + ], + "compact_helper": 454, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12033, + 12035, + 12952, + 13419, + 14613, + 15938, + 15940, + 17423, + 17424, + 18174, + 18385 + ], + "direct_scalar_sha256": "9ba3458f09ad70a2cb950ae67d694a0c01f655859d374e21a31b9758e61beaf0", + "entrance": [ + 51 + ], + "private_uses": [ + 17423, + 17424, + 18174, + 18385 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6492, + "pre" + ], + [ + 22603, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17214, + "alloc" + ], + [ + 22512, + "free" + ] + ], + "climbs": [ + { + "index": 12951, + "new": [ + 448, + 38, + 21 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13418, + "new": [ + 264, + 136, + 64, + 38, + 21 + ], + "old": [ + 448, + 38, + 21 + ], + "rank": 2 + }, + { + "index": 14612, + "new": [ + 264, + 136, + 64, + 37, + 21, + 3 + ], + "old": [ + 264, + 136, + 64, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15936, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 264, + 136, + 64, + 37, + 21, + 3 + ], + "rank": 1 + } + ], + "compact_helper": 454, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12033, + 12035, + 12952, + 13419, + 14613, + 15938, + 15940, + 17423, + 17424, + 18174, + 18385 + ], + "direct_scalar_sha256": "9ba3458f09ad70a2cb950ae67d694a0c01f655859d374e21a31b9758e61beaf0", + "entrance": [ + 51 + ], + "private_uses": [ + 17423, + 17424, + 18174, + 18385 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6492, + "pre" + ], + [ + 22603, + "post" + ] + ] + } + }, + "455": { + "backward": { + "buffers": [ + [ + 17215, + "alloc" + ], + [ + 22513, + "free" + ] + ], + "climbs": [ + { + "index": 12953, + "new": [ + 469, + 51, + 11 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13423, + "new": [ + 259, + 131, + 85, + 51, + 11 + ], + "old": [ + 469, + 51, + 11 + ], + "rank": 2 + }, + { + "index": 14618, + "new": [ + 256, + 128, + 85, + 48, + 8, + 3 + ], + "old": [ + 259, + 131, + 85, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15941, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 256, + 128, + 85, + 48, + 8, + 3 + ], + "rank": 1 + } + ], + "compact_helper": 455, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12037, + 12039, + 12954, + 13424, + 14619, + 15943, + 15945, + 17421, + 17422, + 18172, + 18384 + ], + "direct_scalar_sha256": "c2b9d5e06b0c0b804bb49be48cf11db43c9c55f437cfcceea0a79c6591390173", + "entrance": [ + 51 + ], + "private_uses": [ + 17421, + 17422, + 18172, + 18384 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6493, + "pre" + ], + [ + 22604, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17215, + "alloc" + ], + [ + 22513, + "free" + ] + ], + "climbs": [ + { + "index": 12953, + "new": [ + 469, + 51, + 11 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13423, + "new": [ + 259, + 131, + 85, + 51, + 11 + ], + "old": [ + 469, + 51, + 11 + ], + "rank": 2 + }, + { + "index": 14618, + "new": [ + 256, + 128, + 85, + 48, + 8, + 3 + ], + "old": [ + 259, + 131, + 85, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15941, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 256, + 128, + 85, + 48, + 8, + 3 + ], + "rank": 1 + } + ], + "compact_helper": 455, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12037, + 12039, + 12954, + 13424, + 14619, + 15943, + 15945, + 17421, + 17422, + 18172, + 18384 + ], + "direct_scalar_sha256": "c2b9d5e06b0c0b804bb49be48cf11db43c9c55f437cfcceea0a79c6591390173", + "entrance": [ + 51 + ], + "private_uses": [ + 17421, + 17422, + 18172, + 18384 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6493, + "pre" + ], + [ + 22604, + "post" + ] + ] + } + }, + "556": { + "backward": { + "buffers": [ + [ + 17234, + "alloc" + ], + [ + 22532, + "free" + ] + ], + "climbs": [ + { + "index": 13415, + "new": [ + 328, + 200, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13417, + "new": [ + 264, + 136, + 64, + 38, + 21 + ], + "old": [ + 328, + 200, + 51 + ], + "rank": 2 + }, + { + "index": 14609, + "new": [ + 256, + 128, + 64, + 38, + 21, + 8 + ], + "old": [ + 264, + 136, + 64, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15939, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 256, + 128, + 64, + 38, + 21, + 8 + ], + "rank": 1 + } + ], + "compact_helper": 550, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12062, + 13416, + 13419, + 14610, + 15940, + 16013, + 16015, + 17382, + 17383, + 17423, + 18174, + 18175 + ], + "direct_scalar_sha256": "2a0c273d7f1caa8133a50dc3e35f1426debf4032789f31edfc3f3f9d655abcad", + "entrance": [ + 51 + ], + "private_uses": [ + 17382, + 17383, + 17423, + 18174, + 18175 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6588, + "pre" + ], + [ + 22669, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17234, + "alloc" + ], + [ + 22532, + "free" + ] + ], + "climbs": [ + { + "index": 13415, + "new": [ + 328, + 200, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13417, + "new": [ + 264, + 136, + 64, + 38, + 21 + ], + "old": [ + 328, + 200, + 51 + ], + "rank": 2 + }, + { + "index": 14609, + "new": [ + 256, + 128, + 64, + 38, + 21, + 8 + ], + "old": [ + 264, + 136, + 64, + 38, + 21 + ], + "rank": 1 + }, + { + "index": 15939, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 256, + 128, + 64, + 38, + 21, + 8 + ], + "rank": 1 + } + ], + "compact_helper": 550, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12062, + 13416, + 13419, + 14610, + 15940, + 16013, + 16015, + 17382, + 17383, + 17423, + 18174, + 18175 + ], + "direct_scalar_sha256": "2a0c273d7f1caa8133a50dc3e35f1426debf4032789f31edfc3f3f9d655abcad", + "entrance": [ + 51 + ], + "private_uses": [ + 17382, + 17383, + 17423, + 18174, + 18175 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6588, + "pre" + ], + [ + 22669, + "post" + ] + ] + } + }, + "557": { + "backward": { + "buffers": [ + [ + 17235, + "alloc" + ], + [ + 22533, + "free" + ] + ], + "climbs": [ + { + "index": 13420, + "new": [ + 259, + 131, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13422, + "new": [ + 259, + 131, + 85, + 51, + 11 + ], + "old": [ + 259, + 131, + 51 + ], + "rank": 2 + }, + { + "index": 14615, + "new": [ + 259, + 131, + 67, + 37, + 22, + 11 + ], + "old": [ + 259, + 131, + 85, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15944, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 259, + 131, + 67, + 37, + 22, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 551, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12063, + 13421, + 13424, + 14616, + 15945, + 16017, + 16018, + 17380, + 17381, + 17421, + 18172, + 18173 + ], + "direct_scalar_sha256": "b747d0e3606f3a577740a6f0d13642a74391fdaaf79ad2921613bd8e29903801", + "entrance": [ + 51 + ], + "private_uses": [ + 17380, + 17381, + 17421, + 18172, + 18173 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6589, + "pre" + ], + [ + 22670, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17235, + "alloc" + ], + [ + 22533, + "free" + ] + ], + "climbs": [ + { + "index": 13420, + "new": [ + 259, + 131, + 51 + ], + "old": [ + 51 + ], + "rank": 2 + }, + { + "index": 13422, + "new": [ + 259, + 131, + 85, + 51, + 11 + ], + "old": [ + 259, + 131, + 51 + ], + "rank": 2 + }, + { + "index": 14615, + "new": [ + 259, + 131, + 67, + 37, + 22, + 11 + ], + "old": [ + 259, + 131, + 85, + 51, + 11 + ], + "rank": 1 + }, + { + "index": 15944, + "new": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "old": [ + 259, + 131, + 67, + 37, + 22, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 551, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12063, + 13421, + 13424, + 14616, + 15945, + 16017, + 16018, + 17380, + 17381, + 17421, + 18172, + 18173 + ], + "direct_scalar_sha256": "b747d0e3606f3a577740a6f0d13642a74391fdaaf79ad2921613bd8e29903801", + "entrance": [ + 51 + ], + "private_uses": [ + 17380, + 17381, + 17421, + 18172, + 18173 + ], + "recipe_key": "114:263", + "terminal": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "wrappers": [ + [ + 6589, + "pre" + ], + [ + 22670, + "post" + ] + ] + } + } + }, + "climb_recipes": { + "[[256,128,64,38,21,8],[256,128,64,37,21,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 38, + 3, + 32, + 36, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 2, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[256,128,85,48,8,3],[256,128,64,37,21,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 16, + 33, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 80, + 17, + 2, + 20, + 8, + 64, + 96, + 128, + 256 + ], + "offset": 43, + "phase": 0, + "quadratic_rows": [ + 16, + 0, + 16, + 0, + 5, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[259,131,51],[259,131,85,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 3, + 33, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 86, + 75, + 73, + 10, + 68, + 80, + 32, + 128, + 256 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 21, + 22, + 0, + 22, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[259,131,67,37,22,11],[256,128,64,37,21,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 33, + 64, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 262, + 3, + 256, + 260, + 264, + 272, + 32, + 320, + 384 + ], + "offset": 43, + "phase": 0, + "quadratic_rows": [ + 2, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[259,131,85,51,11],[256,128,85,48,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 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, + 2, + 0, + 0, + 1, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 273, + 259, + 256, + 4, + 264, + 272, + 288, + 64, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 19, + 1, + 0, + 0, + 17, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[259,131,85,51,11],[259,131,67,37,22,11]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 16, + 33, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 80, + 1, + 18, + 20, + 8, + 64, + 96, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 16, + 16, + 0, + 6, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[264,136,64,37,21,3],[256,128,64,37,21,8,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 17, + 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": [ + 264, + 1, + 2, + 4, + 256, + 16, + 32, + 64, + 384 + ], + "offset": 17, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[264,136,64,38,21],[256,128,64,38,21,8]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 17, + 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": [ + 264, + 1, + 2, + 4, + 256, + 16, + 32, + 64, + 384 + ], + "offset": 17, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[264,136,64,38,21],[264,136,64,37,21,3]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 3, + 1, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 38, + 3, + 32, + 36, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 6, + "phase": 2, + "quadratic_rows": [ + 2, + 7, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[328,200,51],[264,136,64,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 32, + 65, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 3, + 320, + 49, + 34, + 20, + 8, + 32, + 256, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 51, + 35, + 16, + 0, + 21, + 3, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[448,38,21],[264,136,64,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 16, + 34, + 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, + 0, + 3, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 456, + 1, + 2, + 4, + 392, + 16, + 32, + 256 + ], + "offset": 258, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 72, + 0, + 0, + 136, + 320, + 384 + ] + } + }, + "spectator_axes": 7 + }, + "[[469,51,11],[259,131,85,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 32, + 65, + 128, + 257, + 3, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 0, + 3, + 0, + 3, + 2, + 2 + ], + "matrix_rows": [ + 86, + 384, + 193, + 386, + 324, + 8, + 336, + 32, + 256 + ], + "offset": 340, + "phase": 2, + "quadratic_rows": [ + 192, + 470, + 278, + 0, + 278, + 0, + 451, + 67, + 86 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[259,131,51]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 32, + 64, + 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, + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 131, + 385, + 386, + 4, + 8, + 16, + 32, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 259, + 259, + 0, + 0, + 0, + 0, + 0, + 384, + 131 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[328,200,51]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 16, + 34, + 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, + 0, + 3, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 200, + 1, + 2, + 4, + 392, + 16, + 32, + 448 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 328, + 0, + 0, + 328, + 384, + 200 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[448,38,21]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 5, + 9, + 16, + 32, + 65, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 3, + 448, + 49, + 34, + 20, + 8, + 32, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 51, + 35, + 16, + 0, + 21, + 3, + 192, + 192, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[51],[469,51,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 17, + 3, + 33, + 64, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 2, + 3, + 2, + 3, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 470, + 267, + 265, + 10, + 260, + 272, + 32, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 3, + 213, + 214, + 0, + 214, + 0, + 214, + 214, + 0 + ] + } + }, + "spectator_axes": 7 + } + }, + "controls": { + "omitted_entrance": "entrance-relative width", + "parent_wrapper_alias": "phase-exact all-column residual", + "phase": "phase-exact all-column residual", + "wrong_entrance_line": "phase-exact all-column residual", + "wrong_terminal_span": "phase-exact all-column residual" + }, + "local_checks_sha256": "f2a8160669dba42701bf43a9cd18ba47e4a2ac16a5eb6dac2b77e41eaec5cbdc", + "parent_residual_comparison": { + "454": { + "entrance": [ + 51 + ], + "joint_recipe_key": "114:263", + "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 + ] + }, + "455": { + "entrance": [ + 51 + ], + "joint_recipe_key": "114:263", + "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": { + "114:263": { + "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": [ + 64, + 131, + 259, + 4, + 1, + 2, + 8, + 16, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 6, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 6, + 54, + 8, + 64, + 128, + 256, + 19, + 32, + 52 + ], + "offset": 252, + "phase": 2, + "quadratic_rows": [ + 18, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ] + }, + "terminal": 263, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "vectors": [ + 51 + ] + }, + "spectator_axes": 3 + } + } + } + }, + "native_to_owner_join": { + "base": { + "454": { + "helper_index": 230, + "native_pair": "114:263", + "width": 6 + }, + "455": { + "helper_index": 231, + "native_pair": "114:263", + "width": 6 + }, + "556": { + "helper_index": 326, + "native_pair": "114:263", + "width": 6 + }, + "557": { + "helper_index": 327, + "native_pair": "114:263", + "width": 6 + } + }, + "extra": { + "454": { + "helper_index": 230, + "native_pair": "114:263", + "width": 6 + }, + "455": { + "helper_index": 231, + "native_pair": "114:263", + "width": 6 + }, + "556": { + "helper_index": 326, + "native_pair": "114:263", + "width": 6 + }, + "557": { + "helper_index": 327, + "native_pair": "114:263", + "width": 6 + } + } + }, + "schema_version": 1, + "status": "PASS_GROUP_D_NATIVE_WIDTHS" +} diff --git a/research/rank7-group-d-native-widths-audit/SOURCES.json b/research/rank7-group-d-native-widths-audit/SOURCES.json new file mode 100644 index 0000000000..1548f12ccf --- /dev/null +++ b/research/rank7-group-d-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-d-native-widths-audit/TASK.json b/research/rank7-group-d-native-widths-audit/TASK.json new file mode 100644 index 0000000000..8032c1ae43 --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/TASK.json @@ -0,0 +1,124 @@ +{ + "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 D only: exact emitted wrapper pairs, native residual ranks/widths and climbs for helpers 454/455/556/557 under shared W=<256,128,64,37,21,8,3> (all entering at [51]), adapter pins against FULL-NATIVE-RECEIPT, and native-width-to-T74-fill join. Explicitly excludes STAGE-PRICES guide margins and single-helper control reprints.", + "scope_change_reason": "Group A (entrance audit), leave-alone #3411 group B, and in-flight group C tip ad6350cbb already bind their native residuals. Group D helpers {454,455,556,557} remain unbound at the native/wrapper boundary; STAGE-PRICES margins +17170 are already registered in #2979 and must not be headlined.", + "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 D 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 6/6/6/6; shared residual pair 114:263; entrance [51] for all four helpers; adapter and LOCAL-CHECKS pins; T74 placements 2664; semantic controls reject omitted entrance, wrong entrance line, wrong terminal span, parent-wrapper alias, and phase corruption.", + "author": "Wentao Li", + "ai_assistance": "Substantial AI assistance for derivation, implementation, checking and writing.", + "open_questions": [ + { + "question": "Can the checked group-D 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 454/455/556/557 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." + }, + { + "pr": 3411, + "package": "research/rank7-group-b-native-widths-audit", + "head": "24a291a502fc93e1bf7bdbb2d7b351ce75f0bee8", + "scope": "Leave-alone group-B native residual binding; helpers 299/448/449/484/485 and W_B are outside this package." + }, + { + "package": "research/rank7-group-c-native-widths-audit", + "tip": "ad6350cbb", + "scope": "In-flight group-C native residual binding; helpers 452/453/532/533 and W_C are outside this package; its OQ3 asked for this group-D audit." + }, + { + "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-d-native-widths", + "method": "Handoff after #3411 group-B and in-flight group-C native: bind emitted native residuals/wrappers for helpers 454/455/556/557; 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-D 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-18T01:40:00Z", + "canonical_main": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "priority_revision": 6, + "selected_kappa": "0.001672660197076918", + "changes": "Pin CrocSwap tip 6f100d4; leave alone #3421/#3411/#3392/#3386/#3374/#3349; deferred f795116d/1910fd12/rho; in-flight group C ad6350cbb." + } +} diff --git a/research/rank7-group-d-native-widths-audit/VERIFY.json b/research/rank7-group-d-native-widths-audit/VERIFY.json new file mode 100644 index 0000000000..9452df28fd --- /dev/null +++ b/research/rank7-group-d-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-D native entering 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/terminal, wrapper/lifetime, scalar chronology/cleanup, owner geometry, actual-width mismatch, and source/event-receipt corruption/duplicate JSON." + } + ] +} diff --git a/research/rank7-group-d-native-widths-audit/common.py b/research/rank7-group-d-native-widths-audit/common.py new file mode 100644 index 0000000000..90bdf8880b --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/common.py @@ -0,0 +1,90 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Bounded source loading for the group-D 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 = (454, 455, 556, 557) +W = [256, 128, 64, 37, 21, 8, 3] +ENTRANCE = [51] +WRONG_ENTRANCE = [3] +# Same dimension as W, different #2979 group subspace (group C). +WRONG_TERMINAL = [256, 128, 64, 32, 19, 11, 6] +LIMIT = 64 * 1024 * 1024 + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +# Alias kept for -O admission wording in handoffs (not assert-based). +need = require + + +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-d-native-widths-audit/invoice.py b/research/rank7-group-d-native-widths-audit/invoice.py new file mode 100644 index 0000000000..6b5379a850 --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/invoice.py @@ -0,0 +1,157 @@ +# 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 D. +""" + +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 * len(HELPERS), + "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"] == {"454": 6, "455": 6, "556": 6, "557": 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-d-native-widths-audit/native.py b/research/rank7-group-d-native-widths-audit/native.py new file mode 100644 index 0000000000..8b98cbd4fe --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/native.py @@ -0,0 +1,288 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Bind emitted group-D entering 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, +research/rank7-group-b-native-widths-audit/native.py and +research/rank7-group-c-native-widths-audit/native.py to helpers +454/455/556/557 and shared W = <256,128,64,37,21,8,3> (all entering at [51]). +""" + +import copy +import os +import subprocess +import sys +from common import COMPILER, ENGINE, ENTRANCE, HELPERS, KERNEL, W, WRONG_ENTRANCE +from common import WRONG_TERMINAL, 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_d_source_compiler") + kernel = module(blobs[KERNEL], "group_d_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["454"]["forward"]["recipe_key"] + rec = adapters["recipes"][entering] + parent = data(blobs, f"data/PARENT-{tag}.json.gz") + comparison = {} + parent_candidates = {} + for h in (454, 455): + 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) + candidate = decode(encoded(candidate)) + parent_candidates[str(h)] = candidate + comparison[str(h)] = {"entrance": entrance, "parent_terminal": terminal, + "parent": check_recipe(kernel, candidate, entrance, terminal), + "joint_recipe_key": entering} + require(all(parent["start_extra"][str(h)] == ENTRANCE and + parent["helper_final"][str(h)] == comparison["454"]["parent_terminal"] + for h in HELPERS), "four common entering parent pairs") + require(all(bindings[str(h)]["forward"]["entrance"] == ENTRANCE for h in HELPERS), + "group-D entrance inventory") + 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") + # Parent residual has width 7; its right wrapper is not interchangeable with the joint width-6 recipe. + bad = copy.deepcopy(rec); bad["right"] = parent_candidates["454"]["right"] + controls["parent_wrapper_alias"] = reject(lambda: check_recipe(kernel, bad, ENTRANCE, W), "parent 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") + # Same residual width against a different #2979 group terminal span. + controls["wrong_terminal_span"] = reject( + lambda: check_recipe(kernel, rec, ENTRANCE, WRONG_TERMINAL), "wrong terminal") + 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-d-native-widths-audit/test_verify.py b/research/rank7-group-d-native-widths-audit/test_verify.py new file mode 100644 index 0000000000..fdb7c6bacb --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/test_verify.py @@ -0,0 +1,158 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Semantic failures at the actual group-D 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, WRONG_TERMINAL +from common import 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_d_test_kernel") + cls.tmp = tempfile.TemporaryDirectory(prefix="group-d-tests-") + cls.canonical, cls.programs, _ = native.generate(cls.blobs, "base", Path(cls.tmp.name)) + cls.entering_key = cls.result["native_to_owner_join"]["base"]["454"]["native_pair"] + cls.parent_recipe = cls.result["native"]["base"]["parent_residual_comparison"]["454"]["parent"]["recipe"] + + @classmethod + def tearDownClass(cls): + cls.tmp.cleanup() + + def bind(self, stream, h=454, 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) + with self.assertRaisesRegex(ValueError, "phase-exact"): + native.check_recipe(self.kernel, rec, ENTRANCE, WRONG_TERMINAL) + wrong = copy.deepcopy(rec) + wrong["right"] = self.parent_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"]["454"]["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"]["454"]["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"]["454"] + # Treating an entering helper as cold selects width 7 and breaks the 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-d-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-d-native-widths-audit/verify.py b/research/rank7-group-d-native-widths-audit/verify.py new file mode 100644 index 0000000000..e8cf6a8c61 --- /dev/null +++ b/research/rank7-group-d-native-widths-audit/verify.py @@ -0,0 +1,71 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Group D 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 ENTRANCE, 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-d-native-") as work: + native_results[tag] = native.audit(blobs, tag, Path(work)) + result = {"schema_version": 1, "status": "PASS_GROUP_D_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 == [6, 6, 6, 6], "emitted residual widths 6/6/6/6") + require(result["invoice"]["group_placements"] == 2664, "T74 fill places group D 2664 times") + for tag, record in native_results.items(): + require(set(record["residuals"]) >= {joins[tag]["454"]["native_pair"]}, + "entering residual class") + require(all(record["bindings"][str(h)]["forward"]["entrance"] == ENTRANCE + for h in HELPERS), "entering helpers at span(51)") + require(all(joins[tag][str(h)]["native_pair"] == joins[tag]["454"]["native_pair"] + for h in HELPERS), "shared group-D residual pair") + 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=4 residual_widths=6,6,6,6 pairs={pairs}" + + " placements=2664 adapter_pinned both_orientations no_new_kappa") + + +if __name__ == "__main__": + main()