diff --git a/research/staged544-native-quadratic-audit/.gitattributes b/research/staged544-native-quadratic-audit/.gitattributes new file mode 100644 index 0000000000..173ce7b91c --- /dev/null +++ b/research/staged544-native-quadratic-audit/.gitattributes @@ -0,0 +1,4 @@ +frozen/* -text +vendor/* -text +NOTICE-PR3945.md -text +SOURCE-CREDITS.md -text diff --git a/research/staged544-native-quadratic-audit/.gitignore b/research/staged544-native-quadratic-audit/.gitignore new file mode 100644 index 0000000000..7a60b85e14 --- /dev/null +++ b/research/staged544-native-quadratic-audit/.gitignore @@ -0,0 +1,2 @@ +__pycache__/ +*.pyc diff --git a/research/staged544-native-quadratic-audit/LEDGER.json b/research/staged544-native-quadratic-audit/LEDGER.json new file mode 100644 index 0000000000..97e4b38ded --- /dev/null +++ b/research/staged544-native-quadratic-audit/LEDGER.json @@ -0,0 +1,80 @@ +{ + "status": "LOCAL_NATIVE_PHASE_INTERFACES_ONLY", + "proved": [ + { + "item": "Changed cold terminal residual widths", + "old": 4, + "new": 5, + "helpers_per_provider": 26, + "evidence": "Exact source-derived coverage and all512column signed operator equality for every unique old/new interface." + }, + { + "item": "Actual changed native warp interfaces", + "per_provider": 5, + "binary_maps": 4, + "paid_recursive_rank": 0, + "evidence": "Both directions, old/new frames, all512columns; source lifting phase included." + }, + { + "item": "Record-only index shifts", + "per_provider": 47, + "evidence": "G,U,E,register unchanged; chronological insertion index differs." + }, + { + "item": "Clifford lift inverse correction", + "witness_G": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "character_mask": 256, + "flipped_columns": 256, + "evidence": "K_(G inverse) K_G = Z_256; correct adjoint recipe verified." + }, + { + "item": "Computational coverage", + "unique_interface_classes": 40, + "source_occurrences": 144, + "basis_columns": 20480, + "note": "Deduplicated byte-identical descriptors with exact source coverage map; all output coefficients checked, no random probes." + } + ], + "inherited_not_reproved": [ + { + "item": "Complete paid profile / literal owner capacity", + "source": "PR3969 6ff67539f1131a287eb9a9a98bf1e94a02eecba7", + "status": "Independent predecessor audit; not recomputed here" + }, + { + "item": "Arbitrary dirty whole-word free-operator cleanup", + "source": "PR3945 andPR3969 pinned words/receipts", + "status": "Local all-column equality composes linearly; whole723inputfreealgebra replay not repeated" + } + ], + "unknown_or_outside_scope": [ + { + "item": "All changed scalar frame-transition recipe classes and entire emitted program", + "cost": "unknown in this audit" + }, + { + "item": "Physical hosting/allocation/owner chronology beyond inherited finite owner audit", + "cost": "unknown inherited full model obligation" + }, + { + "item": "Uniform coefficient height, precision, stock and tape costs", + "cost": "unknown; no zero tariff assigned to monomial wrappers or Z correction" + }, + { + "item": "All-size compiler, common mutable labels, outer/supplier, analytic and BIT H1-H5 admission", + "cost": "inherited conditional obligations, not admitted by this finite certificate" + } + ], + "selected_frontier_changed": false, + "new_kappa_claim": false +} diff --git a/research/staged544-native-quadratic-audit/NOTICE-PR3945.md b/research/staged544-native-quadratic-audit/NOTICE-PR3945.md new file mode 100644 index 0000000000..6dcffa5dfb --- /dev/null +++ b/research/staged544-native-quadratic-audit/NOTICE-PR3945.md @@ -0,0 +1,20 @@ +# Attribution and scope + +New terminal-width/frame construction, idle-gap absorption proof, source-guarded recipe, independent finite checks and integration: Dugongue with substantial OpenAI Codex assistance, including three parallel Codex agents. Apache-2.0. AI implementation separation is not independent human review. + +Retain the following predecessor credit and all native/vendor notices: + +- dataisfire, PR3734: actual staged544 supplier and retained full source closure. zxv, PR3682: staged pair. Ross Richardson, PR3605: staged entrance, cleanup and residual checks. +- Erwan Secousses / ChaloupeMusic, PR3815, with retained PR3638 lineage: attained T360 owner clock and fill. The new allocation changes widths and offsets on that placement; it does not invent the source clock. +- hexapode, PR3802 and PR3875: previous complete endpoint combination and refinement. Dugongue, PR3857: prior general proof/evaluator work; PR3929: transported-frame compiler and concrete nonimproving example. +- Sagar Thakrar, PR3687: audit_core.py, retained byte for byte. Its header explicitly credits Arham Tahir's coupled-carrier audit, which it reimplements. roger-sato, PR3693: whole-word audit adapter in the inherited closure. Retained exact rational-price evaluator and source notices are unchanged. +- Jeremy Kothe: frame/preload machinery and PR2833 native rewrite; Lyy-iiis, PR2857; Dugongue, PR2863; philippeVV, PR2853, and all retained provider, owner, native/admission and outer contributors. +- Cinna Davis (@1337isnot1337), PR2226, with OpenAI Codex assistance: native exact Clifford/operator machinery. icekylinx, PR514/433, and retained native ancestry. +- DreamingOfClouds with Claude Opus 5.5: inherited wrapper/outer machinery; chafreaky, PR458, and its retained lineage. +- Tekalign (@tekuuu): sparse native acceleration; retain SPARSE-NOTICE, SPARSE-PROOF, Rohan Arun and all earlier authors/PRs listed by those files. The accelerator changes replay representation, not the certified word. + +The original contributor names already present in upstream sources are attribution. They are not new identification of the submitting GitHub account. All original licenses and source headers remain in place. No broad mathematical novelty, independent human approval, unconditional all-size multiplication bound or fresh Lean/kernel certification is claimed. + +Adjacent reviews were compared and credited: Chris R / Clear1nsight PR3883/3936, with substantial OpenAI Codex assistance, supplies the completed T385 execution/COPY-contract audit precedent; retain its ai-nanachi PR3647, Sagar Thakrar PR3700 and PR2809 physical-caller lineage. These are scoped comparison sources, not a new admission receipt for our changed T360 words. + +Also compare and credit Chris R / Clear1nsight PR3941 for its distinct neutral-first enumeration/middle-cut reduction, following PR3886/3734, Jeremy Kothe PR2957/2979 and Dugongue PR3863/ranked-pair/MathProof predecessors. Rohan Arun's PR3939 bit-pooling draft and its explicitly conditional PR3934 stack are acknowledged as higher draft endpoints on a different route; their data and extra assumptions are not imported into this supplier. diff --git a/research/staged544-native-quadratic-audit/PROOF.md b/research/staged544-native-quadratic-audit/PROOF.md new file mode 100644 index 0000000000..a194ca7dbc --- /dev/null +++ b/research/staged544-native-quadratic-audit/PROOF.md @@ -0,0 +1,132 @@ +# Exact quadratic-phase interface certificate + +Prepared by Chris R / Clear1nsight with substantial OpenAI Codex assistance. +Apache-2.0. This is an independent finite audit of Dugongue's PR3945, not a +claim that its native checker is wrong or a new multiplication theorem. + +## Domain and conventions + +The logical coordinate space has dimension 512, indexed by `x in F_2^9`. +Write `X^u |x> = |x+u>` and `Z^v |x> = (-1)^(v dot x)|x>`. +Products act right to left. Every scalar coefficient below is an exact Gaussian +integer divided by an explicit power of two. The verifier uses Python integers, +not floating point, sampled states, the predecessor tableau compiler, or numpy. + +For invertible binary columns G, set Q_G = I + G^(-T)G^(-1) over F_2. +Its specified Z4 quadratic refinement is + + q_G(y) = sum_i (Q_G)_ii y_i + 2 sum_(i = i^(q_G(Gx)) |Gx>. + +The source's canonical frame T_U is K_B C_[r] K_B^adjoint, where B completes +the given ordered basis U by successive coordinate vectors, r=dim U, and +C_j=((1+i)I+(1-i)X_j)/2. Its inverse conjugates the Gaussian coefficients. +The local warp is T_E K_G^(sign) T_U^adjoint. The cold terminal residual is +T_E, since its entrance U is empty. These definitions preserve global phase. + +The new evaluator finds inverse columns by exhaustive permutation inversion, +constructs the quadratic form from their binary dot products, and propagates +sparse Gaussian numerator dictionaries one coordinate at a time. It independently +decodes a serialized monomial's binary rows, translation, Z4 linear coefficients, +symmetric quadratic rows and global phase. A compiler recipe is R, C_[rank], L +in chronological order. Reference recipes are generated by the frozen source +compiler; the verifier never imports that compiler or its dependent checkers. +A shared mathematical convention is unavoidable and is stated above; no claim +of independently deriving the construction's physical model is made. + +## Complete finite interface equality + +Both frozen providers have exactly 26 helper terminal extensions from width 4 +to width 5; every one has the same empty entrance in old and new words. Their +first helper is 277: + + old [388,75,41,26] + new [388,74,40,26,1] + +Exactly 5 of the 72 warp records per provider change their entrance/exit frame; +the binary map and register identity are unchanged. Another 47 records change +only their chronological index. We compare both signs of each genuinely changed +warp, at old and new interfaces. We do not confuse these 47 index shifts with +new native operators. + +The 144 source occurrences deduplicate to 40 exact descriptors: 24 residuals +and 16 signed warp interfaces. Each descriptor includes the actual ordered +frames and, for a warp, its binary columns and sign. Coverage is reconstructed +from the four frozen words by verify.py, independently of the recipe generator. +Every descriptor is evaluated on all 512 input basis columns, comparing every +output coefficient after exact dyadic normalization: 20,480 column equalities. +RESULT.json commits a digest of the normalized complete action of each class. + +Equality on a basis proves equality for arbitrary complex input, hence for any +arbitrary dirty coordinate state at this local interface, including relative +and global phases. It also tensors with untouched registers. This does not +by itself reprove the whole emitted program's chronological composition, +all dirty-buffer restoration, or the supplier contract. The old terminal +recipes are calibration controls; they are not proposed substitutes for the +promoted width-5 interfaces. All signed warps have zero recursive rank; the +residual recipe ranks are exactly 4 and 5 respectively. Zero recursive rank +does not mean zero physical or uniform precision cost. + +## Why the binary inverse is insufficient: the lift cocycle + +The binary symplectic action of K_G on Pauli labels (x,z) is + + M(G) = [[G, 0], [G + G^(-T), G^(-T)]]. + +Direct multiplication gives M(H)M(G)=M(HG). This does not determine the signed +lift. The exact phase difference + + d_(G,H)(x) = q_G(Gx) + q_H(HGx) - q_(HG)(HGx) mod 4 + +is an even linear character, 2 ell dot x. One way to see this is to use +q_Q(a+b)-q_Q(a)-q_Q(b)=2 a^T Q b mod 4, noting that all binary operations +inside q use XOR. The composed quadratic polarizations cancel under the +identity for M. The parity cancels as well; since d(0)=0, the remaining even +additive function is exactly a binary linear character. Consequently + + K_H K_G = K_(HG) Z_ell. + +The certificate calculates ell from the nine coordinate inputs and then +checks this identity on every one of the 512 inputs for each ordered pair of +the four actual changed binary maps. These 16 algebraic pair controls are not +asserted to occur adjacently in either word. + +For an actual map in the changed interfaces, + + G = [1,2,8,32,44,128,59,66,489], + G^(-1) = [1,2,28,4,79,8,130,32,431], + +our exact certificate finds + + K_(G^(-1)) K_G = Z_256. + +This is a relative sign on exactly 256 of the 512 basis coordinates, not a +removable global phase. In particular the input x=256 is sent to its negative +by this binary-identity product. The phase-correct inverse is + + K_G^adjoint = Z_256 K_(G^(-1)). + +The source uses the correct adjoint; it passes the signed audit. This witness +rejects the tempting implementation shortcut of substituting the canonical +lift of the binary inverse. It is a precise source-bound warning, not a +counterexample to the author's construction. A physical implementation of the +Z correction needs its own paid contract; this audit supplies an exact local +operator identity and assigns no free implementation tariff. + +## Failure controls and limits + +Fourteen controls reject wrong residual left/right global phases, warp global, +linear and quadratic phase changes, translation, signed inverse, terminal, +singular binary map, wrong charged residual rank, swapped residual wrappers, +an omitted descriptor and a relabelled provider. A global-phase mutant preserves +all 512 permutation columns while failing the exact phase comparison. Every +serialized monomial is also composed with its independently decoded inverse +on every input column. Normal and optimized Python must give the same result. + +The frozen author NATIVE receipts bind the literal changed word hashes and +native source hashes and report all five native stages passed. Their status +is authenticated historical evidence. Fresh equality here covers the stated +40 classes only. Full changed scalar frame-transition recipes, the complete +CLIFFORD-RECIPES serialization, whole emitted program, ordinary/outer release +replay, and all-size or uniform resource admission remain outside this proof. +See LEDGER.json and RELEASE-BINDING.json for the exact inherited/unknown split. diff --git a/research/staged544-native-quadratic-audit/README.md b/research/staged544-native-quadratic-audit/README.md new file mode 100644 index 0000000000..cd92a14c73 --- /dev/null +++ b/research/staged544-native-quadratic-audit/README.md @@ -0,0 +1,105 @@ +# Native quadratic-phase audit of the staged544 terminal promotion + +This independently corroborates the signed native action at every promoted +terminal residual and every genuinely changed warp interface in the two +PR3945 providers. It also exhibits an actual binary inverse whose canonical +Clifford lift differs from the correct adjoint by a nonconstant sign character. +The result is a finite local operator certificate; it makes no new κ claim. + +**Result:** 40 unique interfaces cover 144 source occurrences, checked on all +20,480 basis columns with every Gaussian coefficient and global phase retained. +Each provider contributes 26 cold terminal promotions, old and new residuals, +and 5 changed warp interfaces in both directions, old and new. The other 47 +changed warp records only shift chronological indices. All equalities pass. + +The mathematical pairing is framed arithmetic with finite symplectic geometry +and Z4 quadratic refinements. For the actual map +`G=[1,2,8,32,44,128,59,66,489]`, the canonical lift obeys +`K_(G inverse) K_G = Z_256`: a sign change on 256 of 512 basis coordinates. +Thus replacing a signed adjoint with the canonical lift of the binary inverse +would be wrong. The source uses the correct adjoint and passes. This is a +phase-discipline witness, not an author bug. The correction is a nonconstant +Pauli character; it is not merely a global scalar phase. + +## Sources and independence + +Scientific input: [Dugongue PR3945](https://github.com/CrocSwap/integer-mult-bounds/pull/3945), +head `91f81d131252db704f945891da1ea54e29d46b8b`. The four exact frozen words and +native source/receipt hashes are authenticated by SOURCES.json. Source words +are not edited. The nearest predecessor is the independent owner audit +[PR3969](https://github.com/CrocSwap/integer-mult-bounds/pull/3969), head +`6ff67539f1131a287eb9a9a98bf1e94a02eecba7`, which explicitly excluded phases. + +`generate.py` optionally uses the byte-pinned predecessor compiler to generate +RECIPES.json. `verify.py` and `exact_phase.py` execute no predecessor code. +The new standard-library verifier independently inverts binary permutations, +constructs quadratic forms, propagates scalar Gaussian integers and decodes +the serialized recipe. It checks coverage directly against both old/new words. +The all-column checks prove local equality on arbitrary complex dirty state; +whole-word dirty restoration and physical admission remain inherited obligations. + +Fresh frozen release crosslinks connect these exact words, the author native +recipe inventories, the final package manifest and the reported release receipt. +All crosslink files are included and checked. This does not replay the full +archive or complete native recipe payload. The retained complete recipe hashes +are recorded separately from our newly generated subset. The author evidence +explicitly discloses corrected frozen-spec bindings and reused successful +prefixes; this package does not describe that history as an uninterrupted run. + +## Reproduce + +Python 3.12, standard library only; no network or Git needed for the standalone +scientific verifier: + +```sh +python3 -B research/staged544-native-quadratic-audit/verify.py +python3 -O -B research/staged544-native-quadratic-audit/verify.py +``` + +The registered repository check is: + +```sh +python3 scripts/research_package.py --package research/staged544-native-quadratic-audit +``` + +The verifier is read-only. To obtain a new comparison receipt, pass `--emit` +with a path outside the package. Optional source-compiler recipe regeneration: + +```sh +python3 -B research/staged544-native-quadratic-audit/generate.py /tmp/phase-recipes.json +``` + +Compare that JSON with RECIPES.json. Generation is not the independent check. +Fourteen semantic mutations reject, including phases invisible to binary-map +checks; all serialized monomials also pass exact inverse-column controls. +Both ordinary and optimized independent verifier runs are registered. + +## Costs, scope and attribution + +LEDGER.json lists proved, inherited and unknown obligations. Terminal recursive +ranks are 4 before and 5 after promotion; changed native warps have rank zero. +These statements assign no zero physical, precision, stock or tape tariff to +monomial wrappers or to the corrective sign. The complete owner bill is inherited +from PR3969. All changed scalar frame-transition classes, complete emitted +program, full release and uniform supplier conditions are outside this audit. + +Credit: Dugongue's terminal promotion and native frame work (PR3945/3929), +dataisfire's literal providers (PR3734), Cinna Davis's PR2226 dirty-borrowing +operators, Tekalign's native replay, and the retained native compiler and phase +lineage including icekylinx, DreamingOfClouds and upstream contributors. The +source audit lineage includes Sagar Thakrar, roger-sato and Arham Tahir. Exact +retained notices are in SOURCE-CREDITS.md, NOTICE-PR3945.md and +frozen/NATIVE-LINEAGE-NOTICE. Chris R / Clear1nsight prepared this independent +audit with substantial OpenAI Codex assistance. Root-agent coordination supplied +an independently authenticated release crosslink inspection; this verifier +rechecks those links from the included raw bytes. Apache-2.0. + +## Open next questions + +Regenerate the complete source-bound canonical word and native recipe payload, +match the retained complete recipe hashes, and extend independent exact action +to every changed scalar frame-transition class and complete emitted program. +This would connect the local equality here to the remaining native admission +boundary. It requires explicit coverage of all emitted interfaces and the +retained uniform model obligations; a fresh subset hash or owner bill alone +cannot discharge it. TASK.json records the bounded first step and stop rule. diff --git a/research/staged544-native-quadratic-audit/RECIPES.json b/research/staged544-native-quadratic-audit/RECIPES.json new file mode 100644 index 0000000000..a24e14593f --- /dev/null +++ b/research/staged544-native-quadratic-audit/RECIPES.json @@ -0,0 +1,4236 @@ +{ + "items": [ + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "entrance": [ + 257, + 161, + 70, + 19, + 13 + ], + "terminal": [ + 260, + 132, + 75, + 42, + 25 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 265, + 202, + 396, + 184, + 128, + 136, + 16, + 64, + 384 + ], + "offset": 426, + "quadratic_rows": [ + 264, + 200, + 392, + 119, + 184, + 152, + 202, + 246, + 5 + ], + "linear_Z4": [ + 0, + 2, + 0, + 2, + 1, + 2, + 1, + 1, + 0 + ], + "phase": 1 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 42, + "register": 1, + "version": "new", + "sign": 1 + }, + { + "provider": "base", + "kind": "warp", + "index": 44, + "register": 6, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 42, + "register": 1, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 44, + "register": 6, + "version": "new", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "entrance": [ + 260, + 132, + 75, + 42, + 25 + ], + "terminal": [ + 257, + 161, + 70, + 19, + 13 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 289, + 162, + 308, + 48, + 64, + 104, + 128, + 16, + 272 + ], + "offset": 330, + "quadratic_rows": [ + 288, + 160, + 304, + 96, + 20, + 207, + 104, + 162, + 5 + ], + "linear_Z4": [ + 0, + 2, + 0, + 0, + 3, + 0, + 3, + 1, + 0 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 42, + "register": 1, + "version": "new", + "sign": -1 + }, + { + "provider": "base", + "kind": "warp", + "index": 44, + "register": 6, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 42, + "register": 1, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 44, + "register": 6, + "version": "new", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "entrance": [ + 260, + 132, + 75, + 51 + ], + "terminal": [ + 416, + 70, + 19, + 13 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 162, + 292, + 32, + 64, + 328, + 128, + 304, + 256 + ], + "offset": 75, + "quadratic_rows": [ + 0, + 160, + 288, + 320, + 288, + 182, + 328, + 162, + 348 + ], + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 1, + 3, + 1, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 42, + "register": 1, + "version": "old", + "sign": -1 + }, + { + "provider": "base", + "kind": "warp", + "index": 44, + "register": 6, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 42, + "register": 1, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 44, + "register": 6, + "version": "old", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "entrance": [ + 416, + 70, + 19, + 13 + ], + "terminal": [ + 260, + 132, + 75, + 51 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 74, + 268, + 304, + 392, + 8, + 16, + 64, + 256 + ], + "offset": 183, + "quadratic_rows": [ + 0, + 72, + 264, + 206, + 304, + 272, + 74, + 264, + 436 + ], + "linear_Z4": [ + 2, + 2, + 2, + 1, + 3, + 0, + 1, + 2, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 42, + "register": 1, + "version": "old", + "sign": 1 + }, + { + "provider": "base", + "kind": "warp", + "index": 44, + "register": 6, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 42, + "register": 1, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 44, + "register": 6, + "version": "old", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "entrance": [ + 259, + 131, + 75, + 42, + 25 + ], + "terminal": [ + 260, + 132, + 75, + 42, + 25 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 385, + 386, + 388, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 384, + 384, + 384, + 0, + 0, + 0, + 0, + 391, + 391 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 43, + "register": 4, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 43, + "register": 4, + "version": "new", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "entrance": [ + 259, + 131, + 75, + 51 + ], + "terminal": [ + 260, + 132, + 75, + 51 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 385, + 386, + 388, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 384, + 384, + 384, + 0, + 0, + 0, + 0, + 391, + 391 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 43, + "register": 4, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 43, + "register": 4, + "version": "old", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "entrance": [ + 260, + 132, + 75, + 42, + 25 + ], + "terminal": [ + 259, + 131, + 75, + 42, + 25 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 385, + 386, + 388, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 384, + 384, + 384, + 0, + 0, + 0, + 0, + 391, + 391 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 43, + "register": 4, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 43, + "register": 4, + "version": "new", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "entrance": [ + 260, + 132, + 75, + 51 + ], + "terminal": [ + 259, + 131, + 75, + 51 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 385, + 386, + 388, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 384, + 384, + 384, + 0, + 0, + 0, + 0, + 391, + 391 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 43, + "register": 4, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 43, + "register": 4, + "version": "old", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "entrance": [ + 266, + 138, + 74, + 30, + 1 + ], + "terminal": [ + 426, + 96, + 24, + 6, + 1 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 67, + 16, + 468, + 65, + 217, + 128, + 417, + 385 + ], + "offset": 458, + "quadratic_rows": [ + 251, + 65, + 464, + 209, + 269, + 385, + 335, + 301, + 244 + ], + "linear_Z4": [ + 1, + 2, + 2, + 0, + 2, + 2, + 3, + 2, + 2 + ], + "phase": 3 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 4, + "register": 333, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 4, + "register": 333, + "version": "new", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "entrance": [ + 266, + 138, + 75, + 30 + ], + "terminal": [ + 427, + 96, + 24, + 6 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 449, + 66, + 16, + 468, + 64, + 216, + 128, + 416, + 384 + ], + "offset": 120, + "quadratic_rows": [ + 448, + 64, + 464, + 208, + 268, + 384, + 143, + 237, + 309 + ], + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 0, + 0, + 3, + 1 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 4, + "register": 333, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 4, + "register": 333, + "version": "old", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "entrance": [ + 426, + 96, + 24, + 6, + 1 + ], + "terminal": [ + 266, + 138, + 74, + 30, + 1 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 18, + 284, + 116, + 4, + 384, + 17, + 64, + 321 + ], + "offset": 138, + "quadratic_rows": [ + 336, + 16, + 360, + 276, + 379, + 84, + 309, + 256, + 221 + ], + "linear_Z4": [ + 2, + 2, + 2, + 0, + 3, + 2, + 2, + 0, + 0 + ], + "phase": 3 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 4, + "register": 333, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 4, + "register": 333, + "version": "new", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "entrance": [ + 427, + 96, + 24, + 6 + ], + "terminal": [ + 266, + 138, + 75, + 30 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 273, + 18, + 284, + 116, + 4, + 384, + 16, + 64, + 320 + ], + "offset": 459, + "quadratic_rows": [ + 272, + 16, + 360, + 276, + 107, + 84, + 308, + 256, + 461 + ], + "linear_Z4": [ + 2, + 2, + 2, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 4, + "register": 333, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 4, + "register": 333, + "version": "old", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "entrance": [ + 384, + 74, + 44, + 30, + 1 + ], + "terminal": [ + 426, + 96, + 24, + 6, + 1 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 258, + 16, + 340, + 32, + 376, + 64, + 192, + 320 + ], + "offset": 466, + "quadratic_rows": [ + 0, + 256, + 336, + 368, + 44, + 376, + 428, + 64, + 366 + ], + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 3, + 0, + 2, + 1 + ], + "phase": 3 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 5, + "register": 317, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 5, + "register": 317, + "version": "new", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "entrance": [ + 385, + 74, + 44, + 30 + ], + "terminal": [ + 427, + 96, + 24, + 6 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 65, + 258, + 16, + 340, + 32, + 376, + 64, + 192, + 320 + ], + "offset": 120, + "quadratic_rows": [ + 64, + 256, + 336, + 368, + 44, + 376, + 493, + 64, + 366 + ], + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 1, + 3, + 0, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 5, + "register": 317, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 5, + "register": 317, + "version": "old", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "entrance": [ + 426, + 96, + 24, + 6, + 1 + ], + "terminal": [ + 384, + 74, + 44, + 30, + 1 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 322, + 268, + 308, + 4, + 16, + 64, + 192, + 320 + ], + "offset": 102, + "quadratic_rows": [ + 0, + 320, + 56, + 260, + 308, + 276, + 194, + 64, + 314 + ], + "linear_Z4": [ + 0, + 2, + 2, + 2, + 3, + 0, + 3, + 0, + 1 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 5, + "register": 317, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 5, + "register": 317, + "version": "new", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "entrance": [ + 427, + 96, + 24, + 6 + ], + "terminal": [ + 385, + 74, + 44, + 30 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 65, + 322, + 268, + 308, + 4, + 16, + 64, + 192, + 320 + ], + "offset": 487, + "quadratic_rows": [ + 64, + 320, + 56, + 260, + 308, + 276, + 131, + 64, + 314 + ], + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 0, + 2, + 2, + 1 + ], + "phase": 3 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 5, + "register": 317, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 5, + "register": 317, + "version": "old", + "sign": -1 + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 257, + 137, + 67, + 37, + 22 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 46, + 85, + 147, + 265, + 22, + 5, + 3, + 9, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 10, + 12, + 6, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 270, + 389, + 387, + 489, + 118, + 481, + 82, + 52, + 136 + ], + "offset": 31, + "quadratic_rows": [ + 15, + 171, + 205, + 103, + 0, + 106, + 108, + 6, + 0 + ], + "linear_Z4": [ + 1, + 1, + 1, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 369, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 371, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 373, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 369, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 371, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 373, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 257, + 161, + 70, + 19, + 13 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 62, + 69, + 139, + 13, + 3, + 273, + 6, + 17, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 18, + 20, + 16, + 14, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 294, + 389, + 387, + 477, + 441, + 409, + 82, + 76, + 160 + ], + "offset": 31, + "quadratic_rows": [ + 506, + 245, + 310, + 441, + 447, + 31, + 387, + 475, + 477 + ], + "linear_Z4": [ + 0, + 2, + 1, + 1, + 1, + 2, + 2, + 3, + 1 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 337, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 339, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 337, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 339, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 258, + 130, + 67, + 22, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 35, + 85, + 134, + 8, + 6, + 256, + 3, + 18, + 2 + ], + "offset": 0, + "quadratic_rows": [ + 20, + 18, + 17, + 0, + 23, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 2, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 467, + 389, + 470, + 8, + 338, + 65, + 466, + 20, + 32 + ], + "offset": 13, + "quadratic_rows": [ + 22, + 135, + 67, + 0, + 129, + 0, + 132, + 210, + 0 + ], + "linear_Z4": [ + 0, + 3, + 0, + 2, + 2, + 0, + 2, + 1, + 2 + ], + "phase": 3 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 323, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 323, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 259, + 131, + 75, + 42, + 25 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 58, + 81, + 128, + 268, + 13, + 6, + 7, + 19, + 3 + ], + "offset": 0, + "quadratic_rows": [ + 10, + 9, + 4, + 19, + 8, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 50, + 49, + 8, + 441, + 179, + 465, + 482, + 4, + 120 + ], + "offset": 27, + "quadratic_rows": [ + 235, + 353, + 0, + 449, + 176, + 179, + 11, + 441, + 138 + ], + "linear_Z4": [ + 1, + 2, + 0, + 0, + 3, + 3, + 2, + 1, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 385, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 387, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 385, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 387, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 259, + 131, + 75, + 51, + 7 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 63, + 95, + 3, + 133, + 265, + 9, + 5, + 17, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 18, + 1, + 4, + 8, + 1, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 3, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 415, + 7, + 11, + 19, + 131, + 485, + 486, + 72, + 48 + ], + "offset": 18, + "quadratic_rows": [ + 231, + 231, + 415, + 468, + 428, + 19, + 11, + 415, + 156 + ], + "linear_Z4": [ + 1, + 1, + 3, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 389, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 394, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 389, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 394, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 262, + 134, + 102, + 22, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 32, + 92, + 156, + 2, + 5, + 265, + 9, + 17, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 20, + 0, + 1, + 8, + 1, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 432, + 8, + 22, + 38, + 134, + 1, + 466, + 468, + 96 + ], + "offset": 23, + "quadratic_rows": [ + 0, + 358, + 358, + 0, + 432, + 470, + 38, + 432, + 182 + ], + "linear_Z4": [ + 0, + 3, + 3, + 2, + 1, + 0, + 2, + 1, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 353, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 355, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 353, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 355, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 262, + 134, + 102, + 30, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 60, + 92, + 134, + 6, + 266, + 10, + 18, + 2 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 18, + 4, + 8, + 2, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 424, + 14, + 38, + 134, + 466, + 468, + 24, + 96 + ], + "offset": 17, + "quadratic_rows": [ + 0, + 382, + 382, + 438, + 14, + 462, + 38, + 424, + 174 + ], + "linear_Z4": [ + 2, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 357, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 362, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 357, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 362, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 266, + 138, + 74, + 30, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 60, + 70, + 156, + 6, + 256, + 10, + 18, + 2 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 24, + 4, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 452, + 14, + 74, + 138, + 466, + 20, + 472, + 32 + ], + "offset": 27, + "quadratic_rows": [ + 0, + 286, + 474, + 286, + 14, + 0, + 452, + 452, + 206 + ], + "linear_Z4": [ + 2, + 3, + 0, + 3, + 2, + 0, + 1, + 1, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 330, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 330, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 266, + 138, + 75, + 47, + 30 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 36, + 90, + 137, + 282, + 14, + 7, + 3, + 18, + 2 + ], + "offset": 0, + "quadratic_rows": [ + 12, + 24, + 9, + 15, + 2, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 84, + 506, + 81, + 46, + 138, + 97, + 498, + 52, + 504 + ], + "offset": 21, + "quadratic_rows": [ + 49, + 174, + 74, + 174, + 465, + 427, + 468, + 506, + 240 + ], + "linear_Z4": [ + 3, + 1, + 0, + 1, + 1, + 1, + 1, + 3, + 0 + ], + "phase": 3 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 325, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 325, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 273, + 145, + 85, + 51, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 54, + 67, + 133, + 8, + 278, + 3, + 5, + 17, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 17, + 2, + 4, + 0, + 1, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 390, + 19, + 21, + 8, + 145, + 481, + 34, + 68, + 496 + ], + "offset": 24, + "quadratic_rows": [ + 375, + 437, + 467, + 0, + 375, + 19, + 21, + 390, + 151 + ], + "linear_Z4": [ + 1, + 2, + 2, + 2, + 1, + 2, + 2, + 3, + 0 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 293, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 298, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 293, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 298, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 131, + 75, + 51 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 31, + 47, + 64, + 131, + 261, + 5, + 3, + 1, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 2, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 411, + 11, + 19, + 131, + 481, + 482, + 4, + 72, + 48 + ], + "offset": 9, + "quadratic_rows": [ + 224, + 224, + 0, + 464, + 424, + 19, + 11, + 411, + 152 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 0 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 385, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 387, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 389, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 394, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 385, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 387, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 389, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 394, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 134, + 120, + 30 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 16, + 42, + 74, + 133, + 5, + 262, + 6, + 1, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 2, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 456, + 118, + 56, + 134, + 1, + 466, + 468, + 24, + 96 + ], + "offset": 10, + "quadratic_rows": [ + 0, + 288, + 288, + 480, + 64, + 14, + 408, + 456, + 206 + ], + "linear_Z4": [ + 0, + 2, + 2, + 2, + 2, + 0, + 2, + 3, + 2 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 353, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 355, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 357, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 362, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 353, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 355, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 357, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 362, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 193, + 75, + 30 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 26, + 37, + 70, + 133, + 6, + 256, + 10, + 1, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 2, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 74, + 389, + 14, + 193, + 65, + 466, + 20, + 472, + 32 + ], + "offset": 11, + "quadratic_rows": [ + 260, + 404, + 411, + 404, + 14, + 0, + 128, + 462, + 143 + ], + "linear_Z4": [ + 2, + 0, + 0, + 0, + 2, + 0, + 0, + 3, + 0 + ], + "phase": 3 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 323, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 325, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 330, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 323, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 325, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 330, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 196, + 85, + 51 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 22, + 35, + 73, + 128, + 262, + 3, + 9, + 4, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 390, + 19, + 81, + 196, + 481, + 34, + 68, + 8, + 496 + ], + "offset": 13, + "quadratic_rows": [ + 418, + 437, + 258, + 0, + 418, + 19, + 128, + 467, + 151 + ], + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 3, + 0 + ], + "phase": 3 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 293, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 298, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 293, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 298, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 74, + 44, + 30, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 36, + 66, + 136, + 14, + 12, + 10, + 272, + 16 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 16, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 100, + 98, + 8, + 128, + 82, + 52, + 120, + 384 + ], + "offset": 1, + "quadratic_rows": [ + 0, + 50, + 84, + 120, + 14, + 106, + 108, + 384, + 128 + ], + "linear_Z4": [ + 2, + 1, + 1, + 1, + 2, + 1, + 1, + 1, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 314, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 314, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 385, + 66, + 36, + 22, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 33, + 84, + 146, + 8, + 22, + 4, + 2, + 257, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 385, + 100, + 98, + 8, + 118, + 257, + 82, + 52, + 384 + ], + "offset": 31, + "quadratic_rows": [ + 129, + 68, + 34, + 0, + 0, + 100, + 98, + 129, + 0 + ], + "linear_Z4": [ + 3, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 307, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 309, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 307, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 309, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 385, + 74, + 44, + 30 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 17, + 36, + 66, + 136, + 14, + 12, + 10, + 257, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 385, + 100, + 98, + 8, + 257, + 82, + 52, + 120, + 384 + ], + "offset": 1, + "quadratic_rows": [ + 129, + 50, + 84, + 120, + 14, + 106, + 108, + 129, + 0 + ], + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 307, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 309, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 314, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 307, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 309, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 314, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 388, + 67, + 33, + 18, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 34, + 81, + 132, + 8, + 18, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 18, + 17, + 0, + 0, + 19, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 50, + 49, + 388, + 8, + 66, + 97, + 82, + 260, + 384 + ], + "offset": 15, + "quadratic_rows": [ + 81, + 32, + 132, + 0, + 65, + 66, + 49, + 132, + 0 + ], + "linear_Z4": [ + 3, + 0, + 3, + 2, + 0, + 0, + 0, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 282, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 282, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 388, + 74, + 40, + 26, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 48, + 68, + 152, + 26, + 8, + 10, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 8, + 2, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 80, + 388, + 8, + 58, + 82, + 260, + 120, + 384 + ], + "offset": 29, + "quadratic_rows": [ + 0, + 106, + 132, + 66, + 80, + 98, + 58, + 132, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 3, + 1, + 0, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 277, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 277, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 388, + 75, + 41, + 26 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 18, + 33, + 68, + 136, + 10, + 9, + 11, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 8, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 50, + 49, + 388, + 8, + 97, + 82, + 260, + 120, + 384 + ], + "offset": 4, + "quadratic_rows": [ + 81, + 98, + 132, + 120, + 57, + 58, + 11, + 132, + 0 + ], + "linear_Z4": [ + 1, + 1, + 3, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 277, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 282, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 277, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 282, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 392, + 67, + 35, + 16, + 6 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 48, + 82, + 2, + 132, + 8, + 19, + 3, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 17, + 2, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 96, + 2, + 392, + 16, + 39, + 97, + 102, + 264, + 384 + ], + "offset": 30, + "quadratic_rows": [ + 71, + 65, + 69, + 136, + 0, + 96, + 39, + 136, + 0 + ], + "linear_Z4": [ + 3, + 2, + 1, + 3, + 2, + 3, + 0, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 378, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 378, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 392, + 67, + 37, + 22 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 18, + 41, + 75, + 132, + 10, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 6, + 5, + 392, + 118, + 97, + 82, + 52, + 264, + 384 + ], + "offset": 15, + "quadratic_rows": [ + 101, + 32, + 69, + 136, + 0, + 3, + 5, + 136, + 0 + ], + "linear_Z4": [ + 3, + 2, + 1, + 3, + 2, + 2, + 2, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 369, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 371, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 373, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 378, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 369, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 371, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 373, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 378, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 416, + 70, + 18, + 12, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 36, + 74, + 12, + 2, + 144, + 6, + 272, + 16 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 28, + 26, + 68, + 416, + 82, + 76, + 288, + 384 + ], + "offset": 23, + "quadratic_rows": [ + 0, + 74, + 16, + 66, + 68, + 160, + 26, + 160, + 0 + ], + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 3, + 0, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 341, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 346, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 341, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 346, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 416, + 70, + 19, + 13 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 22, + 33, + 71, + 5, + 3, + 136, + 2, + 264, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 6, + 5, + 93, + 416, + 25, + 82, + 76, + 288, + 384 + ], + "offset": 15, + "quadratic_rows": [ + 64, + 86, + 22, + 0, + 6, + 160, + 3, + 160, + 0 + ], + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 3, + 2, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 337, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 339, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 341, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 346, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 337, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 339, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 341, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 346, + "version": "old" + } + ] + } + ] +} diff --git a/research/staged544-native-quadratic-audit/RELEASE-BINDING.json b/research/staged544-native-quadratic-audit/RELEASE-BINDING.json new file mode 100644 index 0000000000..5c3b0b3c61 --- /dev/null +++ b/research/staged544-native-quadratic-audit/RELEASE-BINDING.json @@ -0,0 +1,23 @@ +{ + "status": "PASS_FROZEN_RELEASE_CROSSLINKS_ONLY", + "providers": { + "base": { + "word_sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0", + "retained_complete_recipe_sha256": "bdd292a21746c584479060e1cacdf9e74c368f9007608f11c3e573e0a5c1fd7d", + "fresh_subset_recipe_scope": "40 interface classes regenerated separately; not a byte replay of complete retained recipe payload" + }, + "extra": { + "word_sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299", + "retained_complete_recipe_sha256": "4b08fd0ddf681e29c2df01a01eb06db2431c9431799422f1785d44145e1d08ef", + "fresh_subset_recipe_scope": "40 interface classes regenerated separately; not a byte replay of complete retained recipe payload" + } + }, + "release_sha256": "f4c359390cbd28c60aff03304fa4811efbb2c23d072765eb5fb09f3e41858010", + "final_manifest_sha256": "215cb84a35ed000ddf929dc91d8c89fc64f379fe9d380504a53057711fce559f", + "limitations": [ + "Full recipe payload not included in this local certificate; native receipt contains its hash.", + "Full manifest source archive and release execution not replayed.", + "Native receipt manifest refers to its own source context; it is not equated to the final package manifest.", + "Author EVIDENCE discloses frozen-spec corrections and successful-prefix reuse; no uninterrupted fresh release assertion." + ] +} diff --git a/research/staged544-native-quadratic-audit/RESULT.json b/research/staged544-native-quadratic-audit/RESULT.json new file mode 100644 index 0000000000..9781578ebf --- /dev/null +++ b/research/staged544-native-quadratic-audit/RESULT.json @@ -0,0 +1,1414 @@ +{ + "status": "PASS_INDEPENDENT_QUADRATIC_PHASE_INTERFACES", + "coverage": { + "base": { + "promoted_helpers": [ + 277, + 282, + 293, + 298, + 307, + 309, + 314, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394 + ], + "changed_native_warp_indices": [ + 4, + 5, + 42, + 43, + 44 + ], + "index_only_warp_changes": [ + 1, + 2, + 3, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 14, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 64, + 66, + 67, + 68, + 69 + ] + }, + "extra": { + "promoted_helpers": [ + 277, + 282, + 293, + 298, + 307, + 309, + 314, + 323, + 325, + 330, + 337, + 339, + 341, + 346, + 353, + 355, + 357, + 362, + 369, + 371, + 373, + 378, + 385, + 387, + 389, + 394 + ], + "changed_native_warp_indices": [ + 4, + 5, + 42, + 43, + 44 + ], + "index_only_warp_changes": [ + 1, + 2, + 3, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 14, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 64, + 66, + 67, + 68, + 69 + ] + } + }, + "unique_interfaces": 40, + "source_occurrences": 144, + "all_basis_columns": 20480, + "items": [ + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 128, + 112, + 128, + 144 + ], + "operator_sha256": "915793262dcd21db059a1ea135ebc671b7f6e44d0c3fc9c1c6ae6a99ac8203fb" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 128, + 144, + 128, + 112 + ], + "operator_sha256": "c307d5ec7004726939b13de3d35fe161d9e49b2e022ada26e7f7c3187db3b566" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 128, + 128, + 128, + 128 + ], + "operator_sha256": "8b129a2781078afbf937a7c416953faa0fdda96f111dbe46e3123685c3e28371" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 128, + 128, + 128, + 128 + ], + "operator_sha256": "c5f0e1411e958c635b13af5f3f28ae11a23ffce8f6b017eb1522607d61ba8627" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 256, + 128, + 0, + 128 + ], + "operator_sha256": "ad6492113b7f2adeaaea5dd912f4c4ad0fdef82c42ac4cfb84919c200f3c6f7a" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 256, + 128, + 0, + 128 + ], + "operator_sha256": "ad6492113b7f2adeaaea5dd912f4c4ad0fdef82c42ac4cfb84919c200f3c6f7a" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 256, + 128, + 0, + 128 + ], + "operator_sha256": "ad6492113b7f2adeaaea5dd912f4c4ad0fdef82c42ac4cfb84919c200f3c6f7a" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 256, + 128, + 0, + 128 + ], + "operator_sha256": "ad6492113b7f2adeaaea5dd912f4c4ad0fdef82c42ac4cfb84919c200f3c6f7a" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 128, + 128, + 128, + 128 + ], + "operator_sha256": "35398839f9896ac23fedccbae5ffc00b4cc1c31fef28b97a82bd6a9a4bcef0e2" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 144, + 128, + 112, + 128 + ], + "operator_sha256": "19276b2426321366e53eafba639f9688adeb83d5fed57f763018002b568e0dd6" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 128, + 128, + 128, + 128 + ], + "operator_sha256": "7de1e9e19ded839d5cb53e5fa38f9bbab2d8cf1e251ebf464fb1fcdb42e9b312" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 144, + 128, + 112, + 128 + ], + "operator_sha256": "e56d6a942f4a80654eb31b51dfaaf1d91328d96dcca7aeeafb2034521f8803b1" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 112, + 128, + 144, + 128 + ], + "operator_sha256": "373480876cc8b1eca9a065da101cd9e7fdc679b6c9abc0de77375f6c2d51b403" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 144, + 128, + 112, + 128 + ], + "operator_sha256": "d208eecc3769ac81da08e10cc2f72dc79d10e4aa7e29dd7d42d99f53ccc0ea8d" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 112, + 128, + 144, + 128 + ], + "operator_sha256": "9e2679e8d7472cb686eb65cf06b7c07e854eae6199b9fcf34caab3bdc717141f" + }, + { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 144, + 128, + 112, + 128 + ], + "operator_sha256": "91e63d283b00985a37ae8234aa2c81b66e10b1987636aad170bec2bd2e245f25" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "ed4daea8c653110a17ebf69fe387aa1ed6e4bfdeb19c53fe01ff7a939e757d4d" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "83e6fc6e8d7734e9a74f7a12c84214caeb6f1552900e02dc77c4d4ff5914dfb7" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "afef23d8f1756ae9244e1999946420f1f23f44b3c9b9c95098bba607033a10bb" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "8631df6a6b20a063dff7d1c4f05f1c3e5e45876eb9a88d16aa5f99087d0ebbd0" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "8b607e369efdf1b2f302b46cc1579aab365ebeba59f09fd2296e71b9afc7374c" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "0eeff7fd4ae19b6d3da595835110da42e039ded0433fdbfa1655b450a078d8d5" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "c3c8cfbab92dbddee183604f3000a5a761e3bb9ceefa42cb94c980f16783b4fb" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "06129b2fcf0497c2a881f7f6cdd434184ad7cdd53c8c2c8efc26563a98bcac53" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "a903d7aadc361faa3b19dd474c988a182f6fec69d1f946e6f047297794889afb" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "a9d2a4d1412611bacb0a7f777ff9a7cff08662e761365f52f89223eeb697c7a3" + }, + { + "columns": 512, + "nonzero_coefficients": 8192, + "gaussian_axis_phase_histogram": [ + 1792, + 2048, + 2304, + 2048 + ], + "operator_sha256": "267abbdb6934d2b3b9c4796fb263aed096bf6b4c9a5cbc0051e7b5c1517efbd2" + }, + { + "columns": 512, + "nonzero_coefficients": 8192, + "gaussian_axis_phase_histogram": [ + 1792, + 2048, + 2304, + 2048 + ], + "operator_sha256": "eae783de5d17bc268484df8ade287a2e47ccd7752e0eff1f2d6c47fd6da09b6a" + }, + { + "columns": 512, + "nonzero_coefficients": 8192, + "gaussian_axis_phase_histogram": [ + 1792, + 2048, + 2304, + 2048 + ], + "operator_sha256": "b7eb5d732ed9cab083e2bafc0ff62237c6356bc7f35c66b874157d530b7237e2" + }, + { + "columns": 512, + "nonzero_coefficients": 8192, + "gaussian_axis_phase_histogram": [ + 1792, + 2048, + 2304, + 2048 + ], + "operator_sha256": "7f787f250e429c3027d019af1b570ae7a7853e1d547262c35106044cbd5d05f9" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "73d78437c8b76dcfd416b07c18466e3b2ed8bf5b04b5fe652247df9402781b44" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "f2785f3309eb682f6148efef86b6e2c6d463f497bac0807b60a544fccb3b0039" + }, + { + "columns": 512, + "nonzero_coefficients": 8192, + "gaussian_axis_phase_histogram": [ + 1792, + 2048, + 2304, + 2048 + ], + "operator_sha256": "b267c69ba0c5926b22a908c08e0b321d0be9a272b125e0e150426fee1a90fe6f" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "35ec5104009caa02ce237ca5aa234efe06231081f62405d0168f5aeb438e8c06" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "2e71154d212bb214a5f0f646fd0788ac53276c9c54baeba925847b5853dd6e9f" + }, + { + "columns": 512, + "nonzero_coefficients": 8192, + "gaussian_axis_phase_histogram": [ + 1792, + 2048, + 2304, + 2048 + ], + "operator_sha256": "6d0ea87181139bea15cf921a556f5dc2b21aa51eab75c8d22e283f1ee583f7a6" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "d63fcb5a48472a9ad3361a5119581942a3a5163fcd40cb8cc5d6d08b6aa441a0" + }, + { + "columns": 512, + "nonzero_coefficients": 8192, + "gaussian_axis_phase_histogram": [ + 1792, + 2304, + 2304, + 1792 + ], + "operator_sha256": "95cd5292c2b0e247a947c827948686a23557db7c221f5282f30e21224440d481" + }, + { + "columns": 512, + "nonzero_coefficients": 16384, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "07355454e0834075f54baa573cceca072411ccc0bb0cefea9194f1f97aa47a21" + }, + { + "columns": 512, + "nonzero_coefficients": 8192, + "gaussian_axis_phase_histogram": [ + 1792, + 2304, + 2304, + 1792 + ], + "operator_sha256": "c37323e7d9fa697e1ba5528d693b0273a6198f2871a94112c30364ba1a11fc39" + } + ], + "lift_cocycle": { + "actual_binary_maps": 4, + "inverse_lifts": [ + { + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "H_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "product_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "H_columns": [ + 1, + 2, + 4, + 32, + 128, + 142, + 48, + 66, + 420 + ], + "product_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "H_columns": [ + 1, + 2, + 28, + 4, + 40, + 8, + 66, + 128, + 324 + ], + "product_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "H_columns": [ + 1, + 2, + 28, + 4, + 79, + 8, + 130, + 32, + 431 + ], + "product_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "phase_character_mask": 256, + "flipped_columns": 256 + } + ], + "abstract_pair_compositions": [ + { + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "H_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "product_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "H_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "product_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 23, + 283 + ], + "phase_character_mask": 8, + "flipped_columns": 256 + }, + { + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "H_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "product_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 139, + 321 + ], + "phase_character_mask": 256, + "flipped_columns": 256 + }, + { + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "H_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "product_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 73, + 482 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "H_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "product_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 133, + 16, + 283 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "H_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "product_columns": [ + 1, + 2, + 4, + 70, + 180, + 54, + 18, + 72, + 358 + ], + "phase_character_mask": 272, + "flipped_columns": 256 + }, + { + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "H_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "product_columns": [ + 1, + 2, + 8, + 22, + 98, + 32, + 130, + 44, + 334 + ], + "phase_character_mask": 24, + "flipped_columns": 256 + }, + { + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "H_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "product_columns": [ + 1, + 2, + 8, + 166, + 27, + 32, + 64, + 44, + 493 + ], + "phase_character_mask": 272, + "flipped_columns": 256 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "H_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "product_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 135, + 333 + ], + "phase_character_mask": 256, + "flipped_columns": 256 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "H_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "product_columns": [ + 1, + 2, + 54, + 8, + 58, + 64, + 128, + 16, + 426 + ], + "phase_character_mask": 276, + "flipped_columns": 256 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "H_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "product_columns": [ + 1, + 2, + 32, + 48, + 24, + 28, + 64, + 128, + 298 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "H_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "product_columns": [ + 1, + 2, + 32, + 128, + 168, + 172, + 57, + 66, + 496 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "H_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "product_columns": [ + 1, + 2, + 8, + 32, + 44, + 135, + 59, + 66, + 489 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "H_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "product_columns": [ + 1, + 2, + 54, + 8, + 58, + 16, + 117, + 128, + 433 + ], + "phase_character_mask": 20, + "flipped_columns": 256 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "H_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "product_columns": [ + 1, + 2, + 32, + 48, + 24, + 128, + 63, + 64, + 409 + ], + "phase_character_mask": 0, + "flipped_columns": 0 + }, + { + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "H_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "product_columns": [ + 1, + 2, + 32, + 128, + 168, + 66, + 143, + 57, + 305 + ], + "phase_character_mask": 256, + "flipped_columns": 256 + } + ], + "pair_composition_scope": "Algebraic closure controls on the four actual maps; not asserted to be adjacent in the word.", + "inverse_correction": "K_G inverse = Z_ell K_(G inverse), in right-to-left matrix convention" + }, + "release_binding": { + "status": "PASS_FROZEN_RELEASE_CROSSLINKS_ONLY", + "providers": { + "base": { + "word_sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0", + "retained_complete_recipe_sha256": "bdd292a21746c584479060e1cacdf9e74c368f9007608f11c3e573e0a5c1fd7d", + "fresh_subset_recipe_scope": "40 interface classes regenerated separately; not a byte replay of complete retained recipe payload" + }, + "extra": { + "word_sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299", + "retained_complete_recipe_sha256": "4b08fd0ddf681e29c2df01a01eb06db2431c9431799422f1785d44145e1d08ef", + "fresh_subset_recipe_scope": "40 interface classes regenerated separately; not a byte replay of complete retained recipe payload" + } + }, + "release_sha256": "f4c359390cbd28c60aff03304fa4811efbb2c23d072765eb5fb09f3e41858010", + "final_manifest_sha256": "215cb84a35ed000ddf929dc91d8c89fc64f379fe9d380504a53057711fce559f", + "limitations": [ + "Full recipe payload not included in this local certificate; native receipt contains its hash.", + "Full manifest source archive and release execution not replayed.", + "Native receipt manifest refers to its own source context; it is not equated to the final package manifest.", + "Author EVIDENCE discloses frozen-spec corrections and successful-prefix reuse; no uninterrupted fresh release assertion." + ] + }, + "controls": { + "rejected": [ + "residual left global phase", + "residual right global phase", + "warp global phase", + "warp linear phase", + "warp quadratic cocycle", + "warp translation", + "warp signed inverse", + "warp wrong terminal", + "warp singular G", + "dependent terminal frame basis", + "promoted residual billed as width4", + "residual wrappers swapped", + "one interface omitted", + "coverage provider relabelled" + ], + "phase_blind_mutant_preserves_all_512_permutation_columns": true, + "monomial_inverse_columns": 32768 + } +} diff --git a/research/staged544-native-quadratic-audit/SOURCE-CREDITS.md b/research/staged544-native-quadratic-audit/SOURCE-CREDITS.md new file mode 100644 index 0000000000..c054fad87e --- /dev/null +++ b/research/staged544-native-quadratic-audit/SOURCE-CREDITS.md @@ -0,0 +1,14 @@ +# Source credit and independence + +New work: dataisfire with substantial OpenAI Codex assistance, Apache-2.0. No independent human review, fresh third-party AI review or proof-kernel verification is claimed. + +The construction extends [PR3682](https://github.com/CrocSwap/integer-mult-bounds/pull/3682), head431e6c6023ef352c41696469de7fb614cd4ded8c. Its retimed word, actual T360 source clock and immutable native/parent framework are retained. The complete new source/receipt snapshot is bound by REPLAY-INPUTS.json. The new ordinary source stage is an explicit pinned record applied after the unchanged predecessor reconstruction. + +- [PR3605](https://github.com/CrocSwap/integer-mult-bounds/pull/3605), Ross Richardson, supplies the staged-entrance mechanism, literal cleanup and exact Gaussian residual-check pattern. staged_pair.py is retained; the new544 shear and its proof are separate. +- [PR3638](https://github.com/CrocSwap/integer-mult-bounds/pull/3638), head d62e1acd7518a231440383f0d0dddf54d6edf8c1, supplies the T360 source-window clock, chronological aggregate model and integral-network/literal construction, with its retained PR3605 and earlier credits. The new inventory, integer incumbent and literal fill are recomputed. No predecessor owner receipt is used as proof of the new fill. +- [PR3687](https://github.com/CrocSwap/integer-mult-bounds/pull/3687) and [PR3693](https://github.com/CrocSwap/integer-mult-bounds/pull/3693), Sagar Thakrar and roger-sato with their credited AI assistance, supply audit_core.py and the whole-word semantics adapter audit_verify.py. These bytes are retained and reused. They are independent of the current constructor in the stated interpreter scope, not a newly written independent audit or new reviewer approval. +- The coupled-word source lineage includes PR3133, PR2979, Marius-Paul Dumitrean, dcharb78, Jeremy Kothe and the retained native/owner/block-norm/outer authors. All notices and scientific engines inside the source snapshot remain intact. + +owner_audit.py is a standalone standard-library adaptation of the source-window/family/prefix/invoice predicates in PR3638's independent_literal.py. It imports no producer, optimizer or retained owner checker. Its source template, plan and actual native canonical words are authenticated inputs. Three controls mutate actual literal roles and must fail for the intended reason. It shares the credited contract interpretation; it is not evidence of independent human agreement. + +The rational finite-price enclosure is retained from the PR3682 sources. New script adapters bind it to the actual finite histogram. Native forward/backward scalar replay, wrapper/phase lowering and all-column warp recipes were freshly run for both new words; unchanged native and parent ancestry is explicitly reused. The separate new544 span(414,51) residual check includes global Gaussian phase. diff --git a/research/staged544-native-quadratic-audit/SOURCES.json b/research/staged544-native-quadratic-audit/SOURCES.json new file mode 100644 index 0000000000..b4e03fc91c --- /dev/null +++ b/research/staged544-native-quadratic-audit/SOURCES.json @@ -0,0 +1,182 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "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" + } + ], + "external_public_inputs": [ + { + "local_path": "frozen/NATIVE-LINEAGE-NOTICE", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/NATIVE-LINEAGE-NOTICE", + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740" + }, + { + "local_path": "frozen/NATIVE-base.json", + "sha256": "98a7325d56c466673e60e17cb8d426b4e42f2adaf06786a23383eb265cfd0dd1", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/evidence/NATIVE-base.json", + "git_blob": "5d8c8be01570bd6e76dfe62321ec68be1b37cd53" + }, + { + "local_path": "frozen/NATIVE-extra.json", + "sha256": "3a47df8de3b4d82c12c7c2030b256830ed26642df23e2bc31f9d4da41ab0f7ff", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/evidence/NATIVE-extra.json", + "git_blob": "32f4acafe4216e6e34c214964428ae936042be92" + }, + { + "local_path": "frozen/PINS.json", + "sha256": "f619e8e1c163078fb70c6fc3b98a498a671b8c02927b91d6cc253af2a775b6c9", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/PINS.json", + "git_blob": "7c83dc543292205bc65abd332f77215b58feebf7" + }, + { + "local_path": "frozen/WORD-base.json.gz", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/inputs/NEW-base.json.gz", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8" + }, + { + "local_path": "frozen/WORD-extra.json.gz", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/inputs/NEW-extra.json.gz", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67" + }, + { + "local_path": "frozen/old-WORD-base.json.gz", + "sha256": "5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/inputs/OLD-base.json.gz", + "git_blob": "674ea18ade4af85ca865fb08dc973637a09e30e6" + }, + { + "local_path": "frozen/old-WORD-extra.json.gz", + "sha256": "965268a9be73d3f62e7ef680d18f108cf064bfe1f44b82157baa61443232904e", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/inputs/OLD-extra.json.gz", + "git_blob": "b17e2be67e327f04802fd034c344fe4253c13a4a" + }, + { + "local_path": "vendor/bw_adapters.py", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "native/vendor/native/new/code/borrow/bw_adapters.py", + "usage": "Only clifford_exact.py used in optional reference generation; independent verifier executes none of these sources", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/vendor/native/new/code/borrow/bw_adapters.py", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347" + }, + { + "local_path": "vendor/bw_gauss.py", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "native/vendor/native/new/code/borrow/bw_gauss.py", + "usage": "Only clifford_exact.py used in optional reference generation; independent verifier executes none of these sources", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/vendor/native/new/code/borrow/bw_gauss.py", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58" + }, + { + "local_path": "vendor/bw_phases.py", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "native/vendor/native/new/code/borrow/bw_phases.py", + "usage": "Only clifford_exact.py used in optional reference generation; independent verifier executes none of these sources", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/vendor/native/new/code/borrow/bw_phases.py", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5" + }, + { + "local_path": "vendor/bw_transport.py", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "native/vendor/native/new/code/borrow/bw_transport.py", + "usage": "Only clifford_exact.py used in optional reference generation; independent verifier executes none of these sources", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/vendor/native/new/code/borrow/bw_transport.py", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1" + }, + { + "local_path": "vendor/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "Only clifford_exact.py used in optional reference generation; independent verifier executes none of these sources", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2" + }, + { + "local_path": "frozen/EVIDENCE.json", + "sha256": "f398820698eb2d04c4a371bed3246ca7b0eab968b46eef5c7381deb1c0e9d45c", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "research/staged544-terminal-gap-fill/admission/EVIDENCE.json", + "usage": "Frozen source-bound author release crosslinks only; no full replay claim", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/admission/EVIDENCE.json", + "git_blob": "b83f9fbb89dad04cf6613ace56a14c05be03e742" + }, + { + "local_path": "frozen/FINAL-PACKAGE-MANIFEST.json", + "sha256": "215cb84a35ed000ddf929dc91d8c89fc64f379fe9d380504a53057711fce559f", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "research/staged544-terminal-gap-fill/admission/FINAL-PACKAGE-MANIFEST.json", + "usage": "Frozen source-bound author release crosslinks only; no full replay claim", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/admission/FINAL-PACKAGE-MANIFEST.json", + "git_blob": "ca780c8aab452b2a1545f1c318f6ad451f74d2ea" + }, + { + "local_path": "frozen/NATIVE-RECEIPT-CORRECTED.json", + "sha256": "bb6783ff5658a3dc7ee6656ef87cb5ead8d7c2c781536c152d6e12043e162499", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "research/staged544-terminal-gap-fill/admission/NATIVE-RECEIPT-CORRECTED.json", + "usage": "Frozen source-bound author release crosslinks only; no full replay claim", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/admission/NATIVE-RECEIPT-CORRECTED.json", + "git_blob": "c6fda0653cb382a3d8614cc1383cde30537d72a2" + }, + { + "local_path": "frozen/RELEASE.json", + "sha256": "f4c359390cbd28c60aff03304fa4811efbb2c23d072765eb5fb09f3e41858010", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "research/staged544-terminal-gap-fill/admission/RELEASE.json", + "usage": "Frozen source-bound author release crosslinks only; no full replay claim", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/admission/RELEASE.json", + "git_blob": "1a1426c7921650274df29dfb7dadbb906b698201" + } + ] +} diff --git a/research/staged544-native-quadratic-audit/TASK.json b/research/staged544-native-quadratic-audit/TASK.json new file mode 100644 index 0000000000..6659e14b6b --- /dev/null +++ b/research/staged544-native-quadratic-audit/TASK.json @@ -0,0 +1,79 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "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": "Independent exact quadratic-phase audit of all26promoted cold terminal residuals and5 genuinely changed native warp interfaces per PR3945 staged544 provider, plus a Clifford lift cocycle/inverse witness.", + "scope_change_reason": "Assigned follow-up to PR3969 native-phase obligation. Pair framed arithmetic with finite symplectic geometry and central-extension cocycles; replace aggregate moment checking with independent exact phase action.", + "bottleneck_link": "A literal binary frame map and paid owner bill do not determine relative complex phases; signed lift and wrapper equality must hold before native admission.", + "budget_minutes": 60, + "stop_rule": "Stop on a reproducible phase mismatch or complete bounded verification of these changed interfaces. Global scalar-frame recipes, full emitted program and full supplier admission remain separate.", + "outcome": "completed", + "evidence": "RESULT.json independent20,480column checks; PROOF.md cocycle lemma; 14 semantic rejection controls; complete LEDGER.json statuses.", + "author": "Chris R / Clear1nsight with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance; one agent independently implemented checker while root coordinated overlap/publication.", + "open_questions": [ + { + "question": "Do all changed scalar frame-transition recipes and complete emitted program preserve their signed phase action in the retained release?", + "why_it_matters": "This audit closes promoted residuals and genuinely changed warp interfaces only.", + "first_step": "Regenerate complete source-bound canonical word and CLIFFORD-RECIPES; match retained hashes, then extend independent scalar-column checks to exact changed transition classes.", + "blocked_by": "Full recipe materialization and emitted-program binding are not part of this local-interface certificate." + } + ], + "mathematical_pairing": { + "primary": "framed arithmetic and native operator interfaces", + "contrasting": "finite symplectic geometry; Z4 quadratic refinements and Z2 lift cocycles" + }, + "overlap": { + "cache": "677 open PR bodies, complete7page snapshot at2026-10-1907:42UTC", + "discussions": "partial signed-in1166read by root07:41UTC, claim3969comment6262298202; not exhaustive novelty", + "nearest": [ + "PR3945 native author replay", + "PR3969 independently checked owner/terminal bridge; explicitly excluded phase", + "PR3929 frame compiler" + ] + } +} diff --git a/research/staged544-native-quadratic-audit/VALIDATION.json b/research/staged544-native-quadratic-audit/VALIDATION.json new file mode 100644 index 0000000000..fe599ed7c3 --- /dev/null +++ b/research/staged544-native-quadratic-audit/VALIDATION.json @@ -0,0 +1,36 @@ +{ + "status": "PASS_BOUNDED_NATIVE_PHASE_AUDIT", + "scientific_generation": { + "command": "python3 -B research/staged544-native-quadratic-audit/generate.py /external/recipes.json", + "result": "byte-identical to retained RECIPES.json" + }, + "registered_replay": { + "command": "python3 scripts/research_package.py --package research/staged544-native-quadratic-audit", + "result": "PASS_REGISTERED_RESEARCH_PACKAGE", + "normal_seconds": 16.143, + "optimized_seconds": 15.333 + }, + "isolated_interpreter": { + "command": "python3 -I -B -X pycache_prefix=/external/cache research/staged544-native-quadratic-audit/verify.py", + "result": "PASS", + "seconds": 20.703 + }, + "source_binding": "All17retainednative/word/receipt blobs matched exact public PR3945 file inventory; source SHA256 checked on every run. Both source-main metadata pins passed.", + "prepublication_checkpoint": { + "utc": "2026-10-19 07:58 UTC", + "main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "pr3945": "91f81d131252db704f945891da1ea54e29d46b8b" + }, + "review": "Root bounded mathematical/code review: no phase-order/cocycle issue found. Added explicit frame independence and isolated-script import support. This is collaborator review, not maintainer acceptance.", + "limitations": [ + "Full native recipe payload, emitted program and release were not replayed.", + "Hosted CI status and exact public commit are reported in PR/session handoff after publication.", + "All-size, uniform precision/stock/tape, physical and supplier obligations remain inherited or unknown." + ], + "python_source_sha256": { + "verify.py": "a99c1313816b5d37e98d2d6a50b13a43f62f6ad5b0254ced3b6b1373947af2f8", + "generate.py": "0d06322361482723753651d3d92415c5253d477977e22f963fc83ffbfa94fa72", + "exact_phase.py": "e3d76b3373ff40a83a4b212b3fe1c0b431b3cfdc807da601d6e7f273c02c6d30" + } +} diff --git a/research/staged544-native-quadratic-audit/VERIFY.json b/research/staged544-native-quadratic-audit/VERIFY.json new file mode 100644 index 0000000000..52437dd943 --- /dev/null +++ b/research/staged544-native-quadratic-audit/VERIFY.json @@ -0,0 +1,28 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Independent exact Gaussian integer all-column interface equality, source coverage, cocycle witness and 14 phase/coverage rejection controls." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Same independent audit with assertions disabled; verifier uses explicit failures." + } + ] +} diff --git a/research/staged544-native-quadratic-audit/exact_phase.py b/research/staged544-native-quadratic-audit/exact_phase.py new file mode 100644 index 0000000000..4659b91e1b --- /dev/null +++ b/research/staged544-native-quadratic-audit/exact_phase.py @@ -0,0 +1,154 @@ +"""Independent scalar Gaussian-integer action; no native compiler imports. +Chris R / Clear1nsight with substantial OpenAI Codex assistance. Apache-2.0. +""" +from functools import lru_cache + +N = 9 +SIZE = 1 << N + +def need(ok, why): + if not ok: + raise ValueError(why) + +def rot(z, p): + a,b=z + return ((a,b),(-b,a),(-a,-b),(b,-a))[p%4] + +def lin(cols,x): + y=0 + for j,c in enumerate(cols): + if x & (1<>i&1] + q.append((sum(gram[i][i] for i in bits)+2*sum(gram[i][j]for i in bits for j in bits if i>j)&1)==((quad[j]>>i)&1)for i in range(N)for j in range(N)),'symmetric quadratic form') + need(all(alpha[i]%2==((quad[i]>>i)&1)for i in range(N)),'quadratic parity') + perm=[];phasev=[] + for x in range(SIZE): + perm.append(sum(((r&x).bit_count()%2)<>i&1] + phasev.append((phase+sum(alpha[i]for i in bits)+2*sum((quad[i]>>j)&1 for i in bits for j in bits if i0 else 2]+=1 + elif not r:phase_hist[1 if s>0 else 3]+=1 + digest.update(json.dumps([x,da,sorted(a.items())],separators=(',',':')).encode()) + return dict(columns=SIZE,nonzero_coefficients=support,gaussian_axis_phase_histogram=phase_hist,operator_sha256=digest.hexdigest()) + +def lift_cocycle(G,H): + """K_H K_G = K_(HG) Z_ell. Exact finite Z4 phase defect.""" + gp,gq=kernel(tuple(G));hp,hq=kernel(tuple(H)) + HG=tuple(lin(H,c)for c in G);cp,cq=kernel(HG) + defect=[(gq[x]+hq[gp[x]]-cq[x])%4 for x in range(SIZE)] + ell=sum((defect[1<0 else k.adjoint()) + op=op.then(c.canonical_frame(9,d['terminal'])) + d['recipe']=c.lower_child(op)[0];items[key]=d;coverage[key]=[] + coverage[key].append(label) + for tag in ['base','extra']: + a=json.load(gzip.open(P/'frozen'/('old-WORD-'+tag+'.json.gz')));b=json.load(gzip.open(P/'frozen'/('WORD-'+tag+'.json.gz'))) + for r,terminal in b['helper_final'].items(): + if terminal==a['helper_final'][r]:continue + for version,w in [('old',a),('new',b)]: + add(dict(kind='residual',entrance=w['start_extra'].get(r,[]),terminal=w['helper_final'][r]),dict(provider=tag,kind='terminal',helper=int(r),version=version)) + for i,(old,new)in enumerate(zip(a['warps'],b['warps'])): + if old[2:]==new[2:]:continue + for version,w in [('old',old),('new',new)]: + for sign in [1,-1]: + add(dict(kind='warp',G_columns=w[2],entrance=w[3] if sign>0 else w[4],terminal=w[4]if sign>0 else w[3],sign=sign),dict(provider=tag,kind='warp',index=i,register=w[1],version=version,sign=sign)) + return {'items':[dict(items[k],coverage=coverage[k])for k in sorted(items)]} +if __name__=='__main__': + if len(sys.argv)!=2:raise SystemExit('explicit output path required') + Path(sys.argv[1]).write_text(json.dumps(build(),indent=2)+'\n') diff --git a/research/staged544-native-quadratic-audit/vendor/bw_adapters.py b/research/staged544-native-quadratic-audit/vendor/bw_adapters.py new file mode 100644 index 0000000000..82beaa9c1d --- /dev/null +++ b/research/staged544-native-quadratic-audit/vendor/bw_adapters.py @@ -0,0 +1,165 @@ +"""Paid residual wrappers for entering helpers (Lemma A): generation and independent decoding. Apache-2.0. +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. The wrapper construction follows PR #458 +(chafreaky): a helper that starts at frame E and ends at FULL has the physical residual S_E = T_FULL T_E^-1 (apply T_E^-1 first); +S_E = L_E (C_[w] x I) R_E with R_E applied first; the wrappers R_E^-1 before the whole local invocation and L_E^-1 after its +full-frame cleanup turn the residual into the coordinate factor C_[w] x I and restore the other 9 - w coordinates identically. +usage: adapters_gk.py CANONICAL-WORD.json.gz RESIDUAL-ADAPTERS.json OUT-LEMMA-A.json +Writes the recipes (generation uses clifford_exact.lower_child) and then DECODES the serialized monomials with the primitive +constructors of clifford_exact (not lower_child) and checks, for every entrance frame, that L_E^-1 S_E R_E^-1 has exactly the +tableau and zero-state vector (global phase included) of fourier(9, range(w)); mutated recipes (wrong phase, swapped sides, wrong +translation, wrong width) must be rejected.""" +if not __debug__: + raise RuntimeError('assertions must remain enabled') # every check of this stage is an assert +import copy, gzip, json, sys +from pathlib import Path +# Package-path adaptation only; the exact wrapper mathematics is unchanged. +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE / 'vendor/clifford')) # BW: the pinned vendor531 clifford_exact (byte copy) +sys.path.insert(0, str(HERE)) +from clifford_exact import canonical_frame, lower_child, fourier, diag, perm, xgate, Op, identity, transpose, inv, parity, monomial as mono_of, mv +import bw_gauss +n = 9; FULL = tuple(1 << i for i in range(n)) +def monomial_op(rec): + """decode a serialized monomial (matrix rows, quadratic rows, Z4 linear part, translation, phase)""" + out = diag(n, tuple(rec['quadratic_rows']), tuple(rec['linear_Z4'])).then(perm(n, tuple(rec['matrix_rows']))).then(xgate(n, rec['offset'])) + return out.then(Op(n, identity(n), [('phase', rec['phase'])])) +def S_of(U, END=FULL): + # HPE: a helper that starts at E=U and ends at END has residual T_END T_E^-1 (END = FULL is the inherited case) + return canonical_frame(n, tuple(U)).adjoint().then(canonical_frame(n, tuple(END))) +def wrapped_ok(U, rec, END=FULL): + """exactly: L^-1 S R^-1 = C_[w] x I (apply order: R^-1, S, L^-1), w = dim END - dim E""" + w = len(END) - len(U); S = S_of(U, END); Rm = monomial_op(rec['right']); Lm = monomial_op(rec['left']) + net = Rm.adjoint().then(S).then(Lm.adjoint()); target = fourier(n, range(w)) + return rec['rank'] == w and net.tab == target.tab and net.zero_state() == target.zero_state() +def _contains(a, b): + a = list(a) + for x in b: + for y in sorted(a, reverse=True): + if x >> (y.bit_length() - 1) & 1: x ^= y + if x: return False + return True +def Kop(G_cols): + """BW: K_G = perm(G) then diag(Q), Q = I + G^-T G^-1: PR2226's monomial() and the conjugator inside clifford_exact.canonical_frame.""" + G = transpose(tuple(G_cols), n); gi = inv(G, n) + Q = tuple((1 << i) ^ sum(parity(gi_i & gi_j) << j for j, gi_j in enumerate(transpose(gi, n))) for i, gi_i in enumerate(transpose(gi, n))) + return perm(n, G).then(diag(n, Q)) +def numeric_K(G_cols): + import numpy as np + pv, ph = bw_gauss.monomial(list(G_cols), n) + N = 1 << n; re = np.zeros((N, N), dtype=np.int64); im = np.zeros((N, N), dtype=np.int64) + unit = [(1, 0), (0, 1), (-1, 0), (0, -1)] + for x in range(N): re[pv[x], x], im[pv[x], x] = unit[ph[x]] + return re, im, 0 +def warp_ok(G_cols, rec): + """BW: the serialized monomial equals PR2226's exact numpy K_G on all 512 columns (indep. decode) and its op decodes to K_G exactly.""" + m = bw_gauss.recipe_matrix(rec, n) + if not bw_gauss.equal_scaled(numeric_K(G_cols), m): return False + dec = monomial_op(rec); ref = Kop(G_cols) + return dec.tab == ref.tab and dec.zero_state() == ref.zero_state() + +def main(): + c = json.load(gzip.open(sys.argv[1])); frames = c['frames']; v = c['v'] + starts = sorted({c['start'][r] for r in range(2 * v, len(c['start'])) if c['start'][r] != 0 and c['final'][r] == 1}) + # HPE: (entrance, terminal) pairs of helpers ending at a proper subspace; key 'E:U'. Inherited words have none. + ends = sorted({(c['start'][r], c['final'][r]) for r in range(2 * v, len(c['start'])) if c['final'][r] != 1}) + # COLD-HPE: e == 0 (a cold helper, entrance = bottom, T_0 = I) is allowed: the (0, U) recipe is keyed '0:U' + assert all(len(frames[u]) < n and _contains(frames[u], frames[e]) for e, u in ends) + cold_ends = [(e, u) for e, u in ends if e == 0] + recipes = {} + for f in starts: + U = frames[f]; rec, compiled = lower_child(S_of(U)) + recipes[str(f)] = dict(frame=f, vectors=list(U), entrance_rank=len(U), rank=rec['rank'], left=rec['left'], right=rec['right']) + for e, u in ends: + E, U = frames[e], frames[u]; rec, compiled = lower_child(S_of(E, U)) + recipes['%d:%d' % (e, u)] = dict(frame=e, terminal=u, vectors=list(E), terminal_vectors=list(U), entrance_rank=len(E), + terminal_rank=len(U), rank=rec['rank'], left=rec['left'], right=rec['right']) + # BW: monomial recipes of the warps K_G (anticipatory dirty borrowing, PR2226): one per operator, serialized like a wrapper monomial + warp_recipes = {} + for w in c.get('warps', []): + _, rec_k = mono_of(Kop(w['G_columns'])) + warp_recipes[str(w['op'])] = dict(op=w['op'], from_frame=w['from_frame'], to_frame=w['to_frame'], G_columns=list(w['G_columns']), K=rec_k) + Path(sys.argv[2]).write_text(json.dumps(dict(status='RESIDUAL_ADAPTER_RECIPES', recipes=recipes, warps=warp_recipes), sort_keys=True, separators=(',', ':')) + '\n') + # ---- independent decode of the serialized file + data_all = json.loads(Path(sys.argv[2]).read_text()); data = data_all['recipes'] + dot = lambda a, b: bin(a & b).count('1') & 1 + detail = [] + for f in starts: + rec = data[str(f)]; U = frames[f] + assert wrapped_ok(U, rec), ('wrapper product is not C_[w] x I', f) + detail.append(dict(frame=f, entrance_rank=len(U), residual_width=n - len(U), vectors=list(U), all_even_weight=all(bin(x).count('1') % 2 == 0 for x in U), + totally_isotropic=all(dot(a, b) == 0 for a in U for b in U))) + hdetail = [] + for e, u in ends: # HPE: independent decode, residual width = dim U - dim E + rec = data['%d:%d' % (e, u)]; E, U = frames[e], frames[u] + assert wrapped_ok(E, rec, U), ('HPE wrapper product is not C_[w] x I', e, u) + hdetail.append(dict(frame=e, terminal=u, entrance_rank=len(E), terminal_rank=len(U), residual_width=len(U) - len(E))) + controls = [] + def reject(name, fn): + f = starts[0]; rec = copy.deepcopy(data[str(f)]); fn(rec) + if wrapped_ok(frames[f], rec): raise AssertionError('mutated wrapper accepted: ' + name) + controls.append(name) + reject('wrong global phase', lambda r: r['right'].__setitem__('phase', (r['right']['phase'] + 1) % 4)) + reject('wrong translation', lambda r: r['left'].__setitem__('offset', r['left']['offset'] ^ 1)) + reject('wrong quadratic form', lambda r: r['right'].__setitem__('quadratic_rows', [x ^ 2 if i == 0 else x for i, x in enumerate(r['right']['quadratic_rows'])]) if False else r['right']['linear_Z4'].__setitem__(0, (r['right']['linear_Z4'][0] + 2) % 4)) + reject('sides swapped', lambda r: (r.__setitem__('left', r['right']), r.__setitem__('right', r['left']))) + reject('wrong width', lambda r: r.__setitem__('rank', r['rank'] + 1)) + if ends: # HPE controls on the first (E, U) pair + e, u = next((p for p in ends if p[0] != 0), ends[0]); rec0 = data['%d:%d' % (e, u)] # COLD-HPE: an entering pair if any (= ends[0] without cold ends) + def hreject(name, ok): + if ok: raise AssertionError('HPE mutation accepted: ' + name) + controls.append(name) + hreject('hpe: U-wrapper decoded against a FULL ending', wrapped_ok(frames[e], rec0)) + hreject('hpe: width misreported as 9 - dim E', wrapped_ok(frames[e], dict(rec0, rank=n - len(frames[e])), frames[u])) + other = next(f for f in range(len(frames)) if f != u and len(frames[f]) == len(frames[u]) and _contains(frames[f], frames[e])) + hreject('hpe: wrong terminal hyperplane', wrapped_ok(frames[e], rec0, frames[other])) + fe = next(((e2, u2) for e2, u2 in ends if str(e2) in data), None) + if fe: # an entrance shared with FULL-ended helpers: R_{E,FULL} must not serve as R_{E,U} + r2 = data['%d:%d' % fe] + hreject('hpe: pre wrapper resolved to the FULL recipe R_{E,FULL}', wrapped_ok(frames[fe[0]], dict(r2, right=data[str(fe[0])]['right']), frames[fe[1]])) + hreject('hpe: wrong global phase', wrapped_ok(frames[e], dict(rec0, left=dict(rec0['left'], phase=(rec0['left']['phase'] + 1) % 4)), frames[u])) + if cold_ends: # COLD-HPE controls on the first cold pair (0, U): factor_iff_pre says only R_{0,U} itself may precede + e, u = cold_ends[0]; recc = data['%d:%d' % (e, u)]; E, U = frames[e], frames[u] + ID = dict(matrix_rows=[1 << i for i in range(n)], offset=0, quadratic_rows=[0] * n, linear_Z4=[0] * n, phase=0) + assert monomial_op(ID).tab == identity(n) # the control's wrapper really is the identity + def creject(name, ok): + if ok: raise AssertionError('cold HPE mutation accepted: ' + name) + controls.append(name) + creject('cold hpe: identity pre wrapper instead of R_{0,U}', wrapped_ok(E, dict(recc, right=ID), U)) + creject('cold hpe: identity post wrapper instead of L_{0,U}', wrapped_ok(E, dict(recc, left=ID), U)) + creject('cold hpe: no wrappers (cold FULL convention L = R = I)', wrapped_ok(E, dict(recc, left=ID, right=ID), U)) + creject('cold hpe: U-wrapper decoded against a FULL ending', wrapped_ok(E, recc)) + creject('cold hpe: width misreported as 9', wrapped_ok(E, dict(recc, rank=n), U)) + other = next(f for f in range(len(frames)) if f != u and len(frames[f]) == len(frames[u])) + creject('cold hpe: wrong terminal hyperplane', wrapped_ok(E, recc, frames[other])) + creject('cold hpe: wrong global phase', wrapped_ok(E, dict(recc, right=dict(recc['right'], phase=(recc['right']['phase'] + 1) % 4)), U)) + ent = next((p for p in ends if p[0] != 0 and p[1] == u), None) + same = lambda x, y: monomial_op(x).tab == monomial_op(y).tab and monomial_op(x).zero_state() == monomial_op(y).zero_state() + if ent and not same(data['%d:%d' % ent]['right'], recc['right']): # an entering helper ending at the same U: its R_{E,U} must not serve as R_{0,U} + creject('cold hpe: pre wrapper resolved to an entering recipe R_{E,U}', wrapped_ok(E, dict(recc, right=data['%d:%d' % ent]['right']), U)) + wdetail = [] + for w in c.get('warps', []): # BW: independent decode of every warp recipe, then mutation controls on the first warp + rec = data_all['warps'][str(w['op'])] + assert rec['G_columns'] == w['G_columns'] + assert warp_ok(w['G_columns'], rec['K']), ('warp recipe differs from the exact monomial K_G', w['op']) + wdetail.append(dict(op=w['op'], from_frame=w['from_frame'], to_frame=w['to_frame'], columns_checked=1 << n)) + if c.get('warps'): + w0 = c['warps'][0]; k0 = data_all['warps'][str(w0['op'])]['K'] + def wreject(name, ok): + if ok: raise AssertionError('warp mutation accepted: ' + name) + controls.append(name) + wreject('warp: wrong global phase', warp_ok(w0['G_columns'], dict(k0, phase=(k0['phase'] + 1) % 4))) + wreject('warp: wrong translation', warp_ok(w0['G_columns'], dict(k0, offset=k0['offset'] ^ 1))) + wreject('warp: wrong linear phase', warp_ok(w0['G_columns'], dict(k0, linear_Z4=[(k0['linear_Z4'][0] + 2) % 4] + k0['linear_Z4'][1:]))) + wreject('warp: wrong quadratic form', warp_ok(w0['G_columns'], dict(k0, quadratic_rows=[k0['quadratic_rows'][0] ^ 2, k0['quadratic_rows'][1] ^ 1] + k0['quadratic_rows'][2:]))) + wreject('warp: recipe of another operator', warp_ok(w0['G_columns'], data_all['warps'][str(c['warps'][1]['op'])]['K'])) + wreject('warp: inverse recipe used as the warp', warp_ok(w0['G_columns'], mono_of(Kop(w0['G_columns']).adjoint())[1])) + G2 = list(w0['G_columns']); G2[0] ^= G2[1] + wreject('warp: wrong G (frame-changed column)', warp_ok(G2, k0)) + sing = list(w0['G_columns']); sing[1] = sing[0] + try: Kop(sing); raise SystemExit('non-invertible G accepted') + except (AssertionError, StopIteration, ValueError): controls.append('warp: non-invertible G') + res = dict(status='PASS_RESIDUAL_WRAPPERS_ARE_EXACT', frames=len(detail), **({'hyperplane_end_pairs': hdetail} if ends else {}), **({'cold_hyperplane_end_pairs': len(cold_ends)} if cold_ends else {}), wrappers_reject=controls, all_even_weight=all(d['all_even_weight'] for d in detail), **({'warp_recipes_exact_on_all_512_columns': wdetail} if wdetail else {}), + all_totally_isotropic=all(d['totally_isotropic'] for d in detail), detail=detail) + Path(sys.argv[3]).write_text(json.dumps(res, indent=1) + '\n') + print('Lemma A (exact): L^-1 S_E R^-1 = C_[w] x I for', len(detail), 'entrance frames, global phase included;', len(controls), 'wrapper mutations rejected; all-even-weight:', res['all_even_weight']) +if __name__ == '__main__': main() diff --git a/research/staged544-native-quadratic-audit/vendor/bw_gauss.py b/research/staged544-native-quadratic-audit/vendor/bw_gauss.py new file mode 100644 index 0000000000..1ff29dfb24 --- /dev/null +++ b/research/staged544-native-quadratic-audit/vendor/bw_gauss.py @@ -0,0 +1,114 @@ +"""Exact Gaussian column products of monomial warps (numpy only). + +Port of PR2226's operators.py (Cinna Davis, @1337isnot1337, with OpenAI Codex assistance; Apache-2.0): change / monomial / +apply_mono / coord / frame / check. Shares no code with the clifford_exact phase compiler or the emitter. Matrices are +(re, im, exp) with entries (re + i im) / 2^exp-scaled: a product of frames and warps is *exact* when every row and column has +one support entry of magnitude exactly 2^exp. +""" +if not __debug__: + raise RuntimeError('assertions must remain enabled') # every check of this stage is an assert +import hashlib +import numpy as np +def lin(cols,x): + out=0 + for i,col in enumerate(cols): + if x>>i&1:out^=col + return out +def f2rank(xs): + b={} + for x in xs: + while x: + i=x.bit_length() + if i not in b:b[i]=x;break + x^=b[i] + return len(b) +def extend(xs,hh): + out=list(xs) + for i in range(hh): + if f2rank(out+[1<len(out):out.append(1<>i)&1)<>i&1)==(M[i]>>j&1) for i in range(hh) for j in range(hh)) + permv=np.array([lin(cols,x) for x in range(1<>i)&1)*(x>>i&1) for i in range(hh))+ + 2*sum(((M[j]>>i)&1)*(x>>i&1)*(x>>j&1) for i in range(hh) for j in range(i+1,hh)) + for x in permv],dtype=np.int64)%4 + return permv,phase +def apply_mono(z,recipe,sign=1): + re,im,exp=z;perm,phase=recipe;rr=np.empty_like(re);ii=np.empty_like(im) + if sign==1: + for p in range(4): + mask=phase==p;r=re[mask];i=im[mask] + if p==0:a,b=r,i + elif p==1:a,b=-i,r + elif p==2:a,b=-r,-i + else:a,b=i,-r + rr[perm[mask]]=a;ii[perm[mask]]=b + else: + r=re[perm];i=im[perm] + for p in range(4): + mask=phase==p + if p==0:a,b=r[mask],i[mask] + elif p==1:a,b=i[mask],-r[mask] + elif p==2:a,b=-r[mask],-i[mask] + else:a,b=-i[mask],r[mask] + rr[mask]=a;ii[mask]=b + return rr,ii,exp +def coord(z,axes,sign=1): + re,im,exp=z + for j in axes: + p=np.array([x for x in range(len(re)) if not(x>>j&1)]);q=p^(1<0 else -1);return frame(z,E,hh,1) +def recipe_matrix(rec,hh): + """Dense exact matrix (re, im, exp=0) of a serialized clifford_exact monomial (matrix_rows, quadratic_rows, linear_Z4, offset, phase): + |x> -> i^(qvalue(x)+phase) |G x ^ offset>, qvalue = sum alpha_i x_i + 2 sum_{i in x} parity((Q_i >> (i+1)) & (x >> (i+1))).""" + N=1<>i&1)+2*sum(((Q[i]>>(i+1))&(x>>(i+1))).bit_count()&1 for i in range(hh) if x>>i&1)+ph)%4 + re[y,x],im[y,x]=unit[q] + return re,im,0 +def equal_scaled(z,m): + """z (scaled by 2^exp) equals m (exp 0) entrywise exactly""" + re,im,exp=z;return bool(np.array_equal(re,m[0]<0 else K.adjoint() + op=ops[f0].adjoint().then(Ks).then(ops[f1]);rec,compiled=lower_child(op) + assert rec['rank']==0 and rec['right'] is None,('warp is not a monomial Clifford',sign,op_id,f0,f1) + Z=bw_gauss.warp_product(G,frames[f0],frames[f1],sign*op_id,n) + assert bw_gauss.equal_scaled(Z,bw_gauss.recipe_matrix(rec['left'],n)),('recipe differs from the exact column product',sign,op_id,f0,f1) + hist['warp']+=1;warps.append({'sign':sign,'op':op_id,'old':f0,'new':f1,'G_columns':G,**rec}) +raw=json.dumps({'children':recipes,'endpoint_adapters':adapters,'warps':warps},sort_keys=True,separators=(',',':')).encode() +(OUT/'CLIFFORD-RECIPES.json').write_bytes(raw) +result={'status':'PASS_NEW_WORD_EXACT_LOCAL_PHASE_RECIPES', + 'canonical_word_sha256':hashlib.sha256(P.read_bytes()).hexdigest(), + 'frames':len(frames),'directed_edges':len(edges),'ranks':{str(k):x for k,x in hist.items()}, + 'endpoint_adapters':len(adapters),'warp_recipes':len(warps),'warp_recipes_rank_zero':all(w['rank']==0 for w in warps), + 'warp_recipes_equal_exact_512_column_product':True, + 'all_child_equalities_include_global_phase':True, + 'recipe_sha256':hashlib.sha256(raw).hexdigest(),'seconds':time.monotonic()-start, + 'scope':'Every local frame, centre transition and warp. Expanded scalar-interface integration and global emitted program are separate obligations.'} +(OUT/'CLIFFORD-REVIEW.json').write_text(json.dumps(result,indent=2)+'\n') +print('PASS exact local phases',result['seconds'],'seconds',flush=True) diff --git a/research/staged544-native-quadratic-audit/vendor/bw_transport.py b/research/staged544-native-quadratic-audit/vendor/bw_transport.py new file mode 100644 index 0000000000..08248542b1 --- /dev/null +++ b/research/staged544-native-quadratic-audit/vendor/bw_transport.py @@ -0,0 +1,416 @@ +"""Transport an explicit BORROW-WORD to the native canonical frame-id form, with warps, and replay it exactly. + +Anticipatory dirty borrowing is the construction of PR2226 (Cinna Davis, @1337isnot1337, with OpenAI Codex +assistance; Apache-2.0): a retiring helper's register is lent to a later helper through a monomial Clifford +logical reference change K_G ("warp"), the retired field's value being replaced by K_G z. The explicit +chronological BORROW-WORD (canonical coordinates, literal frames, warps, cold restoration, inverse cleanup +with private zero buffers) is the builder output of the borrowing work (P1/P2). This script is the +transport stage of the native chain (the analogue of hpe_audit_and_transport.py): it never trusts the builder. +It replays the program in the free operator algebra generated by the warps over every arbitrary input, +in BOTH orientations (forward and inverse-transpose), checks every frame chain and the paid profile, compacts +the helper registers to R' = R - k, and writes the native CANONICAL-WORD. + +usage: bw_transport.py BORROW-WORD.json[.gz] OUT_DIR +""" +if not __debug__: + raise RuntimeError('assertions must remain enabled') # every check of this stage is an assert +import argparse +import copy +import gzip +import hashlib +import json +import sys +import time +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def basis(vs): + pivots = {} + for x in vs: + for k in sorted(pivots, reverse=True): + if x >> k & 1: + x ^= pivots[k] + if x: + k = x.bit_length() - 1 + for j in pivots: + if pivots[j] >> k & 1: + pivots[j] ^= x + pivots[k] = x + return tuple(pivots[k] for k in sorted(pivots, reverse=True)) + + +def span(b): + s = {0} + for x in b: + s |= {t ^ x for t in s} + return frozenset(s) + + +def rank_of(vs): + return len(basis(vs)) + + +def solve_G(cols, h): + """G given as images of e_i; returns (invertible?, image-of-subspace function).""" + def lin(x): + out = 0 + for i, c in enumerate(cols): + if x >> i & 1: + out ^= c + return out + return lin, rank_of(cols) == h + + +# ---- free operator algebra over the warps ------------------------------------------------------------------ +def add_row(dst, src, c): + for key, value in list(src.items()): + z = dst.get(key, Q(0)) + c * value + if z: + dst[key] = z + elif key in dst: + del dst[key] + + +def warp_row(row, op): + out = {} + for (var, word), value in row.items(): + word = word[1:] if word and word[0] == -op else (op,) + word + out[var, word] = value + return out + + +def is_dyadic(q): + return q.denominator & (q.denominator - 1) == 0 + + +def gate_regs(e): + if e[0] == 'add': + return [e[1], e[2]] + if e[0] == 'scale': + return [e[1]] + raise AssertionError(e[0]) + + +def dual(e): + e = list(e) + if e[0] == 'add': + e[1], e[2] = e[2], e[1] + e[3] = -e[3] + elif e[0] == 'scale': + e[2], e[3] = e[3], e[2] + return e + + +def apply_gate(e, rows, back): + if back: + e = dual(e) + if e[0] == 'scale': + q = Q(e[2], e[3]) + assert q + rows[e[1]] = {j: q * x for j, x in rows[e[1]].items()} + else: + assert e[1] != e[2] + add_row(rows[e[1]], rows[e[2]], Q(e[3], e[4])) + + +def run(word_path, out): + t0 = time.monotonic() + word = read(word_path) + assert word['kind'] == 'BORROW-WORD' + v, h, R0 = word['report']['v'], word['report']['h'], word['report']['R'] + assert h == 9 and v == 112 + n0 = 2 * v + R0 + removed = sorted(word['removed']) + assert all(2 * v <= r < n0 for r in removed) and len(set(removed)) == len(removed) + k = len(removed) + kept = [r for r in range(n0) if r not in set(removed)] + newid = {r: i for i, r in enumerate(kept)} + n = len(kept) + R = R0 - k + assert n == 2 * v + R + Zbase = n0 # builder convention: zero buffer of restored c is register n0 + c + ports = word['ports'] + assert len(set(ports)) == v + full = tuple(1 << i for i in range(h - 1, -1, -1)) + frames, frame_ids = [(), full], {(): 0, full: 1} + + def fid(vectors): + frame = basis(vectors) + if frame not in frame_ids: + frame_ids[frame] = len(frames) + frames.append(frame) + return frame_ids[frame] + + def R_(r): # register -> new register (int) or ['Z', c] + if isinstance(r, list): + return r + if r >= Zbase: + return ['Z', newid[r - Zbase]] + return newid[r] + + start = [fid([p]) for p in ports] + [0] * (v + R) + for r, frame in word['start_extra'].items(): + assert 2 * v <= int(r) < n0 and int(r) not in set(removed) + start[newid[int(r)]] = fid(frame) + final = [1] * v + [fid(x for x in range(1, 1 << h) if (x & p).bit_count() % 2 == 0) for p in ports] + [1] * R + helper_final = {} + for r, frame in word['helper_final'].items(): + assert 2 * v <= int(r) < n0 and int(r) not in set(removed) + helper_final[newid[int(r)]] = fid(frame) + final[newid[int(r)]] = helper_final[newid[int(r)]] + zero_buffers = sorted(helper_final) # every restored (hyperplane-ended) helper is replaced by a private zero buffer in the FULL cleanup + + def gate(e): + e = copy.deepcopy(e) + # Four-low lifted-target port (PR2436 mechanism): literal A-phase warp after the entry adapters. + if e[0] == 'warp': + assert len(e) == 5 + return ['warp', R_(e[1]), e[2], fid(e[3]), fid(e[4])] + if e[0] == 'add': + e[1], e[2] = R_(e[1]), R_(e[2]) + else: + e[1] = R_(e[1]) + e[-1] = None if e[-1] is None else fid(e[-1]) + return e + + # warps: operator table; op id = position + 1; G given by images of the basis vectors + warps = [] + for i, (pos, lender, G, frm, to) in enumerate(word['warps']): + warps.append({'op': i + 1, 'B_pos': pos, 'lender': newid[lender], 'G_columns': list(G), + 'from_frame': fid(frm), 'to_frame': fid(to)}) + byp = {} + for w_ in warps: + byp.setdefault(w_['B_pos'], []).append(w_) + + def warp_event(r, op, f0, f1): + return ['warp', r, op, f0, f1] + + # compensation (zero frame): initial corrections first, as twisted additions t += c * W(s) + pre = [] + for term in word['initial_corrections']: + q = Q(term['coefficient']) + pre.append(['tadd', newid[term['target']], newid[term['source']], list(term['operator_word']), + q.numerator, q.denominator, 0]) + precondition = pre + [gate(e) for e in word['precondition']] # the formal initial corrections come first (PR2226 order) + compensation = [gate(e) for e in word['compensation']] + A = [gate(e) for e in word['A']] + cut = [gate(e) for e in word['cut']] + B = [] + for p in range(len(word['B']) + 1): + for w_ in sorted(byp.get(p, []), key=lambda x: x['op']): + B.append(warp_event(w_['lender'], w_['op'], w_['from_frame'], w_['to_frame'])) + if p < len(word['B']): + B.append(gate(word['B'][p])) + assert sum(1 for e in B if e[0] == 'warp') == len(warps) + tail = [gate(e) for e in word['restore']] + cleanup = [] + for e in word['cleanup']: + if e[0] == 'warp': + cleanup.append(warp_event(R_(e[1]), e[2], 1, 1)) + assert basis(e[3]) == full + else: + cleanup.append(gate(e)) + centers = [newid[r] for r in word['centers']] + center_frames = [fid(f) for f in word['center_frames']] + levels = {str(t): fid(f) for t, f in word['target_levels'].items()} + + canonical = dict(h=h, v=v, R=R, ports=ports, frames=frames, start=start, final=final, + precondition=precondition, compensation=compensation, A=A, cut=cut, B=B, tail=tail, + cleanup=cleanup, centers=centers, center_frames=center_frames, target_levels=levels, + warps=warps, zero_buffers=zero_buffers, removed=removed, helper_origin=kept[2 * v:], + borrow=dict(k=k, base=word.get('base'), original_helpers=R0)) + # ---- exact scalar replay in the free algebra over the warps (both orientations) ----------------------------------- + nz = len(zero_buffers) + + def regkey(r): + return tuple(r) if isinstance(r, list) else ('L', r) + + def expand_tadd(e): + _, t, s, wordops, a, b, f = e + ev = [warp_event(s, op, 0, 0) for op in reversed(wordops)] + ev.append(['add', t, s, a, b, 0]) + ev += [warp_event(s, -op, 0, 0) for op in wordops] + return ev + + def program(): + yield 'pre', [x for e in precondition + compensation for x in (expand_tadd(e) if e[0] == 'tadd' else [e])] + yield 'A', A + yield 'A', cut + yield 'B', B + yield 'tail', tail + yield 'cleanup', cleanup + + def fullprog(): + return [(part, e) for part, es in program() for e in es] + prog = fullprog() + for back in (False, True): + rows = {regkey(r): {(r, ()): Q(1)} for r in range(n)} + for c in zero_buffers: + rows[('Z', c)] = {} + for part, e in prog: + if e[0] == 'warp': + key = ('L', e[1]) if not isinstance(e[1], list) else tuple(e[1]) + rows[key] = warp_row(rows[key], e[2]) + else: + if e[0] == 'add': + src, dst = regkey(e[2]), regkey(e[1]) + a, b = e[3], e[4] + if back: + src, dst, a = dst, src, -a + assert src != dst + add_row(rows[dst], rows[src], Q(a, b)) + else: + key = regkey(e[1]) + a, b = (e[3], e[2]) if back else (e[2], e[3]) + q = Q(a, b) + assert q + rows[key] = {j: q * x for j, x in rows[key].items()} + expected = {regkey(r): {(r, ()): Q(1)} for r in range(n)} + for t in range(v): + if back: + expected[('L', t)][(v + t, ())] = Q(-1) + else: + expected[('L', v + t)][(t, ())] = Q(1) + for c in zero_buffers: + expected[('Z', c)] = {} + bad = [key for key in expected if rows[key] != expected[key]] + assert not bad, ('arbitrary-input endpoint (free warp algebra)', back, bad[:8]) + # dyadic primitives + for part, e in prog: + if e[0] == 'add': + assert is_dyadic(Q(e[3], e[4])) + elif e[0] == 'scale': + q = Q(e[2], e[3]) + a = abs(q.numerator) + assert is_dyadic(q) and a and a & (a - 1) == 0 + + wrapped_regs = {r for r in range(2 * v, n) if start[r] != 0 or final[r] != 1} # entering or hyperplane-ended helpers carry wrappers + # ---- frame chains, paid profile, edges, warps ------------------------------------------------------------------- + contains = lambda a, b: basis(frames[a] + frames[b]) == tuple(frames[b]) + cur = start.copy() + paid, edges = Counter(), set() + wsum = {w_['op']: w_ for w_ in warps} + G_of = {} + for w_ in warps: + lin, inv_ = solve_G(w_['G_columns'], h) + assert inv_, ('non-invertible G', w_['op']) + img = basis([lin(x) for x in frames[w_['from_frame']]]) + assert img == tuple(frames[w_['to_frame']]), ('G does not map the from frame onto the to frame', w_['op']) + assert len(frames[w_['from_frame']]) == len(frames[w_['to_frame']]) + G_of[w_['op']] = lin + warp_edges = set() + + def regs_of(e): + return [r for r in gate_regs(e) if not isinstance(r, list)] + + def climb(r, f): + old = cur[r] + assert contains(old, f), ('nonmonotone', r, old, f) + if old != f: + degree = len(frames[f]) - len(frames[old]) + paid[degree] += 1 + edges.add((old, f)) + cur[r] = f + + def do_warp(e): + _, r, op, f0, f1 = e + if isinstance(r, list): + assert r[0] == 'Z' + assert f0 == f1 == 1 + return + assert cur[r] == f0, ('warp frame mismatch', r, op, cur[r], f0) + a = abs(op) + lin = G_of[a] + if op > 0: + ok = basis([lin(x) for x in frames[f0]]) == tuple(frames[f1]) + else: + ok = basis([lin(x) for x in frames[f1]]) == tuple(frames[f0]) + assert ok, ('warp G does not carry the frame', op, f0, f1) + cur[r] = f1 + warp_edges.add((1 if op > 0 else -1, a, f0, f1)) + + # zero-frame phase + for e in precondition + compensation: + if e[0] == 'tadd': + assert start[e[2]] == 0 and start[e[1]] == 0 and e[-1] == 0 and e[2] not in set(wrapped_regs) and all(op != 0 for op in e[3]) + for ev in expand_tadd(e): + if ev[0] == 'warp': + do_warp(ev) # frame 0 -> 0: K_G itself is the physical operator + continue + for r in regs_of(e): + assert start[r] == 0 and e[-1] == 0, ('zero-frame precondition on a nonzero entrance', e) + for part in ('A', 'B'): + if part == 'B': + assert all(cur[r] == f for r, f in zip(centers, center_frames)) + assert all(cur[v + t] == levels.get(str(t), 0) for t in range(v)) + for r, frame in zip(centers, center_frames): + served = {levels.get(str(e[1] - v), 0) for e in cut if e[2] == r} + old = frame + for f in sorted(served, key=lambda f: -len(frames[f])): + assert contains(f, old) + if old != f: + paid[len(frames[old]) - len(frames[f])] += 1 + edges.add((old, f)) + edges.add((f, old)) + old = f + for e in (A if part == 'A' else B): + if e[0] == 'warp': + do_warp(e) + else: + for r in regs_of(e): + climb(r, e[-1]) + for e in tail: + for r in regs_of(e): + climb(r, e[-1]) + for r, f in enumerate(final): + climb(r, f) + for e in cleanup: + if e[0] == 'warp': + do_warp(e) + continue + for r in gate_regs(e): + if isinstance(r, list): + assert r[0] == 'Z' and r[1] in set(zero_buffers) and e[-1] == 1 + else: + assert final[r] == 1 and e[-1] == 1, ('cleanup on a non-FULL end', e) + assert all(len(frames[final[r]]) < h for r in zero_buffers) + assert set(zero_buffers) == set(helper_final) + rep = word['report'] + assert dict(paid) == {int(r): c for r, c in rep['local_profile'].items()}, ('paid profile differs', dict(paid), rep['local_profile']) + canonical['local_profile'] = dict(sorted(paid.items())) + canonical['edges'] = sorted(edges) + canonical['warp_edges'] = sorted(warp_edges) + out.mkdir(parents=True, exist_ok=False) + payload = json.dumps(canonical, sort_keys=True, separators=(',', ':')).encode() + (out / 'CANONICAL-WORD.json.gz').write_bytes(gzip.compress(payload, mtime=0)) + raw = word_path.read_bytes() + (out / 'FULL-WORD.json.gz').write_bytes(gzip.compress(gzip.decompress(raw) if word_path.suffix == '.gz' else raw, mtime=0)) + receipt = dict(status='PASS_BORROW_WORD_FREE_ALGEBRA_ALL_COLUMNS_AND_NATIVE_FRAMES', + input_content_sha256=hashlib.sha256(gzip.decompress(raw) if word_path.suffix == '.gz' else raw).hexdigest(), + canonical_content_sha256=hashlib.sha256(payload).hexdigest(), + live_columns_each_orientation=n, helpers=R, original_helpers=R0, removed_helpers=k, + zero_buffers=nz, warps=len(warps), warp_events=sum(e[0] == 'warp' for part, e in prog), + initial_corrections=len(word['initial_corrections']), + scalar_operations=len([1 for p, e in prog if e[0] != 'warp']), + local_profile=dict(sorted(paid.items())), local_rank_mass=sum(r * z for r, z in paid.items()), + widths=[len(frames[final[r]]) - len(frames[start[r]]) for r in range(2 * v, n)], + frames=len(frames), directed_edges=len(edges), warp_edge_classes=len(warp_edges), + seconds=time.monotonic() - t0, + scope='Fresh exact forward and inverse-transpose replay over a free noncommutative warp algebra on every arbitrary input, native frame chains, dyadic primitives, zero buffers returned to zero. Physical Clifford exactness of every warp is checked by the local replay and the phase recipes.') + (out / 'SCALAR-FRAME-AUDIT.json').write_text(json.dumps(receipt, indent=2) + '\n') + print(json.dumps({k_: x for k_, x in receipt.items() if k_ != 'widths'}, indent=2), flush=True) + + +if __name__ == '__main__': + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('word', type=Path) + ap.add_argument('out', type=Path) + a = ap.parse_args() + run(a.word, a.out) diff --git a/research/staged544-native-quadratic-audit/vendor/clifford_exact.py b/research/staged544-native-quadratic-audit/vendor/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/staged544-native-quadratic-audit/vendor/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<0 else w[4],terminal=w[4]if sign>0 else w[3],sign=sign),dict(provider=tag,kind='warp',index=i,register=w[1],version=version,sign=sign)) + e.need(len(promoted)==26 and len(actual)==5 and len(indexonly)==47,'changed interface coverage') + counts[tag]=dict(promoted_helpers=promoted,changed_native_warp_indices=actual,index_only_warp_changes=indexonly) + return out,counts + +def coverage_check(items,words): + expected,counts=expected_coverage(words) + actual={key(item):item['coverage']for item in items} + e.need(len(actual)==len(items),'duplicate recipe descriptor') + e.need(actual==expected,'source-to-interface coverage') + return counts + +def controls(items,words): + results=[] + def rejects(name,fn): + try:fn() + except (ValueError,KeyError):results.append(name);return + raise ValueError('control accepted: '+name) + warp=next(x for x in items if x['kind']=='warp'and len(x['entrance'])==5) + residual=next(x for x in items if x['kind']=='residual'and len(x['terminal'])==5) + for side in ['left','right']: + z=copy.deepcopy(residual);z['recipe'][side]['phase']=(z['recipe'][side]['phase']+1)%4 + rejects('residual '+side+' global phase',lambda z=z:e.check_item(z)) + for name,mut in [ + ('warp global phase',lambda z:z['recipe']['left'].__setitem__('phase',(z['recipe']['left']['phase']+1)%4)), + ('warp linear phase',lambda z:z['recipe']['left']['linear_Z4'].__setitem__(0,(z['recipe']['left']['linear_Z4'][0]+2)%4)), + ('warp quadratic cocycle',lambda z:(z['recipe']['left']['quadratic_rows'].__setitem__(0,z['recipe']['left']['quadratic_rows'][0]^2),z['recipe']['left']['quadratic_rows'].__setitem__(1,z['recipe']['left']['quadratic_rows'][1]^1))), + ('warp translation',lambda z:z['recipe']['left'].__setitem__('offset',z['recipe']['left']['offset']^1)), + ('warp signed inverse',lambda z:z.__setitem__('sign',-z['sign'])), + ('warp wrong terminal',lambda z:z.__setitem__('terminal',z['terminal'][:-1])), + ('warp singular G',lambda z:z['G_columns'].__setitem__(0,z['G_columns'][1])), + ]: + z=copy.deepcopy(warp);mut(z);rejects(name,lambda z=z:e.check_item(z)) + z=copy.deepcopy(residual);z['terminal'].append(z['terminal'][0]);z['recipe']['rank']=len(z['terminal']) + rejects('dependent terminal frame basis',lambda:e.check_item(z)) + z=copy.deepcopy(residual);z['recipe']['rank']=4 + rejects('promoted residual billed as width4',lambda:e.check_item(z)) + z=copy.deepcopy(residual);z['recipe']['left'],z['recipe']['right']=z['recipe']['right'],z['recipe']['left'] + rejects('residual wrappers swapped',lambda:e.check_item(z)) + z=copy.deepcopy(items);z.pop() + rejects('one interface omitted',lambda:coverage_check(z,words)) + z=copy.deepcopy(items);z[0]['coverage'][0]['provider']='other' + rejects('coverage provider relabelled',lambda:coverage_check(z,words)) + # A phase-blind permutation checker provably accepts this mutant. Our check rejects it above. + clean=e.decoded(warp['recipe']['left']);m=copy.deepcopy(warp['recipe']['left']);m['phase']=(m['phase']+1)%4 + e.need(clean[0]==e.decoded(m)[0] and clean[1]!=e.decoded(m)[1],'phase-blind witness') + # Explicit inverse/unitary controls on every compiled monomial over every basis column. + mono_count=0 + for item in items: + for side in ['left','right']: + if item['recipe'][side]is None:continue + k=e.decoded(item['recipe'][side]);mono_count+=1 + for x in range(e.SIZE):e.need(e.mono(e.mono({x:(1,0)},k),k,True)=={x:(1,0)},'monomial inverse') + return dict(rejected=results,phase_blind_mutant_preserves_all_512_permutation_columns=True,monomial_inverse_columns=mono_count*e.SIZE) + +def run(with_controls=True): + authenticate();items=json.loads((P/'RECIPES.json').read_text())['items'] + words={tag:tuple(json.load(gzip.open(P/'frozen'/(name+tag+'.json.gz')))for name in ['old-WORD-','WORD-'])for tag in ['base','extra']} + counts=coverage_check(items,words) + checks=[e.check_item(item)for item in items] + result=dict(status='PASS_INDEPENDENT_QUADRATIC_PHASE_INTERFACES',coverage=counts,unique_interfaces=len(items),source_occurrences=sum(len(x['coverage'])for x in items),all_basis_columns=len(items)*e.SIZE,items=checks) + result['lift_cocycle']=e.cocycle_certificate(items) + result['release_binding']=release_binding() + if with_controls:result['controls']=controls(items,words) + return result + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--emit',type=Path);args=ap.parse_args();t=time.monotonic();result=run() + if args.emit: + e.need(P not in args.emit.resolve().parents,'receipt output must be outside package') + args.emit.write_text(json.dumps(result,indent=2)+'\n') + else:e.need(result==json.loads((P/'RESULT.json').read_text()),'retained result mismatch') + print(result['status'],json.dumps({k:result[k]for k in ['unique_interfaces','source_occurrences','all_basis_columns']}),'seconds',round(time.monotonic()-t,3))