diff --git a/research/rank7-group-a-entrance-audit/README.md b/research/rank7-group-a-entrance-audit/README.md new file mode 100644 index 0000000000..6a740d5a01 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/README.md @@ -0,0 +1,240 @@ +# Group A's native widths through the shipped T74 invoice + +**Finite native/interface audit; no new kappa or supplier admission.** + +Both literal PR2979 providers pass the mixed-entrance check for group A. +Helpers 450, 451, 508 and 509 enter at `[30]` and end at +`W = [256,128,64,38,20,10,1]`. Their emitted residual pair is `115:261`, +with width **six**, not the terminal dimension seven. Helper 331 enters at +zero and uses pair `0:261`, with width seven. Exact native identities include +global phase and both orientations. These widths bind to all 3,330 group-A +placements in the shipped T74 allocation. + +The contribution joins the complete direct group-A boundary to its actual +owner placements. It corroborates existing native identities and does not +newly discover the construction, local saving or published complete histogram. +The local comparison and normalized endpoint checks explicitly reuse credited +independent checkers. The claim is in discussion [#2612][thread]. + +### Existing coverage and the added check + +[PR3038][3038] already checks both residual classes within its V45 dependency +cone: `0:261` in both orientations and `115:261` in the inverse-transpose +orientation. The latter also implies its forward identity by conjugation. +The original claim's inventory of PR3006/3008 was incomplete; final overlap +review identified and credited this stronger predecessor before submission. +These residual equalities are corroboration, not newly missing mathematics. + +PR3038's roots are helper249/private953. Its pinned receipts contain none of +the five group-A post-wrapper events. For helpers 331/450/451/508/509, this +audit checks 122/19/19/20/20 direct events per orientation. Respectively, +22/19/19/20/20 forward events and 61/3/3/5/7 inverse-transpose events are outside +the earlier cone; the two providers agree. These are per-helper counts and +may share events, not counts of distinct newly proved native identities. +[RESULT.json](RESULT.json) records the exact indices and source-bound coverage +comparison. The PR3038 receipts were inspected, not freshly replayed here. + +The added coverage is the complete direct path through each actual post +wrapper, all ten group helper/private normalized endpoints, and the explicit +native-width/ordered-helper/physical-slot join for every group placement. +The complete peer-native closure still remains separate. Concurrent #2612 +private-free and final-fill control audits should be consulted before taking +those follow-ups; this package does not reconstruct their work. + +## Exact native statement and source binding + +The source is [PR2979][2979] at +`be191346391661f4d35fc0d1508d0a6029572576`; the base is canonical main +`463113d675af7410ac91d53a4fed51ec6494eb9a`, priority revision 6. +[SOURCES.json](SOURCES.json) records exact Git blobs and SHA256 hashes. +The 14 construction inputs also match the original PR2979 head byte for byte. +The native producer, exact kernel and retained checkers 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). +``` + +For these unitary operators, inverse transpose is entrywise conjugation. +The same chronological wrapper arrangement gives `F_w^-T`, with the +remaining `9-w` axes unchanged. The check does not substitute the adjoint +or reverse the execution order. + +| Helper(s) | Entrance | Parent terminal dimension | Parent width | Joint/final width | +|---|---|---:|---:|---:| +| 331 | zero | 8 | 8 | 7 | +| 450, 451, 508, 509 | span(30) | 8 | 7 | 6 | + +Here 30 = 20 xor 10 lies in W. Treating the entering helpers as cold would +select the wrong native operator even if a rank field were edited to six. +The cold right wrapper and the entering right wrapper are not interchangeable: +the all-column check rejects that substitution. A different contained line, +`[10]`, has the same dimension but also fails with the actual `[30]` recipe. + +This width is exact within the monomial/Fourier/monomial format: every column +of `F_w` has exactly `2^w` nonzero entries, and invertible monomial factors +preserve that count. Thus a checked width-six residual cannot be represented +by such a format with fewer than six Fourier axes. This is not a lower bound +for arbitrary native circuits or a claim that the 512-by-512 operator has +matrix rank six; it is unitary and has full matrix rank. + +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. +Generation is not presented as an independent checker. The independent part +compares each selected original entrance/terminal pair, direct scalar clock, +climb and cleanup lifetime against the emitted records, then decodes the +selected native recipes through the separate exact kernel. + +Each provider has 22 distinct group-A climb pairs, two shipped residual pairs +and two parent residual pairs checked exactly. The emitted climb ranks are +`1,1,1,1,1,2` for 331 and `2,2,1,1` for each entering helper. The parent +residuals are generated comparison identities; no complete parent native +program is regenerated. The final pair keys and adapter hashes are bound to +the shipped program, rather than to an interchangeable candidate recipe. + +There are 112/11/11/12/12 direct scalar operations for helpers +331/450/451/508/509 and their private buffers, respectively. Scalar clocks +include intervening operations on other roles. Moving a direct operation +across a disjoint scalar therefore fails the check even when its order among +the helper's own operations is preserved. Private operations occur after +allocation and before free; the inverse left wrapper follows cleanup. + +## The group, its control and the invoice + +The retained [PR2993][2993] checker reconstructs group A on each parent word +and a control with the same 21 partner-frame edits but only helper331 lowered. +No scalar or cleanup operation changes. Their exact local differences are: + +```text +joint: -H1 + 20 H2 - 14 H3 + 2 H4 - 2 H5 +single331: 3H1 + 20 H2 - 14 H3 + 2 H4 - 2 H5 +``` + +`Hr` means one paid rank-r child. Substitution into the source's integer +surrogate and its 2,091,300-unit width guide reproduces joint margin +`+42,541` and single margin `-58,943`. The four additional endpoints save +exactly four H1 children locally. This control keeps the group's partner +frames fixed; it does not optimize every possible single-helper frame path. +The guide is not an independently certified physical idle tariff. + +The new time-major recount reads every one of the final allocation's +271,728 placements, checks role completeness, source windows, per-call +physical-family uniqueness, capacities and compact prefixes, and bills all +149,184 bins including empty bins. Original helper names map to ordered +helper indices `107,226,227,279,280`; those are explicitly joined to the +emitted native residual widths. Replacing helper450's width six with terminal +dimension seven fails the actual allocation check. + +| Item | Exact count/profile | +|---|---| +| Calls | 250 base + 416 extra = 666 | +| Local profile per call | `{1:2445,2:706,3:232,4:108,5:18,8:8}` | +| Width inventory | `{4:26,5:2,6:16,7:52,8:99,9:213}`, mass 3,283 | +| Actual idle bill | `17310 H1 + 4956 H3 + 1728 H5 + 28190 H48` | +| Complete recursive bill | `{1:1645680,2:470196,3:159468,4:71928,5:13716,8:5328,48:28190}` | +| Complete rank mass | `4,816,512 = 65,088 * 74` | +| Nominal physical stock | `66,304 + 408 + 8 + 91 + 2 = 66,813` | + +The complete recursive moment input is therefore +`sum(n_r * (r/73)^(1-a)) / (896*74)`. All 91 private names remain charged. +The five group-A private buffers already exist in the parent; stage one +retains 86, and five later extractions produce the final count 91. +The independently recounted final bill agrees with the source. It includes +the other four groups, later extractions and rewrites, so it is not an +isolated group-A gain attribution or a legal whole-supplier single-control +comparison. Those counterfactual allocations are not supplied here. + +The retained [PR3006][3006] reverse-covector engine also checks 40 output +rows: five helpers and five private buffers, two providers, two orientations. +Each is exactly its own input over the full free operator algebra, with +632 original and 91 private inputs. Thus each covered private output is zero +when its private entrance is zero. This extends that engine's checked domain; +it is not a newly independent implementation of the endpoint algorithm. +Deleting actual cleanup gate178, `private1154 += private934`, breaks this +identity and is rejected by the behavioral control. + +## Evidence and reproduction + +Python 3.12, standard library only, from the repository root: + +```sh +python3 -B scripts/research_package.py --package research/rank7-group-a-entrance-audit --check-only +python3 -B scripts/research_package.py --package research/rank7-group-a-entrance-audit +``` + +Expected verifier output begins `PASS_GROUP_A_ENTRANCE_NATIVE_INVOICE`. +The hook also runs seven behavioral test groups. They cover wrong entrance +and phase, a cold-wrapper alias, omitted/wrong wrappers, premature private +free, changed scalar signs and clocks, omitted cleanup, missing/duplicate +roles, bad capacity, terminal-dimension misuse, source corruption and duplicate +JSON keys. Direct `verify.py --emit` prints deterministic evidence without +rewriting [RESULT.json](RESULT.json). Input hashes are checked again after +the replay. The normal replay writes only temporary work outside the package. + +Source production uses fresh temporary script copies and bounded foreground +subprocesses; inherited `PYTHONOPTIMIZE` is removed from those subprocesses. +Authenticated imported checkers are compiled from source bytes rather than +loaded from a preexisting bytecode cache. The finite domain is two 704-name +source words, 512 address columns, 666 calls and 408 helpers. Raw and decoded +inputs are capped at 64 MiB; each source subprocess has a 120-second timeout. + +## Limits + +The nominal stock arithmetic is a reconciled declaration, not a proof of +physical storage adequacy. The other helpers' native dependency closure, +warps, physical backing and movement, and precision/prefix/tape costs remain +inherited. The 86 other private endpoints were not checked. No complex root +or packing cap, bit supplier cap, outer coupling/release, or all-size, +compiler and analytic implication was independently replayed. Neither +supplier is newly admitted and the selected frontier is unchanged. + +## Open next questions + +The next useful native check starts from the 55/4/4/5/5 private-touch +inventories for this group and binds every peer transition and warp reaching +those endpoints. It matters because direct local identities do not establish +the whole physical caller. Common-chart and peer-native correctness are the +blockers. After that, the exact PR2979 physical/prefix inputs and both supplier +caps need independent review before using its claimed exponent. Another +lowering census or another surrogate-price evaluation does not close these +obligations. Structured questions are in [TASK.json](TASK.json). + +## Credit + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. + +Marius-Paul Dumitrean supplied PR2979 and PR2942's construction; Dugongue +supplied the PR2969 comparator and PR2839's owner engine. Nick Petalas +supplied the reused PR2993 frame checker and PR3006 covector +engine; PR3008's zero-entrance event audit and PR3014's frozen-parent invoice +are method predecessors. ToikY/PR3038 already checked the two native residual +classes inside the V45 cone; its exact coverage is explicitly retained above. +Ross Richardson/PR2987 supplied the complementary +packing audit, and Gonzalo Mier/PR3079 already replayed the published T74 +aggregate arithmetic without owner chronology. Jeremy Kothe supplied frame, +cleanup and rewrite work; Mason Hale and Jeremy Diviney supplied the +paired-extraction chain. The native +compiler retains icekylinx's credit; the separate exact Gaussian kernel is +Sagar Thakrar's. DreamingOfClouds and chafreaky/PR458 supplied the residual +wrapper convention. Earlier helper450 event/scalar audits by bbMisk/PR1611 +and ToikY/PR1710 concern the older k8 word, not this changed endpoint. +Retain Tekalign, Yiyang Lu, Cinna Davis and the geometry/owner/native lineage +credited in those sources. Apache-2.0; original notices remain in place. +No independent human or formal-kernel review is claimed. + +[2979]: https://github.com/CrocSwap/integer-mult-bounds/pull/2979 +[2993]: https://github.com/CrocSwap/integer-mult-bounds/pull/2993 +[3006]: https://github.com/CrocSwap/integer-mult-bounds/pull/3006 +[3038]: https://github.com/CrocSwap/integer-mult-bounds/pull/3038 +[thread]: https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-19001817 diff --git a/research/rank7-group-a-entrance-audit/RESULT.json b/research/rank7-group-a-entrance-audit/RESULT.json new file mode 100644 index 0000000000..04aca52228 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/RESULT.json @@ -0,0 +1,8835 @@ +{ + "invoice": { + "bins": 149184, + "calls": { + "base": 250, + "extra": 416 + }, + "complete": { + "1": 1645680, + "2": 470196, + "3": 159468, + "4": 71928, + "48": 28190, + "5": 13716, + "8": 5328 + }, + "group_placements": 3330, + "group_rows_sha256": "7bf6ec71c273dc242e96c905df7fb5177aaf685fe4900959db468ba25aae9a03", + "group_widths": { + "331": 7, + "450": 6, + "451": 6, + "508": 6, + "509": 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 + }, + "local_comparison": { + "base": { + "final_cleanup": { + "cleanup_gates": 5207, + "private_buffers": 91 + }, + "joint": { + "cleanup": { + "cleanup_gates": 4992, + "private_buffers": 86 + }, + "delta": { + "1": -1, + "2": 20, + "3": -14, + "4": 2, + "5": -2 + }, + "guide_margin": 42541, + "profile": { + "1": 2433, + "2": 652, + "3": 272, + "4": 106, + "5": 24, + "8": 8 + }, + "surrogate_price": -10499041, + "width_inventory": { + "4": 26, + "5": 2, + "6": 4, + "7": 59, + "8": 99, + "9": 218 + } + }, + "parent": { + "cleanup": { + "cleanup_gates": 4992, + "private_buffers": 86 + }, + "delta": {}, + "guide_margin": 0, + "profile": { + "1": 2434, + "2": 632, + "3": 286, + "4": 104, + "5": 26, + "8": 8 + }, + "surrogate_price": 0, + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 100, + "9": 218 + } + }, + "single331": { + "cleanup": { + "cleanup_gates": 4992, + "private_buffers": 86 + }, + "delta": { + "1": 3, + "2": 20, + "3": -14, + "4": 2, + "5": -2 + }, + "guide_margin": -58943, + "profile": { + "1": 2437, + "2": 652, + "3": 272, + "4": 106, + "5": 24, + "8": 8 + }, + "surrogate_price": -2032357, + "width_inventory": { + "4": 26, + "5": 2, + "7": 63, + "8": 99, + "9": 218 + } + } + }, + "extra": { + "final_cleanup": { + "cleanup_gates": 5207, + "private_buffers": 91 + }, + "joint": { + "cleanup": { + "cleanup_gates": 4992, + "private_buffers": 86 + }, + "delta": { + "1": -1, + "2": 20, + "3": -14, + "4": 2, + "5": -2 + }, + "guide_margin": 42541, + "profile": { + "1": 2433, + "2": 652, + "3": 272, + "4": 106, + "5": 24, + "8": 8 + }, + "surrogate_price": -10499041, + "width_inventory": { + "4": 26, + "5": 2, + "6": 4, + "7": 59, + "8": 99, + "9": 218 + } + }, + "parent": { + "cleanup": { + "cleanup_gates": 4992, + "private_buffers": 86 + }, + "delta": {}, + "guide_margin": 0, + "profile": { + "1": 2434, + "2": 632, + "3": 286, + "4": 104, + "5": 26, + "8": 8 + }, + "surrogate_price": 0, + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 100, + "9": 218 + } + }, + "single331": { + "cleanup": { + "cleanup_gates": 4992, + "private_buffers": 86 + }, + "delta": { + "1": 3, + "2": 20, + "3": -14, + "4": 2, + "5": -2 + }, + "guide_margin": -58943, + "profile": { + "1": 2437, + "2": 652, + "3": 272, + "4": 106, + "5": 24, + "8": 8 + }, + "surrogate_price": -2032357, + "width_inventory": { + "4": 26, + "5": 2, + "7": 63, + "8": 99, + "9": 218 + } + } + } + }, + "native": { + "base": { + "adapter_sha256": "e1befeb697875416d93ff291ec931b6267bf7961cbb5afb2d96786c9d05e028a", + "bindings": { + "331": { + "backward": { + "buffers": [ + [ + 17185, + "alloc" + ], + [ + 22483, + "free" + ] + ], + "climbs": [ + { + "index": 9940, + "new": [ + 193 + ], + "old": [], + "rank": 1 + }, + { + "index": 10011, + "new": [ + 193, + 30 + ], + "old": [ + 193 + ], + "rank": 1 + }, + { + "index": 13180, + "new": [ + 321, + 193, + 30 + ], + "old": [ + 193, + 30 + ], + "rank": 1 + }, + { + "index": 13546, + "new": [ + 321, + 193, + 44, + 30 + ], + "old": [ + 321, + 193, + 30 + ], + "rank": 1 + }, + { + "index": 13642, + "new": [ + 320, + 192, + 44, + 30, + 1 + ], + "old": [ + 321, + 193, + 44, + 30 + ], + "rank": 1 + }, + { + "index": 15968, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 320, + 192, + 44, + 30, + 1 + ], + "rank": 2 + } + ], + "compact_helper": 331, + "direct_scalar_count": 112, + "direct_scalar_indices": [ + 7148, + 7149, + 7150, + 7151, + 7152, + 7153, + 7154, + 7155, + 7156, + 7157, + 7158, + 7159, + 7160, + 7161, + 7162, + 7163, + 7164, + 7166, + 7758, + 7765, + 7772, + 7773, + 7774, + 7775, + 7776, + 7777, + 7778, + 7779, + 7780, + 7781, + 7782, + 7783, + 7784, + 7794, + 7795, + 7796, + 7797, + 7802, + 7819, + 7829, + 7845, + 9941, + 9955, + 9956, + 9957, + 9958, + 10012, + 10013, + 12470, + 13182, + 13204, + 13547, + 13643, + 15969, + 16067, + 16068, + 16069, + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079 + ], + "direct_scalar_sha256": "f163218ed916656c6b3990fd52fd32e1d18b761952818767c2bee7ecebe00fe9", + "entrance": [], + "private_uses": [ + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079 + ], + "recipe_key": "0:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6369, + "pre" + ], + [ + 22574, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17185, + "alloc" + ], + [ + 22483, + "free" + ] + ], + "climbs": [ + { + "index": 9940, + "new": [ + 193 + ], + "old": [], + "rank": 1 + }, + { + "index": 10011, + "new": [ + 193, + 30 + ], + "old": [ + 193 + ], + "rank": 1 + }, + { + "index": 13180, + "new": [ + 321, + 193, + 30 + ], + "old": [ + 193, + 30 + ], + "rank": 1 + }, + { + "index": 13546, + "new": [ + 321, + 193, + 44, + 30 + ], + "old": [ + 321, + 193, + 30 + ], + "rank": 1 + }, + { + "index": 13642, + "new": [ + 320, + 192, + 44, + 30, + 1 + ], + "old": [ + 321, + 193, + 44, + 30 + ], + "rank": 1 + }, + { + "index": 15968, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 320, + 192, + 44, + 30, + 1 + ], + "rank": 2 + } + ], + "compact_helper": 331, + "direct_scalar_count": 112, + "direct_scalar_indices": [ + 7148, + 7149, + 7150, + 7151, + 7152, + 7153, + 7154, + 7155, + 7156, + 7157, + 7158, + 7159, + 7160, + 7161, + 7162, + 7163, + 7164, + 7166, + 7758, + 7765, + 7772, + 7773, + 7774, + 7775, + 7776, + 7777, + 7778, + 7779, + 7780, + 7781, + 7782, + 7783, + 7784, + 7794, + 7795, + 7796, + 7797, + 7802, + 7819, + 7829, + 7845, + 9941, + 9955, + 9956, + 9957, + 9958, + 10012, + 10013, + 12470, + 13182, + 13204, + 13547, + 13643, + 15969, + 16067, + 16068, + 16069, + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079 + ], + "direct_scalar_sha256": "f163218ed916656c6b3990fd52fd32e1d18b761952818767c2bee7ecebe00fe9", + "entrance": [], + "private_uses": [ + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079 + ], + "recipe_key": "0:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6369, + "pre" + ], + [ + 22574, + "post" + ] + ] + } + }, + "450": { + "backward": { + "buffers": [ + [ + 17210, + "alloc" + ], + [ + 22508, + "free" + ] + ], + "climbs": [ + { + "index": 12943, + "new": [ + 448, + 38, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13206, + "new": [ + 257, + 129, + 64, + 38, + 30 + ], + "old": [ + 448, + 38, + 30 + ], + "rank": 2 + }, + { + "index": 14516, + "new": [ + 257, + 129, + 64, + 38, + 20, + 10 + ], + "old": [ + 257, + 129, + 64, + 38, + 30 + ], + "rank": 1 + }, + { + "index": 15916, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 64, + 38, + 20, + 10 + ], + "rank": 1 + } + ], + "compact_helper": 450, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12017, + 12019, + 12944, + 13207, + 14517, + 15918, + 15920, + 17431, + 17432, + 18274, + 18389 + ], + "direct_scalar_sha256": "ff5dc34dff178c56a79211e20df26b906987ae0167e8d19b059e28bb395586dd", + "entrance": [ + 30 + ], + "private_uses": [ + 17431, + 17432, + 18274, + 18389 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6488, + "pre" + ], + [ + 22599, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17210, + "alloc" + ], + [ + 22508, + "free" + ] + ], + "climbs": [ + { + "index": 12943, + "new": [ + 448, + 38, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13206, + "new": [ + 257, + 129, + 64, + 38, + 30 + ], + "old": [ + 448, + 38, + 30 + ], + "rank": 2 + }, + { + "index": 14516, + "new": [ + 257, + 129, + 64, + 38, + 20, + 10 + ], + "old": [ + 257, + 129, + 64, + 38, + 30 + ], + "rank": 1 + }, + { + "index": 15916, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 64, + 38, + 20, + 10 + ], + "rank": 1 + } + ], + "compact_helper": 450, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12017, + 12019, + 12944, + 13207, + 14517, + 15918, + 15920, + 17431, + 17432, + 18274, + 18389 + ], + "direct_scalar_sha256": "ff5dc34dff178c56a79211e20df26b906987ae0167e8d19b059e28bb395586dd", + "entrance": [ + 30 + ], + "private_uses": [ + 17431, + 17432, + 18274, + 18389 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6488, + "pre" + ], + [ + 22599, + "post" + ] + ] + } + }, + "451": { + "backward": { + "buffers": [ + [ + 17211, + "alloc" + ], + [ + 22509, + "free" + ] + ], + "climbs": [ + { + "index": 12945, + "new": [ + 486, + 21, + 11 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13211, + "new": [ + 257, + 129, + 102, + 21, + 11 + ], + "old": [ + 486, + 21, + 11 + ], + "rank": 2 + }, + { + "index": 14522, + "new": [ + 256, + 128, + 102, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 102, + 21, + 11 + ], + "rank": 1 + }, + { + "index": 15921, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 256, + 128, + 102, + 20, + 10, + 1 + ], + "rank": 1 + } + ], + "compact_helper": 451, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12021, + 12023, + 12946, + 13212, + 14523, + 15923, + 15925, + 17429, + 17430, + 18272, + 18388 + ], + "direct_scalar_sha256": "dae2879a827096c1050e3323f0d53c5c02e2bf21eb6f26dc2a3317d7a6e773c5", + "entrance": [ + 30 + ], + "private_uses": [ + 17429, + 17430, + 18272, + 18388 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6489, + "pre" + ], + [ + 22600, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17211, + "alloc" + ], + [ + 22509, + "free" + ] + ], + "climbs": [ + { + "index": 12945, + "new": [ + 486, + 21, + 11 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13211, + "new": [ + 257, + 129, + 102, + 21, + 11 + ], + "old": [ + 486, + 21, + 11 + ], + "rank": 2 + }, + { + "index": 14522, + "new": [ + 256, + 128, + 102, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 102, + 21, + 11 + ], + "rank": 1 + }, + { + "index": 15921, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 256, + 128, + 102, + 20, + 10, + 1 + ], + "rank": 1 + } + ], + "compact_helper": 451, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12021, + 12023, + 12946, + 13212, + 14523, + 15923, + 15925, + 17429, + 17430, + 18272, + 18388 + ], + "direct_scalar_sha256": "dae2879a827096c1050e3323f0d53c5c02e2bf21eb6f26dc2a3317d7a6e773c5", + "entrance": [ + 30 + ], + "private_uses": [ + 17429, + 17430, + 18272, + 18388 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6489, + "pre" + ], + [ + 22600, + "post" + ] + ] + } + }, + "508": { + "backward": { + "buffers": [ + [ + 17222, + "alloc" + ], + [ + 22520, + "free" + ] + ], + "climbs": [ + { + "index": 13203, + "new": [ + 321, + 193, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13205, + "new": [ + 257, + 129, + 64, + 38, + 30 + ], + "old": [ + 321, + 193, + 30 + ], + "rank": 2 + }, + { + "index": 14513, + "new": [ + 256, + 128, + 64, + 38, + 30, + 1 + ], + "old": [ + 257, + 129, + 64, + 38, + 30 + ], + "rank": 1 + }, + { + "index": 15919, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 256, + 128, + 64, + 38, + 30, + 1 + ], + "rank": 1 + } + ], + "compact_helper": 503, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12050, + 13204, + 13207, + 14514, + 15920, + 15969, + 15970, + 17406, + 17407, + 17431, + 18274, + 18275 + ], + "direct_scalar_sha256": "176820144a6e1cd50d44dc98d960243f0f0c71ba890d3bf337d9a2c9aa2d1a49", + "entrance": [ + 30 + ], + "private_uses": [ + 17406, + 17407, + 17431, + 18274, + 18275 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6541, + "pre" + ], + [ + 22630, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17222, + "alloc" + ], + [ + 22520, + "free" + ] + ], + "climbs": [ + { + "index": 13203, + "new": [ + 321, + 193, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13205, + "new": [ + 257, + 129, + 64, + 38, + 30 + ], + "old": [ + 321, + 193, + 30 + ], + "rank": 2 + }, + { + "index": 14513, + "new": [ + 256, + 128, + 64, + 38, + 30, + 1 + ], + "old": [ + 257, + 129, + 64, + 38, + 30 + ], + "rank": 1 + }, + { + "index": 15919, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 256, + 128, + 64, + 38, + 30, + 1 + ], + "rank": 1 + } + ], + "compact_helper": 503, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12050, + 13204, + 13207, + 14514, + 15920, + 15969, + 15970, + 17406, + 17407, + 17431, + 18274, + 18275 + ], + "direct_scalar_sha256": "176820144a6e1cd50d44dc98d960243f0f0c71ba890d3bf337d9a2c9aa2d1a49", + "entrance": [ + 30 + ], + "private_uses": [ + 17406, + 17407, + 17431, + 18274, + 18275 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6541, + "pre" + ], + [ + 22630, + "post" + ] + ] + } + }, + "509": { + "backward": { + "buffers": [ + [ + 17223, + "alloc" + ], + [ + 22521, + "free" + ] + ], + "climbs": [ + { + "index": 13208, + "new": [ + 266, + 138, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13210, + "new": [ + 257, + 129, + 102, + 21, + 11 + ], + "old": [ + 266, + 138, + 30 + ], + "rank": 2 + }, + { + "index": 14519, + "new": [ + 257, + 129, + 65, + 39, + 21, + 11 + ], + "old": [ + 257, + 129, + 102, + 21, + 11 + ], + "rank": 1 + }, + { + "index": 15924, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 65, + 39, + 21, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 504, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12051, + 13209, + 13212, + 14520, + 15925, + 15971, + 15973, + 17404, + 17405, + 17429, + 18272, + 18273 + ], + "direct_scalar_sha256": "37c5918a44d89eb91b933f21d8b79d2f03e4f742e24fe975b422e82093d7e59f", + "entrance": [ + 30 + ], + "private_uses": [ + 17404, + 17405, + 17429, + 18272, + 18273 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6542, + "pre" + ], + [ + 22631, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17223, + "alloc" + ], + [ + 22521, + "free" + ] + ], + "climbs": [ + { + "index": 13208, + "new": [ + 266, + 138, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13210, + "new": [ + 257, + 129, + 102, + 21, + 11 + ], + "old": [ + 266, + 138, + 30 + ], + "rank": 2 + }, + { + "index": 14519, + "new": [ + 257, + 129, + 65, + 39, + 21, + 11 + ], + "old": [ + 257, + 129, + 102, + 21, + 11 + ], + "rank": 1 + }, + { + "index": 15924, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 65, + 39, + 21, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 504, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12051, + 13209, + 13212, + 14520, + 15925, + 15971, + 15973, + 17404, + 17405, + 17429, + 18272, + 18273 + ], + "direct_scalar_sha256": "37c5918a44d89eb91b933f21d8b79d2f03e4f742e24fe975b422e82093d7e59f", + "entrance": [ + 30 + ], + "private_uses": [ + 17404, + 17405, + 17429, + 18272, + 18273 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6542, + "pre" + ], + [ + 22631, + "post" + ] + ] + } + } + }, + "climb_recipes": { + "[[193,30],[321,193,30]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 321, + 257, + 2, + 4, + 8, + 16, + 32, + 320, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 0, + 0, + 0, + 0, + 0, + 65, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[193],[193,30]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 1, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 1, + 18, + 20, + 24, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[256,128,102,20,10,1],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 38, + 1, + 98, + 100, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 77, + "phase": 0, + "quadratic_rows": [ + 0, + 70, + 70, + 0, + 0, + 64, + 38, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[256,128,64,38,30,1],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 1, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 1, + 26, + 20, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 22, + 2, + 6, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,102,21,11],[256,128,102,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 17, + 33, + 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, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 263, + 256, + 258, + 260, + 264, + 272, + 32, + 64, + 384 + ], + "offset": 63, + "phase": 0, + "quadratic_rows": [ + 6, + 7, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,102,21,11],[257,129,65,39,21,11]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 38, + 33, + 98, + 100, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 79, + "phase": 3, + "quadratic_rows": [ + 32, + 70, + 70, + 0, + 0, + 97, + 38, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,64,38,20,10],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 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": [ + 257, + 256, + 2, + 4, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 3, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,64,38,30],[256,128,64,38,30,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 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": [ + 257, + 256, + 2, + 4, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 3, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,64,38,30],[257,129,64,38,20,10]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 1, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 1, + 26, + 20, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 22, + 2, + 6, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,65,39,21,11],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 17, + 33, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 257, + 256, + 2, + 4, + 264, + 272, + 288, + 320, + 384 + ], + "offset": 62, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[266,138,30],[257,129,102,21,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 35, + 67, + 130, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 0, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 6, + 40, + 9, + 330, + 324, + 256, + 272, + 96, + 384 + ], + "offset": 122, + "phase": 1, + "quadratic_rows": [ + 8, + 334, + 326, + 99, + 0, + 104, + 46, + 0, + 6 + ] + } + }, + "spectator_axes": 7 + }, + "[[30],[266,138,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 34, + 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": [ + 0, + 3, + 0, + 3, + 0, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 138, + 1, + 386, + 4, + 392, + 16, + 32, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 266, + 0, + 266, + 0, + 0, + 0, + 384, + 138 + ] + } + }, + "spectator_axes": 7 + }, + "[[30],[321,193,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 16, + 32, + 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": [ + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 193, + 385, + 2, + 4, + 8, + 16, + 32, + 448 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 321, + 0, + 0, + 0, + 0, + 0, + 321, + 384, + 193 + ] + } + }, + "spectator_axes": 7 + }, + "[[30],[448,38,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 32, + 64, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 2, + 3, + 3, + 2 + ], + "matrix_rows": [ + 38, + 448, + 1, + 34, + 36, + 8, + 16, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 192, + 192, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[30],[486,21,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 35, + 3, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 1, + 1, + 1, + 2 + ], + "matrix_rows": [ + 6, + 232, + 9, + 282, + 276, + 16, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 8, + 286, + 278, + 483, + 6, + 488, + 488, + 488, + 238 + ] + } + }, + "spectator_axes": 7 + }, + "[[320,192,44,30,1],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 16, + 33, + 65, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 0, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 40, + 320, + 1, + 10, + 4, + 32, + 48, + 256, + 384 + ], + "offset": 251, + "phase": 1, + "quadratic_rows": [ + 0, + 8, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[321,193,30],[257,129,64,38,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 32, + 64, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 38, + 320, + 1, + 34, + 36, + 8, + 16, + 256, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[321,193,30],[321,193,44,30]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 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": [ + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[321,193,44,30],[320,192,44,30,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 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": [ + 257, + 256, + 2, + 4, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[448,38,30],[257,129,64,38,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 16, + 32, + 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": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 449, + 385, + 2, + 4, + 8, + 16, + 32, + 256 + ], + "offset": 258, + "phase": 0, + "quadratic_rows": [ + 65, + 0, + 0, + 0, + 0, + 0, + 129, + 320, + 384 + ] + } + }, + "spectator_axes": 7 + }, + "[[486,21,11],[257,129,102,21,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 18, + 32, + 64, + 130, + 258, + 1, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 0, + 1, + 2, + 2, + 1 + ], + "matrix_rows": [ + 384, + 167, + 385, + 322, + 324, + 8, + 16, + 352, + 256 + ], + "offset": 410, + "phase": 3, + "quadratic_rows": [ + 295, + 487, + 487, + 0, + 0, + 487, + 38, + 38, + 295 + ] + } + }, + "spectator_axes": 7 + }, + "[[],[193]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 193, + 129, + 2, + 4, + 8, + 16, + 32, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 0, + 0, + 0, + 0, + 0, + 65, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + } + }, + "controls": { + "cold_wrapper_alias": "phase-exact all-column residual", + "omitted_entrance": "entrance-relative width", + "phase": "phase-exact all-column residual", + "wrong_entrance_line": "phase-exact all-column residual" + }, + "local_checks_sha256": "f2a8160669dba42701bf43a9cd18ba47e4a2ac16a5eb6dac2b77e41eaec5cbdc", + "parent_residual_comparison": { + "331": { + "entrance": [], + "joint_recipe_key": "0:261", + "parent": { + "columns": 512, + "orientations": 2, + "rank": 8, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 270, + 6, + 10, + 2, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 26, + 22, + 32, + 64, + 128, + 256, + 30 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 12, + 12, + 2, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 1 + }, + "parent_terminal": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + }, + "450": { + "entrance": [ + 30 + ], + "joint_recipe_key": "115:261", + "parent": { + "columns": 512, + "orientations": 2, + "rank": 7, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 128, + 262, + 2, + 4, + 8, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 3, + 3, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 4, + 32, + 64, + 128, + 256, + 14, + 16 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 12, + 2, + 26, + 24, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 2 + }, + "parent_terminal": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "residuals": { + "0:261": { + "columns": 512, + "orientations": 2, + "rank": 7, + "recipe": { + "entrance_rank": 0, + "frame": 0, + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 140, + 258, + 10, + 4, + 6, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 0, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 34, + 64, + 128, + 256, + 42, + 52 + ], + "offset": 119, + "phase": 2, + "quadratic_rows": [ + 0, + 16, + 44, + 36, + 34, + 28, + 0, + 0, + 0 + ] + }, + "terminal": 261, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "vectors": [] + }, + "spectator_axes": 2 + }, + "115:261": { + "columns": 512, + "orientations": 2, + "rank": 6, + "recipe": { + "entrance_rank": 1, + "frame": 115, + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 68, + 132, + 258, + 2, + 6, + 8, + 16, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 6, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 1, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 46, + 64, + 128, + 256, + 58, + 52, + 16 + ], + "offset": 63, + "phase": 2, + "quadratic_rows": [ + 0, + 22, + 30, + 36, + 6, + 40, + 0, + 0, + 0 + ] + }, + "terminal": 261, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "vectors": [ + 30 + ] + }, + "spectator_axes": 3 + } + } + }, + "extra": { + "adapter_sha256": "cc366668c225431a1e5d0f856dbe7ba079c8e2fa1dc3ad0ceeecb9f0796aff77", + "bindings": { + "331": { + "backward": { + "buffers": [ + [ + 17185, + "alloc" + ], + [ + 22483, + "free" + ] + ], + "climbs": [ + { + "index": 9940, + "new": [ + 193 + ], + "old": [], + "rank": 1 + }, + { + "index": 10011, + "new": [ + 193, + 30 + ], + "old": [ + 193 + ], + "rank": 1 + }, + { + "index": 13180, + "new": [ + 321, + 193, + 30 + ], + "old": [ + 193, + 30 + ], + "rank": 1 + }, + { + "index": 13546, + "new": [ + 321, + 193, + 44, + 30 + ], + "old": [ + 321, + 193, + 30 + ], + "rank": 1 + }, + { + "index": 13642, + "new": [ + 320, + 192, + 44, + 30, + 1 + ], + "old": [ + 321, + 193, + 44, + 30 + ], + "rank": 1 + }, + { + "index": 15968, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 320, + 192, + 44, + 30, + 1 + ], + "rank": 2 + } + ], + "compact_helper": 331, + "direct_scalar_count": 112, + "direct_scalar_indices": [ + 7148, + 7149, + 7150, + 7151, + 7152, + 7153, + 7154, + 7155, + 7156, + 7157, + 7158, + 7159, + 7160, + 7161, + 7162, + 7163, + 7164, + 7166, + 7758, + 7765, + 7772, + 7773, + 7774, + 7775, + 7776, + 7777, + 7778, + 7779, + 7780, + 7781, + 7782, + 7783, + 7784, + 7794, + 7795, + 7796, + 7797, + 7802, + 7819, + 7829, + 7845, + 9941, + 9955, + 9956, + 9957, + 9958, + 10012, + 10013, + 12470, + 13182, + 13204, + 13547, + 13643, + 15969, + 16067, + 16068, + 16069, + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079 + ], + "direct_scalar_sha256": "f163218ed916656c6b3990fd52fd32e1d18b761952818767c2bee7ecebe00fe9", + "entrance": [], + "private_uses": [ + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079 + ], + "recipe_key": "0:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6369, + "pre" + ], + [ + 22574, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17185, + "alloc" + ], + [ + 22483, + "free" + ] + ], + "climbs": [ + { + "index": 9940, + "new": [ + 193 + ], + "old": [], + "rank": 1 + }, + { + "index": 10011, + "new": [ + 193, + 30 + ], + "old": [ + 193 + ], + "rank": 1 + }, + { + "index": 13180, + "new": [ + 321, + 193, + 30 + ], + "old": [ + 193, + 30 + ], + "rank": 1 + }, + { + "index": 13546, + "new": [ + 321, + 193, + 44, + 30 + ], + "old": [ + 321, + 193, + 30 + ], + "rank": 1 + }, + { + "index": 13642, + "new": [ + 320, + 192, + 44, + 30, + 1 + ], + "old": [ + 321, + 193, + 44, + 30 + ], + "rank": 1 + }, + { + "index": 15968, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 320, + 192, + 44, + 30, + 1 + ], + "rank": 2 + } + ], + "compact_helper": 331, + "direct_scalar_count": 112, + "direct_scalar_indices": [ + 7148, + 7149, + 7150, + 7151, + 7152, + 7153, + 7154, + 7155, + 7156, + 7157, + 7158, + 7159, + 7160, + 7161, + 7162, + 7163, + 7164, + 7166, + 7758, + 7765, + 7772, + 7773, + 7774, + 7775, + 7776, + 7777, + 7778, + 7779, + 7780, + 7781, + 7782, + 7783, + 7784, + 7794, + 7795, + 7796, + 7797, + 7802, + 7819, + 7829, + 7845, + 9941, + 9955, + 9956, + 9957, + 9958, + 10012, + 10013, + 12470, + 13182, + 13204, + 13547, + 13643, + 15969, + 16067, + 16068, + 16069, + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079 + ], + "direct_scalar_sha256": "f163218ed916656c6b3990fd52fd32e1d18b761952818767c2bee7ecebe00fe9", + "entrance": [], + "private_uses": [ + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079 + ], + "recipe_key": "0:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6369, + "pre" + ], + [ + 22574, + "post" + ] + ] + } + }, + "450": { + "backward": { + "buffers": [ + [ + 17210, + "alloc" + ], + [ + 22508, + "free" + ] + ], + "climbs": [ + { + "index": 12943, + "new": [ + 448, + 38, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13206, + "new": [ + 257, + 129, + 64, + 38, + 30 + ], + "old": [ + 448, + 38, + 30 + ], + "rank": 2 + }, + { + "index": 14516, + "new": [ + 257, + 129, + 64, + 38, + 20, + 10 + ], + "old": [ + 257, + 129, + 64, + 38, + 30 + ], + "rank": 1 + }, + { + "index": 15916, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 64, + 38, + 20, + 10 + ], + "rank": 1 + } + ], + "compact_helper": 450, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12017, + 12019, + 12944, + 13207, + 14517, + 15918, + 15920, + 17431, + 17432, + 18274, + 18389 + ], + "direct_scalar_sha256": "ff5dc34dff178c56a79211e20df26b906987ae0167e8d19b059e28bb395586dd", + "entrance": [ + 30 + ], + "private_uses": [ + 17431, + 17432, + 18274, + 18389 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6488, + "pre" + ], + [ + 22599, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17210, + "alloc" + ], + [ + 22508, + "free" + ] + ], + "climbs": [ + { + "index": 12943, + "new": [ + 448, + 38, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13206, + "new": [ + 257, + 129, + 64, + 38, + 30 + ], + "old": [ + 448, + 38, + 30 + ], + "rank": 2 + }, + { + "index": 14516, + "new": [ + 257, + 129, + 64, + 38, + 20, + 10 + ], + "old": [ + 257, + 129, + 64, + 38, + 30 + ], + "rank": 1 + }, + { + "index": 15916, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 64, + 38, + 20, + 10 + ], + "rank": 1 + } + ], + "compact_helper": 450, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12017, + 12019, + 12944, + 13207, + 14517, + 15918, + 15920, + 17431, + 17432, + 18274, + 18389 + ], + "direct_scalar_sha256": "ff5dc34dff178c56a79211e20df26b906987ae0167e8d19b059e28bb395586dd", + "entrance": [ + 30 + ], + "private_uses": [ + 17431, + 17432, + 18274, + 18389 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6488, + "pre" + ], + [ + 22599, + "post" + ] + ] + } + }, + "451": { + "backward": { + "buffers": [ + [ + 17211, + "alloc" + ], + [ + 22509, + "free" + ] + ], + "climbs": [ + { + "index": 12945, + "new": [ + 486, + 21, + 11 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13211, + "new": [ + 257, + 129, + 102, + 21, + 11 + ], + "old": [ + 486, + 21, + 11 + ], + "rank": 2 + }, + { + "index": 14522, + "new": [ + 256, + 128, + 102, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 102, + 21, + 11 + ], + "rank": 1 + }, + { + "index": 15921, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 256, + 128, + 102, + 20, + 10, + 1 + ], + "rank": 1 + } + ], + "compact_helper": 451, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12021, + 12023, + 12946, + 13212, + 14523, + 15923, + 15925, + 17429, + 17430, + 18272, + 18388 + ], + "direct_scalar_sha256": "dae2879a827096c1050e3323f0d53c5c02e2bf21eb6f26dc2a3317d7a6e773c5", + "entrance": [ + 30 + ], + "private_uses": [ + 17429, + 17430, + 18272, + 18388 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6489, + "pre" + ], + [ + 22600, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17211, + "alloc" + ], + [ + 22509, + "free" + ] + ], + "climbs": [ + { + "index": 12945, + "new": [ + 486, + 21, + 11 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13211, + "new": [ + 257, + 129, + 102, + 21, + 11 + ], + "old": [ + 486, + 21, + 11 + ], + "rank": 2 + }, + { + "index": 14522, + "new": [ + 256, + 128, + 102, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 102, + 21, + 11 + ], + "rank": 1 + }, + { + "index": 15921, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 256, + 128, + 102, + 20, + 10, + 1 + ], + "rank": 1 + } + ], + "compact_helper": 451, + "direct_scalar_count": 11, + "direct_scalar_indices": [ + 12021, + 12023, + 12946, + 13212, + 14523, + 15923, + 15925, + 17429, + 17430, + 18272, + 18388 + ], + "direct_scalar_sha256": "dae2879a827096c1050e3323f0d53c5c02e2bf21eb6f26dc2a3317d7a6e773c5", + "entrance": [ + 30 + ], + "private_uses": [ + 17429, + 17430, + 18272, + 18388 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6489, + "pre" + ], + [ + 22600, + "post" + ] + ] + } + }, + "508": { + "backward": { + "buffers": [ + [ + 17222, + "alloc" + ], + [ + 22520, + "free" + ] + ], + "climbs": [ + { + "index": 13203, + "new": [ + 321, + 193, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13205, + "new": [ + 257, + 129, + 64, + 38, + 30 + ], + "old": [ + 321, + 193, + 30 + ], + "rank": 2 + }, + { + "index": 14513, + "new": [ + 256, + 128, + 64, + 38, + 30, + 1 + ], + "old": [ + 257, + 129, + 64, + 38, + 30 + ], + "rank": 1 + }, + { + "index": 15919, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 256, + 128, + 64, + 38, + 30, + 1 + ], + "rank": 1 + } + ], + "compact_helper": 503, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12050, + 13204, + 13207, + 14514, + 15920, + 15969, + 15970, + 17406, + 17407, + 17431, + 18274, + 18275 + ], + "direct_scalar_sha256": "176820144a6e1cd50d44dc98d960243f0f0c71ba890d3bf337d9a2c9aa2d1a49", + "entrance": [ + 30 + ], + "private_uses": [ + 17406, + 17407, + 17431, + 18274, + 18275 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6541, + "pre" + ], + [ + 22630, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17222, + "alloc" + ], + [ + 22520, + "free" + ] + ], + "climbs": [ + { + "index": 13203, + "new": [ + 321, + 193, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13205, + "new": [ + 257, + 129, + 64, + 38, + 30 + ], + "old": [ + 321, + 193, + 30 + ], + "rank": 2 + }, + { + "index": 14513, + "new": [ + 256, + 128, + 64, + 38, + 30, + 1 + ], + "old": [ + 257, + 129, + 64, + 38, + 30 + ], + "rank": 1 + }, + { + "index": 15919, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 256, + 128, + 64, + 38, + 30, + 1 + ], + "rank": 1 + } + ], + "compact_helper": 503, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12050, + 13204, + 13207, + 14514, + 15920, + 15969, + 15970, + 17406, + 17407, + 17431, + 18274, + 18275 + ], + "direct_scalar_sha256": "176820144a6e1cd50d44dc98d960243f0f0c71ba890d3bf337d9a2c9aa2d1a49", + "entrance": [ + 30 + ], + "private_uses": [ + 17406, + 17407, + 17431, + 18274, + 18275 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6541, + "pre" + ], + [ + 22630, + "post" + ] + ] + } + }, + "509": { + "backward": { + "buffers": [ + [ + 17223, + "alloc" + ], + [ + 22521, + "free" + ] + ], + "climbs": [ + { + "index": 13208, + "new": [ + 266, + 138, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13210, + "new": [ + 257, + 129, + 102, + 21, + 11 + ], + "old": [ + 266, + 138, + 30 + ], + "rank": 2 + }, + { + "index": 14519, + "new": [ + 257, + 129, + 65, + 39, + 21, + 11 + ], + "old": [ + 257, + 129, + 102, + 21, + 11 + ], + "rank": 1 + }, + { + "index": 15924, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 65, + 39, + 21, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 504, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12051, + 13209, + 13212, + 14520, + 15925, + 15971, + 15973, + 17404, + 17405, + 17429, + 18272, + 18273 + ], + "direct_scalar_sha256": "37c5918a44d89eb91b933f21d8b79d2f03e4f742e24fe975b422e82093d7e59f", + "entrance": [ + 30 + ], + "private_uses": [ + 17404, + 17405, + 17429, + 18272, + 18273 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6542, + "pre" + ], + [ + 22631, + "post" + ] + ] + }, + "forward": { + "buffers": [ + [ + 17223, + "alloc" + ], + [ + 22521, + "free" + ] + ], + "climbs": [ + { + "index": 13208, + "new": [ + 266, + 138, + 30 + ], + "old": [ + 30 + ], + "rank": 2 + }, + { + "index": 13210, + "new": [ + 257, + 129, + 102, + 21, + 11 + ], + "old": [ + 266, + 138, + 30 + ], + "rank": 2 + }, + { + "index": 14519, + "new": [ + 257, + 129, + 65, + 39, + 21, + 11 + ], + "old": [ + 257, + 129, + 102, + 21, + 11 + ], + "rank": 1 + }, + { + "index": 15924, + "new": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "old": [ + 257, + 129, + 65, + 39, + 21, + 11 + ], + "rank": 1 + } + ], + "compact_helper": 504, + "direct_scalar_count": 12, + "direct_scalar_indices": [ + 12051, + 13209, + 13212, + 14520, + 15925, + 15971, + 15973, + 17404, + 17405, + 17429, + 18272, + 18273 + ], + "direct_scalar_sha256": "37c5918a44d89eb91b933f21d8b79d2f03e4f742e24fe975b422e82093d7e59f", + "entrance": [ + 30 + ], + "private_uses": [ + 17404, + 17405, + 17429, + 18272, + 18273 + ], + "recipe_key": "115:261", + "terminal": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "wrappers": [ + [ + 6542, + "pre" + ], + [ + 22631, + "post" + ] + ] + } + } + }, + "climb_recipes": { + "[[193,30],[321,193,30]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 321, + 257, + 2, + 4, + 8, + 16, + 32, + 320, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 0, + 0, + 0, + 0, + 0, + 65, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[193],[193,30]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 1, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 1, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 1, + 18, + 20, + 24, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 14, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[256,128,102,20,10,1],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 38, + 1, + 98, + 100, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 77, + "phase": 0, + "quadratic_rows": [ + 0, + 70, + 70, + 0, + 0, + 64, + 38, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[256,128,64,38,30,1],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 1, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 1, + 26, + 20, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 22, + 2, + 6, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,102,21,11],[256,128,102,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 17, + 33, + 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, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 263, + 256, + 258, + 260, + 264, + 272, + 32, + 64, + 384 + ], + "offset": 63, + "phase": 0, + "quadratic_rows": [ + 6, + 7, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,102,21,11],[257,129,65,39,21,11]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 38, + 33, + 98, + 100, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 79, + "phase": 3, + "quadratic_rows": [ + 32, + 70, + 70, + 0, + 0, + 97, + 38, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,64,38,20,10],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 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": [ + 257, + 256, + 2, + 4, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 3, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,64,38,30],[256,128,64,38,30,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 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": [ + 257, + 256, + 2, + 4, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 3, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,64,38,30],[257,129,64,38,20,10]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 1, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 1, + 26, + 20, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 22, + 2, + 6, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[257,129,65,39,21,11],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 17, + 33, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + "matrix_rows": [ + 257, + 256, + 2, + 4, + 264, + 272, + 288, + 320, + 384 + ], + "offset": 62, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[266,138,30],[257,129,102,21,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 35, + 67, + 130, + 2, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 2, + 0, + 3, + 2, + 0, + 2 + ], + "matrix_rows": [ + 6, + 40, + 9, + 330, + 324, + 256, + 272, + 96, + 384 + ], + "offset": 122, + "phase": 1, + "quadratic_rows": [ + 8, + 334, + 326, + 99, + 0, + 104, + 46, + 0, + 6 + ] + } + }, + "spectator_axes": 7 + }, + "[[30],[266,138,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 34, + 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": [ + 0, + 3, + 0, + 3, + 0, + 0, + 0, + 3, + 0 + ], + "matrix_rows": [ + 384, + 138, + 1, + 386, + 4, + 392, + 16, + 32, + 64 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 0, + 266, + 0, + 266, + 0, + 0, + 0, + 384, + 138 + ] + } + }, + "spectator_axes": 7 + }, + "[[30],[321,193,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 16, + 32, + 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": [ + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 0 + ], + "matrix_rows": [ + 384, + 193, + 385, + 2, + 4, + 8, + 16, + 32, + 448 + ], + "offset": 2, + "phase": 1, + "quadratic_rows": [ + 321, + 0, + 0, + 0, + 0, + 0, + 321, + 384, + 193 + ] + } + }, + "spectator_axes": 7 + }, + "[[30],[448,38,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 32, + 64, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 2, + 3, + 3, + 2 + ], + "matrix_rows": [ + 38, + 448, + 1, + 34, + 36, + 8, + 16, + 320, + 384 + ], + "offset": 3, + "phase": 2, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 192, + 192, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[30],[486,21,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 35, + 3, + 66, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 1, + 1, + 1, + 2 + ], + "matrix_rows": [ + 6, + 232, + 9, + 282, + 276, + 16, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 8, + 286, + 278, + 483, + 6, + 488, + 488, + 488, + 238 + ] + } + }, + "spectator_axes": 7 + }, + "[[320,192,44,30,1],[256,128,64,38,20,10,1]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 8, + 16, + 33, + 65, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 1, + 0, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 40, + 320, + 1, + 10, + 4, + 32, + 48, + 256, + 384 + ], + "offset": 251, + "phase": 1, + "quadratic_rows": [ + 0, + 8, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[321,193,30],[257,129,64,38,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 9, + 17, + 32, + 64, + 1, + 130, + 258, + 2 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 2, + 0, + 0, + 2 + ], + "matrix_rows": [ + 38, + 320, + 1, + 34, + 36, + 8, + 16, + 256, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 7 + }, + "[[321,193,30],[321,193,44,30]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 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": [ + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[321,193,44,30],[320,192,44,30,1]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 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": [ + 257, + 256, + 2, + 4, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + }, + "[[448,38,30],[257,129,64,38,30]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 16, + 32, + 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": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 3 + ], + "matrix_rows": [ + 384, + 449, + 385, + 2, + 4, + 8, + 16, + 32, + 256 + ], + "offset": 258, + "phase": 0, + "quadratic_rows": [ + 65, + 0, + 0, + 0, + 0, + 0, + 129, + 320, + 384 + ] + } + }, + "spectator_axes": 7 + }, + "[[486,21,11],[257,129,102,21,11]]": { + "columns": 512, + "orientations": 2, + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 18, + 32, + 64, + 130, + 258, + 1, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 3, + 1, + 1, + 0, + 0, + 1, + 2, + 2, + 1 + ], + "matrix_rows": [ + 384, + 167, + 385, + 322, + 324, + 8, + 16, + 352, + 256 + ], + "offset": 410, + "phase": 3, + "quadratic_rows": [ + 295, + 487, + 487, + 0, + 0, + 487, + 38, + 38, + 295 + ] + } + }, + "spectator_axes": 7 + }, + "[[],[193]]": { + "columns": 512, + "orientations": 2, + "rank": 1, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 193, + 129, + 2, + 4, + 8, + 16, + 32, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 65, + 0, + 0, + 0, + 0, + 0, + 65, + 0, + 0 + ] + } + }, + "spectator_axes": 8 + } + }, + "controls": { + "cold_wrapper_alias": "phase-exact all-column residual", + "omitted_entrance": "entrance-relative width", + "phase": "phase-exact all-column residual", + "wrong_entrance_line": "phase-exact all-column residual" + }, + "local_checks_sha256": "f2a8160669dba42701bf43a9cd18ba47e4a2ac16a5eb6dac2b77e41eaec5cbdc", + "parent_residual_comparison": { + "331": { + "entrance": [], + "joint_recipe_key": "0:261", + "parent": { + "columns": 512, + "orientations": 2, + "rank": 8, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 0 + ], + "matrix_rows": [ + 1, + 270, + 6, + 10, + 2, + 16, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 8, + "right": { + "linear_Z4": [ + 2, + 1, + 3, + 3, + 0, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 26, + 22, + 32, + 64, + 128, + 256, + 30 + ], + "offset": 243, + "phase": 2, + "quadratic_rows": [ + 0, + 18, + 12, + 12, + 2, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 1 + }, + "parent_terminal": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + }, + "450": { + "entrance": [ + 30 + ], + "joint_recipe_key": "115:261", + "parent": { + "columns": 512, + "orientations": 2, + "rank": 7, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 128, + 262, + 2, + 4, + 8, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 3, + 3, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 4, + 32, + 64, + 128, + 256, + 14, + 16 + ], + "offset": 511, + "phase": 1, + "quadratic_rows": [ + 0, + 12, + 2, + 26, + 24, + 0, + 0, + 0, + 0 + ] + } + }, + "spectator_axes": 2 + }, + "parent_terminal": [ + 256, + 128, + 64, + 32, + 18, + 10, + 6, + 1 + ] + } + }, + "residuals": { + "0:261": { + "columns": 512, + "orientations": 2, + "rank": 7, + "recipe": { + "entrance_rank": 0, + "frame": 0, + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 1, + 140, + 258, + 10, + 4, + 6, + 16, + 32, + 64 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 7, + "right": { + "linear_Z4": [ + 2, + 0, + 3, + 0, + 0, + 0, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 28, + 26, + 34, + 64, + 128, + 256, + 42, + 52 + ], + "offset": 119, + "phase": 2, + "quadratic_rows": [ + 0, + 16, + 44, + 36, + 34, + 28, + 0, + 0, + 0 + ] + }, + "terminal": 261, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "vectors": [] + }, + "spectator_axes": 2 + }, + "115:261": { + "columns": 512, + "orientations": 2, + "rank": 6, + "recipe": { + "entrance_rank": 1, + "frame": 115, + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 68, + 132, + 258, + 2, + 6, + 8, + 16, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 6, + "right": { + "linear_Z4": [ + 2, + 3, + 3, + 0, + 0, + 1, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 40, + 46, + 64, + 128, + 256, + 58, + 52, + 16 + ], + "offset": 63, + "phase": 2, + "quadratic_rows": [ + 0, + 22, + 30, + 36, + 6, + 40, + 0, + 0, + 0 + ] + }, + "terminal": 261, + "terminal_rank": 7, + "terminal_vectors": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "vectors": [ + 30 + ] + }, + "spectator_axes": 3 + } + } + } + }, + "native_to_owner_join": { + "base": { + "331": { + "helper_index": 107, + "native_pair": "0:261", + "width": 7 + }, + "450": { + "helper_index": 226, + "native_pair": "115:261", + "width": 6 + }, + "451": { + "helper_index": 227, + "native_pair": "115:261", + "width": 6 + }, + "508": { + "helper_index": 279, + "native_pair": "115:261", + "width": 6 + }, + "509": { + "helper_index": 280, + "native_pair": "115:261", + "width": 6 + } + }, + "extra": { + "331": { + "helper_index": 107, + "native_pair": "0:261", + "width": 7 + }, + "450": { + "helper_index": 226, + "native_pair": "115:261", + "width": 6 + }, + "451": { + "helper_index": 227, + "native_pair": "115:261", + "width": 6 + }, + "508": { + "helper_index": 279, + "native_pair": "115:261", + "width": 6 + }, + "509": { + "helper_index": 280, + "native_pair": "115:261", + "width": 6 + } + } + }, + "normalized_endpoints": { + "base": { + "gates": 17575, + "identity_rows": { + "dual:1035": [ + [ + 1035, + [], + "1" + ] + ], + "dual:1154": [ + [ + 1154, + [], + "1" + ] + ], + "dual:1155": [ + [ + 1155, + [], + "1" + ] + ], + "dual:1212": [ + [ + 1212, + [], + "1" + ] + ], + "dual:1213": [ + [ + 1213, + [], + "1" + ] + ], + "dual:331": [ + [ + 331, + [], + "1" + ] + ], + "dual:450": [ + [ + 450, + [], + "1" + ] + ], + "dual:451": [ + [ + 451, + [], + "1" + ] + ], + "dual:508": [ + [ + 508, + [], + "1" + ] + ], + "dual:509": [ + [ + 509, + [], + "1" + ] + ], + "forward:1035": [ + [ + 1035, + [], + "1" + ] + ], + "forward:1154": [ + [ + 1154, + [], + "1" + ] + ], + "forward:1155": [ + [ + 1155, + [], + "1" + ] + ], + "forward:1212": [ + [ + 1212, + [], + "1" + ] + ], + "forward:1213": [ + [ + 1213, + [], + "1" + ] + ], + "forward:331": [ + [ + 331, + [], + "1" + ] + ], + "forward:450": [ + [ + 450, + [], + "1" + ] + ], + "forward:451": [ + [ + 451, + [], + "1" + ] + ], + "forward:508": [ + [ + 508, + [], + "1" + ] + ], + "forward:509": [ + [ + 509, + [], + "1" + ] + ] + }, + "method": "retained PR3006 reverse-covector engine", + "original_inputs": 632, + "private_inputs": 91 + }, + "extra": { + "gates": 17575, + "identity_rows": { + "dual:1035": [ + [ + 1035, + [], + "1" + ] + ], + "dual:1154": [ + [ + 1154, + [], + "1" + ] + ], + "dual:1155": [ + [ + 1155, + [], + "1" + ] + ], + "dual:1212": [ + [ + 1212, + [], + "1" + ] + ], + "dual:1213": [ + [ + 1213, + [], + "1" + ] + ], + "dual:331": [ + [ + 331, + [], + "1" + ] + ], + "dual:450": [ + [ + 450, + [], + "1" + ] + ], + "dual:451": [ + [ + 451, + [], + "1" + ] + ], + "dual:508": [ + [ + 508, + [], + "1" + ] + ], + "dual:509": [ + [ + 509, + [], + "1" + ] + ], + "forward:1035": [ + [ + 1035, + [], + "1" + ] + ], + "forward:1154": [ + [ + 1154, + [], + "1" + ] + ], + "forward:1155": [ + [ + 1155, + [], + "1" + ] + ], + "forward:1212": [ + [ + 1212, + [], + "1" + ] + ], + "forward:1213": [ + [ + 1213, + [], + "1" + ] + ], + "forward:331": [ + [ + 331, + [], + "1" + ] + ], + "forward:450": [ + [ + 450, + [], + "1" + ] + ], + "forward:451": [ + [ + 451, + [], + "1" + ] + ], + "forward:508": [ + [ + 508, + [], + "1" + ] + ], + "forward:509": [ + [ + 509, + [], + "1" + ] + ] + }, + "method": "retained PR3006 reverse-covector engine", + "original_inputs": 632, + "private_inputs": 91 + } + }, + "prior_coverage": { + "providers": { + "base": { + "backward": { + "331": { + "direct_events": 122, + "direct_events_outside_prior_cone": [ + 13182, + 16068, + 16069, + 17185, + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079, + 22483, + 22574 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "450": { + "direct_events": 19, + "direct_events_outside_prior_cone": [ + 15920, + 22508, + 22599 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "451": { + "direct_events": 19, + "direct_events_outside_prior_cone": [ + 15925, + 22509, + 22600 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "508": { + "direct_events": 20, + "direct_events_outside_prior_cone": [ + 15920, + 17407, + 18275, + 22520, + 22630 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "509": { + "direct_events": 20, + "direct_events_outside_prior_cone": [ + 13209, + 15925, + 15973, + 17404, + 18273, + 22521, + 22631 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + } + }, + "forward": { + "331": { + "direct_events": 122, + "direct_events_outside_prior_cone": [ + 7154, + 7157, + 12470, + 13204, + 13547, + 15969, + 17407, + 18275, + 21445, + 21447, + 21449, + 21451, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22483, + 22574 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "450": { + "direct_events": 19, + "direct_events_outside_prior_cone": [ + 6488, + 12017, + 12019, + 12943, + 12944, + 13206, + 13207, + 14516, + 14517, + 15916, + 15918, + 15920, + 17210, + 17431, + 17432, + 18274, + 18389, + 22508, + 22599 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": false + }, + "451": { + "direct_events": 19, + "direct_events_outside_prior_cone": [ + 6489, + 12021, + 12023, + 12945, + 12946, + 13211, + 13212, + 14522, + 14523, + 15921, + 15923, + 15925, + 17211, + 17429, + 17430, + 18272, + 18388, + 22509, + 22600 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": false + }, + "508": { + "direct_events": 20, + "direct_events_outside_prior_cone": [ + 6541, + 12050, + 13203, + 13204, + 13205, + 13207, + 14513, + 14514, + 15919, + 15920, + 15969, + 15970, + 17222, + 17406, + 17407, + 17431, + 18274, + 18275, + 22520, + 22630 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": false + }, + "509": { + "direct_events": 20, + "direct_events_outside_prior_cone": [ + 6542, + 12051, + 13208, + 13209, + 13210, + 13212, + 14519, + 14520, + 15924, + 15925, + 15971, + 15973, + 17223, + 17404, + 17405, + 17429, + 18272, + 18273, + 22521, + 22631 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": false + } + } + }, + "extra": { + "backward": { + "331": { + "direct_events": 122, + "direct_events_outside_prior_cone": [ + 13182, + 16068, + 16069, + 17185, + 17350, + 17351, + 17352, + 17407, + 18125, + 18275, + 18287, + 19691, + 19692, + 19723, + 19724, + 19725, + 19726, + 19735, + 21382, + 21398, + 21408, + 21425, + 21430, + 21431, + 21432, + 21433, + 21443, + 21444, + 21445, + 21446, + 21447, + 21448, + 21449, + 21450, + 21451, + 21452, + 21453, + 21454, + 21455, + 21462, + 21469, + 22061, + 22063, + 22064, + 22065, + 22066, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22075, + 22076, + 22077, + 22078, + 22079, + 22483, + 22574 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "450": { + "direct_events": 19, + "direct_events_outside_prior_cone": [ + 15920, + 22508, + 22599 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "451": { + "direct_events": 19, + "direct_events_outside_prior_cone": [ + 15925, + 22509, + 22600 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "508": { + "direct_events": 20, + "direct_events_outside_prior_cone": [ + 15920, + 17407, + 18275, + 22520, + 22630 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "509": { + "direct_events": 20, + "direct_events_outside_prior_cone": [ + 13209, + 15925, + 15973, + 17404, + 18273, + 22521, + 22631 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + } + }, + "forward": { + "331": { + "direct_events": 122, + "direct_events_outside_prior_cone": [ + 7154, + 7157, + 12470, + 13204, + 13547, + 15969, + 17407, + 18275, + 21445, + 21447, + 21449, + 21451, + 22067, + 22068, + 22069, + 22070, + 22071, + 22072, + 22073, + 22074, + 22483, + 22574 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": true + }, + "450": { + "direct_events": 19, + "direct_events_outside_prior_cone": [ + 6488, + 12017, + 12019, + 12943, + 12944, + 13206, + 13207, + 14516, + 14517, + 15916, + 15918, + 15920, + 17210, + 17431, + 17432, + 18274, + 18389, + 22508, + 22599 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": false + }, + "451": { + "direct_events": 19, + "direct_events_outside_prior_cone": [ + 6489, + 12021, + 12023, + 12945, + 12946, + 13211, + 13212, + 14522, + 14523, + 15921, + 15923, + 15925, + 17211, + 17429, + 17430, + 18272, + 18388, + 22509, + 22600 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": false + }, + "508": { + "direct_events": 20, + "direct_events_outside_prior_cone": [ + 6541, + 12050, + 13203, + 13204, + 13205, + 13207, + 14513, + 14514, + 15919, + 15920, + 15969, + 15970, + 17222, + 17406, + 17407, + 17431, + 18274, + 18275, + 22520, + 22630 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": false + }, + "509": { + "direct_events": 20, + "direct_events_outside_prior_cone": [ + 6542, + 12051, + 13208, + 13209, + 13210, + 13212, + 14519, + 14520, + 15924, + 15925, + 15971, + 15973, + 17223, + 17404, + 17405, + 17429, + 18272, + 18273, + 22521, + 22631 + ], + "post_wrapper_in_prior_cone": false, + "residual_class_in_prior_cone": false + } + } + } + }, + "status": "Pinned PR3038 receipts inspected; full PR3038 audit not rerun" + }, + "schema_version": 1, + "status": "PASS_GROUP_A_ENTRANCE_NATIVE_INVOICE" +} diff --git a/research/rank7-group-a-entrance-audit/SOURCES.json b/research/rank7-group-a-entrance-audit/SOURCES.json new file mode 100644 index 0000000000..096b95bf59 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/SOURCES.json @@ -0,0 +1,175 @@ +{ + "schema_version": 1, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "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/construction/STAGE-PRICES.json", + "usage": "input", + "git_blob": "b06b369ace05b86377f9f73e13586b62b0b77b98", + "sha256": "dfb7d06724bf95367f3fdb398f4828fc70f803d23030bc0eee0b00541457f546", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/construction/STAGE-PRICES.json" + }, + { + "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/STAGE1-FRAME-EDITS.json", + "usage": "input", + "git_blob": "66525d293bd0e615e469b4c2191281e8cafb8788", + "sha256": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3", + "pin": "head:be191346391661f4d35fc0d1508d0a6029572576:research/rank7-joint-endframes/data/STAGE1-FRAME-EDITS.json" + }, + { + "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/rank7-joint-frame-audit/frames.py", + "usage": "input", + "git_blob": "ae5454f9e25498027884e3a463ec86965d9d4582", + "sha256": "4eb05c9ce716a29735173722a39dda6a92472d44ee304ee43aed81049154e16a", + "pin": "head:34a7003866390618b8e8006dc483e7a37a37903f:research/rank7-joint-frame-audit/frames.py" + }, + { + "path": "research/rank7-joint-frame-audit/lowering.py", + "usage": "input", + "git_blob": "990338a2741a4c5406f5b422977ca496b2fef85b", + "sha256": "fae6946ce453b6971c816e2e0a2d35f259bb181031c2be869e0e6621ab72b8c3", + "pin": "head:34a7003866390618b8e8006dc483e7a37a37903f:research/rank7-joint-frame-audit/lowering.py" + }, + { + "path": "research/rank7-v45-native-cone-seed78/RESULT-base.json", + "usage": "input", + "pin": "head:c7d0d7be056ba77fda1c168641b2bcffb10cf43d:research/rank7-v45-native-cone-seed78/RESULT-base.json", + "git_blob": "9f78923a15b9dc13fbf5d78b7c94a75a3f7083ad", + "sha256": "5cea9b1f2c51b07d62a225100ca2abbcb710943f2d88aaedab0619d214297b40" + }, + { + "path": "research/rank7-v45-native-cone-seed78/RESULT-extra.json", + "usage": "input", + "pin": "head:c7d0d7be056ba77fda1c168641b2bcffb10cf43d:research/rank7-v45-native-cone-seed78/RESULT-extra.json", + "git_blob": "a2a293d5157846a80068bace94ce26e647b54a80", + "sha256": "86b999e314f5d66ce7db7171b1cda9e78c2e5b69bd7f51bee189cac963c3b958" + }, + { + "path": "research/rank7-v45-native-endpoint/endpoints.py", + "usage": "input", + "git_blob": "79c2495d2e0208ecf4d6f0a53f5f108a54217a47", + "sha256": "d5e8b8bf640cc6283141065995ade7f475b7ab3116ea01ce682765b5f84405c0", + "pin": "head:1432a43a331ec857f45093a1d6e16acdbe9849e2:research/rank7-v45-native-endpoint/endpoints.py" + }, + { + "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-a-entrance-audit/TASK.json b/research/rank7-group-a-entrance-audit/TASK.json new file mode 100644 index 0000000000..c2aa97e266 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/TASK.json @@ -0,0 +1,150 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "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 mixed-entrance group A: exact emitted wrapper pairs, native residuals and climbs, parent/joint/single331 comparison, and native-width-to-complete-recursive-invoice binding.", + "scope_change_reason": "PR2993 already covers local group profiles, and final overlap review found PR3038 already checks both group-A residual classes inside its V45 cone. The contribution is therefore the complete direct group-A post-wrapper/endpoints boundary and the native-width-to-actual-owner-invoice join. Native residual identities are explicitly corroborative; no first-proof claim remains.", + "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 A and keeps the remaining physical and outer obligations explicit.", + "budget_minutes": 60, + "stop_rule": "Finish this finite native/interface and invoice audit. No new lowering census, dependent construction, supplier admission or selected-frontier change. Stop at source mismatch, failed exact identity or unresolved full admission.", + "outcome": "partial", + "evidence": "RESULT.json: native classes corroborated; exact source-to-emission boundary for five helper/private pairs, parent/joint/single331 comparison,40 normalized endpoint rows via retained checker,271728 roles/149184 bins/3330 group placements, exact prior-coverage delta, seven behavioral groups.", + "author": "commdata2338", + "ai_assistance": "Prepared for commdata2338 with substantial OpenAI Codex (GPT-6 Astra) assistance in analysis, implementation, checking and writing. No independent human or formal-kernel review is claimed.", + "open_questions": [ + { + "question": "Can the checked group-A direct paths and endpoints be joined to the complete native dependency closure of their private cleanup?", + "why_it_matters": "Direct path equality and normalized private identity do not independently validate every peer native warp, frame and physical implementation used by cleanup.", + "first_step": "Start with the 55/4/4/5/5 private-touch counts for331/450/451/508/509 in RESULT.json 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 and66813 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 its 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": 2993, + "head": "34a7003866390618b8e8006dc483e7a37a37903f", + "scope": "All-group local frame invoices and V45 subsets; its frame engine is explicitly reused." + }, + { + "pr": 3006, + "head": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "scope": "Zero-entrance helper249 native path and endpoint rows; generic covector engine reused for five different helper/private pairs." + }, + { + "pr": 3008, + "head": "948a997eba1aaf13d04e2b52edf70404860d19dc", + "scope": "Direct helper249/private953 event binding; methodology predecessor, not imported." + }, + { + "pr": 3014, + "head": "16e8db5656b4fea487a2212395f39707bf134f7a", + "scope": "V45 frozen-parent allocation obstruction; no repetition of that experiment." + }, + { + "pr": 2987, + "head": "02c3047a1e78e6e35e7573c12434ba26f6f9bd96", + "scope": "Separate final allocation geometry/Hall audit." + }, + { + "pr": 3079, + "head": "8aee45e6a918c99cdca98431c3e791d2b3fd4206", + "scope": "Replays the published T74 aggregate arithmetic (idle profile plus 666 local calls, rank mass 4816512) without owner chronology or native widths." + }, + { + "pr": 3038, + "head": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d", + "scope": "Already checks wrapper0:261 both orientations and115:261 backward in the V45 cone; conjugation implies forward. No group-A post wrapper is in its cone. Exact reported coverage is inspected from pinned receipts without a full replay." + } + ], + "dependency_heads": { + "2979": "be191346391661f4d35fc0d1508d0a6029572576", + "2993": "34a7003866390618b8e8006dc483e7a37a37903f", + "3006": "1432a43a331ec857f45093a1d6e16acdbe9849e2", + "3038": "c7d0d7be056ba77fda1c168641b2bcffb10cf43d" + }, + "selection": { + "track": "independent-verification", + "task_id": "independent-moment", + "scope_key": "5e0f415b25b13c102653", + "selector_seed": "25ae47a00732f7308332aa1beb4bf647", + "method": "Handoff-first; refine PR2993 native/physical handoff to group-A boundary and invoice join after #1166/#2612 inspection. Final review explicitly reconciles the stronger PR3038 coverage.", + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2612", + "canonical_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-19001817" + }, + "unchecked_obligations": [ + "Complete native/warp dependency closure and physical realization of peers", + "Zero return of the other86 private buffers", + "Physical stock adequacy, movement, prefix/precision/tape", + "Comparable legal whole-supplier allocations for the isolated group-A parent/joint/single331 words", + "Complex root/packing cap, bit cap, outer release and inherited all-size/compiler/analytic hypotheses" + ], + "result_kind": "finite native/interface audit; no defect found in stated scope", + "refresh_checkpoint": { + "at_utc": "2026-10-17T17:52:08Z", + "canonical_main": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "priority_revision": 6, + "changes": "No upstream commit or guidance/selected-record changes; preserve all scientific input pins." + }, + "overlap": { + "open_prs_fetched_at": "2026-10-17T17:49:11.608413+00:00", + "open_pr_count": 253, + "discussions_fetched_at": "2026-10-17T17:52:04.322463+00:00", + "discussion_records": 2017, + "complete_pagination": true, + "limitation": "Offline shared snapshots are not atomic and omit unpublished work and arbitrary diffs.", + "nearest_new_activity": "PR3204 idle-axis obstruction and PR3202/PR3044 R2 native cleanup concern different boundaries. Concurrent #2612 private-free and V45 control audits are complementary; consult them before further endpoint or control work.", + "board_read_at_utc": "2026-10-17T17:53:00Z", + "readable_board_snapshot": "2026-10-17T17:39:04.580509+00:00" + }, + "coverage_correction": "Initial orientation omitted PR3038 from the existing-check inventory. Corrected before submission; no residual-identity novelty claim. This narrows the claimed delta without changing the object or launching a new experiment." +} diff --git a/research/rank7-group-a-entrance-audit/VERIFY.json b/research/rank7-group-a-entrance-audit/VERIFY.json new file mode 100644 index 0000000000..0f991c5dfe --- /dev/null +++ b/research/rank7-group-a-entrance-audit/VERIFY.json @@ -0,0 +1,52 @@ +{ + "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/construction/STAGE-PRICES.json", + "research/rank7-joint-endframes/data/PARENT-base.json.gz", + "research/rank7-joint-endframes/data/PARENT-extra.json.gz", + "research/rank7-joint-endframes/data/STAGE1-FRAME-EDITS.json", + "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/rank7-joint-frame-audit/frames.py", + "research/rank7-joint-frame-audit/lowering.py", + "research/rank7-v45-native-cone-seed78/RESULT-base.json", + "research/rank7-v45-native-cone-seed78/RESULT-extra.json", + "research/rank7-v45-native-endpoint/endpoints.py", + "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": 120, + "checks": "Exact source-bound native mixed-entrance identities, direct emitted scalar/climb clocks, retained local/covector checks, complete recursive invoice and semantic controls." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/test_verify.py", + "-v" + ], + "timeout_seconds": 120, + "checks": "Seven behavioral groups: native entrance/phase, wrapper/lifetime, scalar chronology/cleanup, owner geometry, actual-width mismatch, private endpoint corruption and source/event-receipt corruption/duplicate JSON." + } + ] +} diff --git a/research/rank7-group-a-entrance-audit/common.py b/research/rank7-group-a-entrance-audit/common.py new file mode 100644 index 0000000000..00842952d8 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/common.py @@ -0,0 +1,82 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Bounded source loading for the mixed-entrance 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 = (331, 450, 451, 508, 509) +W = [256, 128, 64, 38, 20, 10, 1] +LIMIT = 64 * 1024 * 1024 + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def unique(pairs): + result = dict(pairs) + require(len(result) == len(pairs), "duplicate JSON key") + return result + + +def decode(raw, compressed=False): + if compressed: + with gzip.GzipFile(fileobj=io.BytesIO(raw)) as stream: + raw = stream.read(LIMIT + 1) + require(len(raw) <= LIMIT, "decoded input capacity") + return json.loads(raw, object_pairs_hook=unique) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def encoded(value): + return (json.dumps(value, sort_keys=True, separators=(",", ":")) + "\n").encode() + + +def authenticate(root=ROOT): + rows = decode((PACKAGE / "SOURCES.json").read_bytes())["files"] + pins = {r["path"]: r["sha256"] for r in rows if r["usage"] == "input"} + declared = set(decode((PACKAGE / "VERIFY.json").read_bytes())["inputs"]) + require(set(pins) == declared and len(pins) <= 24, "exact live input inventory") + blobs = {} + for name, sha in pins.items(): + path = root / name + require(path.stat().st_size <= LIMIT, "raw input capacity") + raw = path.read_bytes() + require(digest(raw) == sha, "source SHA256: " + name) + blobs[name] = raw + return blobs + + +def data(blobs, relative): + return decode(blobs[SOURCE + relative], relative.endswith(".gz")) + + +def module(raw, name): + """Compile authenticated bytes directly, without consulting a .pyc file.""" + result = types.ModuleType(name) + sys.modules[name] = result + exec(compile(raw, name, "exec"), result.__dict__) + return result + + +def reject(action, reason): + try: + action() + except (ValueError, AssertionError) as error: + return str(error) + raise ValueError("control accepted: " + reason) diff --git a/research/rank7-group-a-entrance-audit/invoice.py b/research/rank7-group-a-entrance-audit/invoice.py new file mode 100644 index 0000000000..51fe2cffb6 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/invoice.py @@ -0,0 +1,155 @@ +# 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. +""" + +from collections import Counter, defaultdict + +from common import HELPERS, data, digest, encoded, require + + +def widths(word): + live = [r for r in range(224, 704) if r not in word["removed"]] + require(len(live) == 408, "408 helper names") + result = [] + for h in live: + end_rank = len(word["helper_final"][str(h)]) if str(h) in word["helper_final"] else 9 + start = word["start_extra"].get(str(h), []) + result.append(end_rank - len(start)) + require(all(type(r) is int and 0 < r <= 9 for r in result), "positive native widths") + return live, result + + +def windows(template, order): + ranks = {} + for item in template["idle_children"]: + c, r = item["child"], item["rank"] + require(c not in ranks or ranks[c] == r, "unique source capacity") + ranks[c] = r + require(set(ranks) == set(range(18)), "18 idle children") + pairs = {e["stage"]: e["pair"] for e in template["recipe"] if e["kind"] == "local"} + blocks, stage = defaultdict(list), None + for event in template["execution_schedule"]: + kind = event["kind"] + if kind in ("bank_padding_cover_sweep", "translate_every_live_family"): + continue + if kind == "local_cover_sweep": + stage = event["stage"] + require(stage is not None, "initial local source event") + blocks[stage].append(event) + progress, last, result = [0] * 74, {}, {} + for time, (stage, replica) in enumerate(order): + require(0 <= replica < 74 and progress[replica] == stage, "source chronology") + progress[replica] += 1 + for event in blocks[stage]: + kind = event["kind"] + if kind == "local_cover_sweep": + last[replica, pairs[stage]] = time + elif kind == "bridge": + for pair in (event["src"], event["dst"]): + last[replica, pair] = time + elif kind == "idle_cover_sweep": + for child in event["child_indices"]: + if child not in ranks: + continue # Template padding children carry no helper slots. + require((replica, child) not in result, "one idle deadline") + result[replica, child] = (ranks[child], last.get((replica, event["pair"]), -1), time) + else: + require(kind in ("terminal", "terminal_Y_translations"), "known event") + require(progress == [9] * 74 and len(result) == 74 * 18, "all source windows") + return result + + +def recount(fill, order, dispatch, template, plan, words, local): + require(len(order) == len(dispatch) == 666 and [x[:2] for x in dispatch] == order, + "complete dispatch binding") + require(fill["columns"] == ["time", "helper", "owner_replica", "child", "port", "offset"], + "literal fill columns") + require(not fill["dispatch_overrides"], "no hidden provider override") + bounds = windows(template, order) + for event in template["execution_schedule"]: + if event["kind"] != "idle_cover_sweep": + continue + require(len(event["child_indices"]) == 2, "two ordered source sides") + for side, child in enumerate(event["child_indices"]): + if (0, child) in bounds: + require(plan["pairs"][str(child)] == event["pair"] and + plan["sides"][str(child)] == side, "source child family binding") + inventories = {tag: widths(word) for tag, word in words.items()} + names, ws = inventories["base"] + require(inventories["extra"] == (names, ws), "provider width equality") + tags = {"gauge44": "base", "extra": "extra"} + require(len(fill["rows"]) == 666 * 408, "all 271728 roles") + roles, families, bins = set(), set(), defaultdict(list) + group_rows = [] + for row in fill["rows"]: + require(len(row) == 6 and all(type(x) is int for x in row), "integer role record") + t, h, owner, child, port, offset = row + require(0 <= t < 666 and 0 <= h < 408 and 0 <= port < 112, "role domain") + require((t, h) not in roles, "unique helper role") + roles.add((t, h)) + require((owner, child) in bounds, "existing source bin") + cap, begin, end = bounds[owner, child] + require(begin < t <= end, "source availability") + family = (t, owner, 2 * plan["pairs"][str(child)] + plan["sides"][str(child)], port) + require(family not in families, "distinct per-call physical families") + families.add(family) + tag = tags[dispatch[t][2]] + width = inventories[tag][1][h] + require(0 <= offset and offset + width <= cap, "capacity at literal offset") + bins[owner, child, port].append((offset, width)) + if names[h] in HELPERS: + group_rows.append([*row, names[h], width]) + idle, occupied = Counter(), 0 + for (owner, child), (capacity, _, _) in sorted(bounds.items()): + for port in range(112): + cursor = 0 + for offset, width in sorted(bins.get((owner, child, port), [])): + require(offset == cursor, "nonoverlapping compact prefix") + cursor += width + occupied += cursor + if cursor < capacity: + idle[capacity - cursor] += 1 + complete = Counter(idle) + calls = Counter(tags[row[2]] for row in dispatch) + for tag, n in calls.items(): + complete.update({int(r): n * c for r, c in local[tag].items()}) + require(len(roles) == 666 * 408 and len(group_rows) == 666 * 5, "complete group coverage") + require(occupied == sum(ws) * 666, "used width conservation") + return {"calls": dict(calls), "roles": len(roles), "bins": 74 * 18 * 112, + "group_placements": len(group_rows), "group_rows_sha256": digest(encoded(group_rows)), + "group_widths": {str(h): ws[names.index(h)] for h in HELPERS}, + "width_inventory": dict(sorted(Counter(ws).items())), "width_mass": sum(ws), + "idle": dict(sorted(idle.items())), "complete": dict(sorted(complete.items())), + "rank_mass": sum(r * n for r, n in complete.items())} + + +def audit(blobs, words, profiles): + result = recount(data(blobs, "allocation/FILL.json.gz"), data(blobs, "allocation/ORDER.json"), + data(blobs, "allocation/DISPATCH.json"), data(blobs, "allocation/vendor/TEMPLATE.json.gz"), + data(blobs, "allocation/vendor/PLAN.json.gz"), words, profiles) + claimed = {int(r): n for r, n in data(blobs, "allocation/PROFILE.json").items()} + require(result["complete"] == claimed, "complete independently recounted invoice") + claim = data(blobs, "CLAIM.json") + require(result["group_widths"] == {"331": 7, "450": 6, "451": 6, "508": 6, "509": 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-a-entrance-audit/native.py b/research/rank7-group-a-entrance-audit/native.py new file mode 100644 index 0000000000..17f04b2ed3 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/native.py @@ -0,0 +1,275 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Bind emitted mixed-entrance wrappers, then check them with the retained exact kernel. + +Recipe generation follows DreamingOfClouds/PR458's bw_adapters.py. It is a +producer, not independent evidence. The separately implemented Gaussian kernel +is Sagar Thakrar's retained verifier; neither predecessor is new here. +""" + +import copy +import os +import subprocess +import sys +from common import COMPILER, ENGINE, HELPERS, KERNEL, W, data, decode, digest +from common import 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_a_source_compiler") + kernel = module(blobs[KERNEL], "group_a_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["450"]["forward"]["recipe_key"] + cold = bindings["331"]["forward"]["recipe_key"] + rec = adapters["recipes"][entering] + controls = {} + controls["omitted_entrance"] = reject(lambda: check_recipe(kernel, rec, [], W), "entrance") + bad = copy.deepcopy(rec); bad["left"]["phase"] = (bad["left"]["phase"] + 1) % 4 + controls["phase"] = reject(lambda: check_recipe(kernel, bad, [30], W), "phase") + bad = copy.deepcopy(rec); bad["right"] = adapters["recipes"][cold]["right"] + controls["cold_wrapper_alias"] = reject(lambda: check_recipe(kernel, bad, [30], W), "cold alias") + # A same-rank wrong entrance tests operator semantics, rather than metadata alone. + controls["wrong_entrance_line"] = reject(lambda: check_recipe(kernel, rec, [10], W), "wrong line") + parent = data(blobs, f"data/PARENT-{tag}.json.gz") + comparison = {} + for h in (331, 450): + entrance = parent["start_extra"].get(str(h), []) + terminal = parent["helper_final"][str(h)] + require(len(terminal) == 8, "rank-eight parent terminal") + op = compiler.canonical_frame(9, tuple(entrance)).adjoint().then( + compiler.canonical_frame(9, tuple(terminal))) + candidate, _ = compiler.lower_child(op) + comparison[str(h)] = {"entrance": entrance, "parent_terminal": terminal, + "parent": check_recipe(kernel, decode(encoded(candidate)), entrance, terminal), + "joint_recipe_key": cold if h == 331 else entering} + require(all(parent["start_extra"][str(h)] == [30] and + parent["helper_final"][str(h)] == comparison["450"]["parent_terminal"] + for h in HELPERS[1:]), "four common entering parent pairs") + 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-a-entrance-audit/test_verify.py b/research/rank7-group-a-entrance-audit/test_verify.py new file mode 100644 index 0000000000..5d7fd5d140 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/test_verify.py @@ -0,0 +1,161 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Semantic failures at the actual group-A wrapper and owner boundaries.""" + +import copy +import tempfile +import unittest +from pathlib import Path + +import invoice +import native +import verify +from common import KERNEL, PACKAGE, W, 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_a_test_kernel") + cls.tmp = tempfile.TemporaryDirectory(prefix="group-a-tests-") + cls.canonical, cls.programs, _ = native.generate(cls.blobs, "base", Path(cls.tmp.name)) + + @classmethod + def tearDownClass(cls): + cls.tmp.cleanup() + + def bind(self, stream, h=450, 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["115:261"]["recipe"] + native.check_recipe(self.kernel, rec, [30], W) + with self.assertRaisesRegex(ValueError, "phase-exact"): + native.check_recipe(self.kernel, rec, [10], W) + wrong = copy.deepcopy(rec) + wrong["right"] = recipes["0:261"]["recipe"]["right"] + with self.assertRaisesRegex(ValueError, "phase-exact"): + native.check_recipe(self.kernel, wrong, [30], 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, [30], 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"]["450"]["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"]["450"]["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"]["450"] + # Using terminal rank seven as the helper width breaks the actual packing. + with self.assertRaisesRegex(ValueError, "capacity|compact prefix"): + self.recount(words=words) + + def test_private_cleanup_semantics(self): + engine = module(self.blobs[verify.ENDPOINTS], "group_a_test_covectors") + word = copy.deepcopy(self.word) + original = word["cleanup"][178] + self.assertEqual(original[:5], ["add", 1154, 934, 1, 1]) + del word["cleanup"][178] + gates = engine.program(word) + live = set(range(704)) - set(word["removed"]) + private = {704 + int(h) for h in word["helper_final"]} + rows = [engine.endpoint(gates, 1154, dual, live, private) for dual in (False, True)] + self.assertTrue(any(row != [(1154, (), "1")] for row in rows)) + + 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-a-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-a-entrance-audit/verify.py b/research/rank7-group-a-entrance-audit/verify.py new file mode 100644 index 0000000000..0f591647c6 --- /dev/null +++ b/research/rank7-group-a-entrance-audit/verify.py @@ -0,0 +1,142 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Mixed-entrance group A native boundary, control and completed invoice.""" + +import json +import sys +import tempfile +from pathlib import Path + +import invoice +import native +from common import HELPERS, PACKAGE, authenticate, data, decode, module, require + +FRAMES = "research/rank7-joint-frame-audit/frames.py" +LOWERING = "research/rank7-joint-frame-audit/lowering.py" +ENDPOINTS = "research/rank7-v45-native-endpoint/endpoints.py" +PRIOR = "research/rank7-v45-native-cone-seed78/RESULT-" + + +def local_comparison(blobs): + """Explicit reuse of Nick Petalas's independent PR2993 frame checker.""" + frames = module(blobs[FRAMES], "frames") + lower = module(blobs[LOWERING], "group_a_retained_lowering") + edits = data(blobs, "data/STAGE1-FRAME-EDITS.json") + prices = data(blobs, "construction/STAGE-PRICES.json") + weights = {int(r): n for r, n in prices["weights"]["c"].items()} + guide = prices["weights"]["break_even"] + result, final_profiles = {}, {} + for tag in ("base", "extra"): + parent, final = (data(blobs, f"data/{kind}-{tag}.json.gz") for kind in ("PARENT", "WORD")) + baseline = frames.ledger(parent) + variants = {"parent": parent, "joint": lower.apply_frames(parent, edits, ["A"]), + "single331": lower.apply_frames(parent, edits, ["A"], endpoints=[331])} + rows = {} + for name, word in variants.items(): + record = frames.ledger(word, check_report=(name == "parent")) + delta = lower.difference(record["profile"], baseline["profile"]) + count = {"parent": 0, "joint": 5, "single331": 1}[name] + price = sum(weights[r] * n for r, n in delta.items()) + rows[name] = {"profile": record["profile"], "delta": delta, + "width_inventory": record["widths"], "surrogate_price": price, + "guide_margin": -price - count * guide, + "cleanup": frames.cleanup_namespace(word)} + require(rows["joint"]["delta"] == {1: -1, 2: 20, 3: -14, 4: 2, 5: -2}, "joint group delta") + require(rows["single331"]["delta"] == {1: 3, 2: 20, 3: -14, 4: 2, 5: -2}, "single control delta") + require(rows["joint"]["guide_margin"] == 42541 and rows["single331"]["guide_margin"] == -58943, + "source surrogate comparison") + final_profiles[tag] = frames.ledger(final)["profile"] + rows["final_cleanup"] = frames.cleanup_namespace(final) + result[tag] = rows + return result, final_profiles + + +def endpoints(blobs, words): + """Apply the credited generic reverse-covector engine to these ten outputs.""" + engine = module(blobs[ENDPOINTS], "group_a_retained_covectors") + result = {} + for tag, word in words.items(): + gates = engine.program(word) + live = set(range(704)) - set(word["removed"]) + buffers = {704 + int(h) for h in word["helper_final"]} + rows = {} + for dual in (False, True): + for h in HELPERS: + for output in (h, h + 704): + row = engine.endpoint(gates, output, dual, live, buffers) + require(row == [(output, (), "1")], "normalized group/private identity") + rows[f'{"dual" if dual else "forward"}:{output}'] = row + result[tag] = {"gates": len(gates), "original_inputs": len(live), "private_inputs": len(buffers), + "identity_rows": rows, "method": "retained PR3006 reverse-covector engine"} + return result + + +def prior_coverage(blobs, native_results): + """Inventory reported PR3038 coverage; do not call it a fresh replay.""" + result = {} + for tag, current in native_results.items(): + prior = decode(blobs[PRIOR + tag + ".json"]) + require(prior["scientific_head"] == "be191346391661f4d35fc0d1508d0a6029572576" + and prior["provider"] == tag, "PR3038 coverage source") + rows = {} + for orientation, previous in prior["orientations"].items(): + covered = set(previous["event_indices"]) + classes = [a["class"] for a in previous["native"]["associations"]] + helpers = {} + for h, binding in current["bindings"].items(): + row = binding[orientation] + e, u = map(int, row["recipe_key"].split(":")) + selected = set(row["direct_scalar_indices"]) + selected.update(c["index"] for c in row["climbs"]) + selected.update(i for i, _ in row["wrappers"] + row["buffers"]) + helpers[h] = { + "residual_class_in_prior_cone": ["wrapper", e, u] in classes, + "post_wrapper_in_prior_cone": row["wrappers"][1][0] in covered, + "direct_events": len(selected), + "direct_events_outside_prior_cone": sorted(selected - covered)} + rows[orientation] = helpers + result[tag] = rows + return {"status": "Pinned PR3038 receipts inspected; full PR3038 audit not rerun", + "providers": result} + + +def compute(): + blobs = authenticate() + local, profiles = local_comparison(blobs) + words = {tag: data(blobs, f"data/WORD-{tag}.json.gz") for tag in ("base", "extra")} + native_results = {} + for tag in words: + with tempfile.TemporaryDirectory(prefix="group-a-native-") as work: + native_results[tag] = native.audit(blobs, tag, Path(work)) + result = {"schema_version": 1, "status": "PASS_GROUP_A_ENTRANCE_NATIVE_INVOICE", + "local_comparison": local, "native": native_results, + "normalized_endpoints": endpoints(blobs, words), + "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 + result["prior_coverage"] = prior_coverage(blobs, native_results) + 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") + print(result["status"] + " providers=2 helpers=5 residual_widths=7,6,6,6,6 roles=271728 no_new_kappa") + + +if __name__ == "__main__": + main()