diff --git a/research/native-lift-phase-tags/.gitattributes b/research/native-lift-phase-tags/.gitattributes new file mode 100644 index 0000000000..e022399ddb --- /dev/null +++ b/research/native-lift-phase-tags/.gitattributes @@ -0,0 +1 @@ +source/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol diff --git a/research/native-lift-phase-tags/CERTIFICATE.json b/research/native-lift-phase-tags/CERTIFICATE.json new file mode 100644 index 0000000000..170c3b9f11 --- /dev/null +++ b/research/native-lift-phase-tags/CERTIFICATE.json @@ -0,0 +1,113 @@ +{ + "schema_version": 1, + "width": 9, + "maps": [ + { + "columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "tag": 0, + "inverse_tag": 0, + "inverse_defect": 0 + }, + { + "columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "tag": 80, + "inverse_tag": 192, + "inverse_defect": 0 + }, + { + "columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "tag": 112, + "inverse_tag": 340, + "inverse_defect": 0 + }, + { + "columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "tag": 144, + "inverse_tag": 68, + "inverse_defect": 256 + } + ], + "signed_word": { + "indices": [ + 0, + 1, + 2, + 3, + 0, + 1 + ], + "signs": [ + 1, + -1, + 1, + 1, + -1, + -1 + ], + "certificate": { + "product": [ + 1, + 2, + 142, + 239, + 50, + 251, + 4, + 160, + 262 + ], + "tag": 156, + "section_tag": 296 + } + }, + "credited_inverse_witness": { + "tag": 144, + "inverse_tag": 68, + "defect": 256 + }, + "frame_rebinding": { + "tag": 144, + "direction": 16, + "required_global_i": true + } +} diff --git a/research/native-lift-phase-tags/PROOF.md b/research/native-lift-phase-tags/PROOF.md new file mode 100644 index 0000000000..c87b16a3c5 --- /dev/null +++ b/research/native-lift-phase-tags/PROOF.md @@ -0,0 +1,195 @@ +# Explicit phase tags for the source-defined native lift + +## Scope and conventions + +Chris R / Clear1nsight's PR3987, scientific head +`fc536202fdaa924158789a5ef59ac079bbe21922`, already proves that the canonical +lift cocycle is an even linear character and supplies the actual inverse +witness with defect `Z_256`. Its source uses the correct adjoint; there is no +author bug to repair. The present addition is an explicit trivialization of +that cocycle, an arbitrary signed-word tag rule and the required compensation +when using the normalized section inside a frame. The representation-theoretic +conjugation below is elementary; it is not claimed as a new general Clifford +construction or as a native compiler modification. + +Retain the source's ket convention, binary column matrices and right-to-left +operator composition. For `x in F_2^n`, + +``` +P_G |x> = |Gx>, Z_t |x> = (-1)^(t dot x)|x>, +D |x> = i^wt(x)|x>. +``` + +All matrix operations in binary forms are over F_2; Hamming weights are +ordinary integers, reduced modulo four only in phases. Take any positive n +and any invertible binary G. Define exactly the source's canonical refinement + +``` +Q_G = I + G^-T G^-1, +q_Q(y) = sum_j Q_jj y_j + 2 sum_(j = i^q_(Q_G)(Gx) |Gx>. +``` + +These are ideal exact operators on arbitrary Gaussian-dyadic amplitudes. +No numerical precision, tape, owner, native tariff or all-size admission is +implied by a phase identity. + +## The normalization tag + +Set `J_G=D P_G D^-1`. Then + +``` +J_G |x> = i^(wt(Gx)-wt(x)) |Gx>, +J_H J_G = J_(HG), J_G^adjoint = J_(G^-1). +``` + +These equalities include global phase, because they follow by cancellation +of the same D factors. This section is generally different from K_G. + +For completeness, the difference of their exponents is precisely an even +linear character. Both `q_(Q_G)(Gx)` and `wt(Gx)-wt(x)` have polar form +`2 x^t(G^tG+I)y mod4`. Their parities agree: the diagonal of Q_G is +`j+G^-T j`, where j is the all-ones vector, so its pairing with Gx is +`j dot Gx+j dot x`. Their difference is therefore even, vanishes at zero, +and has zero polar form. Dividing it by two gives a binary linear functional. +Consequently there is a unique input mask t_G with + +``` +q_(Q_G)(Gx) - wt(Gx) + wt(x) = 2(t_G dot x) mod4, +K_G = J_G Z_(t_G), J_G = K_G Z_(t_G). +``` + +Its coefficients require only coordinate inputs: + +``` +(t_G)_j = [q_(Q_G)(G e_j)-wt(G e_j)+1]_4 / 2, +``` + +where the bracket is the residue 0 or 2. Binary inversion and these quadratic +evaluations use polynomial work in n, rather than enumerating all 2^n states. +The universal statement follows from the polar/parity argument, not from +sampling the coordinate inputs. All K and J operators fix `|0>` exactly; +there is no unspecified scalar phase in this normalization. + +## Cocycle, inverse and arbitrary signed words + +Since `Z_t J_G=J_G Z_(G^t t)`, the source cocycle has the explicit form + +``` +K_H K_G = K_(HG) Z_(ell(G,H)), +ell(G,H) = t_G + G^t t_H + t_(HG). +``` + +Masks add by XOR. This is the source's already-proved cocycle with a specified +coboundary, not a claim that the canonical K section itself composes strictly. +For the source-defined witness, + +``` +G = [1,2,8,32,44,128,59,66,489], +G^-1 = [1,2,28,4,79,8,130,32,431], +t_G = 144, t_(G^-1) = 68, +ell(G,G^-1) = 144 + G^t 68 = 256. +``` + +Thus the credited witness `K_(G^-1) K_G=Z_256` remains intact. Its exact +inverse rule is + +``` +K_G^adjoint = Z_(ell(G,G^-1)) K_(G^-1) + = J_(G^-1) Z_(G^-T t_G). +``` + +The side of a tag matters; input and output masks are not interchangeable. + +For a chronological word `W=K_(G_s)^(epsilon_s)...K_(G_1)^(epsilon_1)`, +with each epsilon either +1 or -1, put + +``` +H_i = G_i, d_i=t_(G_i) if epsilon_i=+1; +H_i = G_i^-1, d_i=G_i^-T t_(G_i) if epsilon_i=-1. +``` + +Starting with `P_0=I,v_0=0`, update in chronological order + +``` +P_i = H_i P_(i-1), +v_i = v_(i-1) + P_(i-1)^t d_i. +``` + +Induction using the Z/J commutation rule proves + +``` +W = J_(P_s) Z_(v_s) + = K_(P_s) Z_(v_s+t_(P_s)). +``` + +This is an exact word certificate in the stated K/adjoint alphabet. It does +not normalize arbitrary serialized Clifford recipes, translations or inserted +nonmonomial children without their additional relations. A binary product +alone omits the final mask and need not determine the signed word. + +## A frame cannot silently change its lift convention + +For the source frame `T=K_B C_[r] K_B^adjoint`, compensation gives + +``` +T = J_B (Z_(t_B) C_[r] Z_(t_B)) J_B^adjoint. +``` + +Replacing the middle expression by C_[r] generally changes the intended +native action. To see the exact change, let +`C_u=((1+i)I+(1-i)X_u)/2`, with `X_u|x>=|x+u>`. Then + +``` +Z_t C_u Z_t = C_u if t dot u=0, +Z_t C_u Z_t = i C_u^adjoint if t dot u=1. +``` + +The second branch has a necessary global i. For a product of commuting +coordinate C gates, k selected directions therefore contribute i^k and become +adjoints; the other directions remain unchanged. The new independent checker +corroborates both branches on all 512 columns for the witness tag 144 with +u=1 and u=16, rejecting omission of i. These are deliberately constructed +calibration primitives, not a claim that this exact frame or occurrence is +present in the supplier word. + +Using J internally is consequently a change of signed-lift convention that +requires retained compensating tags, retagged central children and rebound +interfaces. This package leaves the author's existing correct adjoints and +recipes unchanged. It does not assign a free physical implementation to Z +passes or to their possible fusion with neighboring operations. + +## Evidence and remaining obligations + +Six unchanged PR3987 exports bind the definitions, recipes and retained +notices. RECIPES.json contains 40 descriptors and exactly four distinct binary +maps in its changed warp-interface subset. This is not the complete PR3945 +native inventory. The source's 20,480 full local action comparisons and original +inverse/cocycle results retain their original credit; they are not newly +claimed by extracting these four maps. + +The primary checker constructs the tags and word certificates symbolically. +The separate checker imports no primary or predecessor executable. It uses +row/permutation tables, exhaustive permutation inversion and direct weight +phases, checking the four maps and inverses on all 512 states, their 16 ordered +pair products, and every prefix of an eight-gate signed-word fixture. Pair +products and this word are algebraic controls, not asserted chronological +adjacencies in the supplier. It additionally checks all 168 elements of +GL(3,2), all 28,224 ordered pairs on eight states, and 5,376 exact frame columns. +Its compensated frames agree, while 2,688 naive unretagged frame columns +differ. Gaussian numerators are integer pairs with explicit dyadic denominators; +no floating tolerance accepts an equality. These finite checks corroborate the +written arbitrary-dimension and arbitrary-word proof. + +No complete native serialization, full emitted-program replay, recipe +replacement, dirty-buffer return, physical scratch/routing/owner/tape bound, +uniform precision theorem, passing supplier invoice, selected frontier update, +human acceptance or proof-kernel verification is claimed. The useful next step +is a separately priced integration of this explicit tag discipline into one +named physical interface, not a free replacement of K by J. + +Prepared by ToikY with substantial OpenAI Codex assistance and separate AI +implementation/review contexts. Credit Chris R / Clear1nsight's PR3987, +Dugongue's PR3945/3929, Cinna Davis's PR2226, dataisfire's PR3734 and the full +retained native/compiler/phase/owner lineage in the unchanged notices. +Apache-2.0. diff --git a/research/native-lift-phase-tags/README.md b/research/native-lift-phase-tags/README.md new file mode 100644 index 0000000000..b8dbc1d30e --- /dev/null +++ b/research/native-lift-phase-tags/README.md @@ -0,0 +1,101 @@ +# Explicit phase tags for canonical native lifts + +For the exact canonical lift used in [PR3987](https://github.com/CrocSwap/integer-mult-bounds/pull/3987), +this package gives an explicit phase tag, a compositional certificate for any +signed word of those lifts, and the compensation required inside a native frame. +The result is an elementary source-bound normalization lemma and tool. + +Let `D|x>=i^wt(x)|x>` and `J_G=D P_G D^-1`. Then + +``` +K_G = J_G Z_tG, J_H J_G = J_HG, +ell(G,H) = tG + G^t tH + tHG, +(tG)_j = [q_G(G e_j)-wt(G e_j)+1]_4 / 2. +``` + +The bracket is always 0 or 2. [PROOF.md](PROOF.md) proves the formula for every +invertible binary G in every positive dimension using the exact polar form and +parity, then derives arbitrary signed-word certificates without enumerating +the whole state space. The implementation obtains tags from n coordinate +evaluations and tracks their pullbacks in chronological order. `word_certificate` +returns the binary product and both the residual canonical tag and normalized +section tag; optional signs distinguish a canonical binary-inverse lift from +the actual adjoint. + +Chris R / Clear1nsight's PR3987 already proves the general even-linear cocycle +and supplies the actual inverse-defect witness. Those are predecessor results. +The addition here is its explicit coboundary/normalization, signed-word rule and +required central-frame compensation. For its actual witness the input tags are +144 and 68, recovering the credited defect256. The original source already +uses correct adjoints; no author bug or compiler replacement is claimed. + +## The compensation is part of the result + +For `T=K_B C_[r] K_B^adjoint`, the same operator is +`J_B (Z_tB C_[r] Z_tB) J_B^adjoint`. Dropping the middle tags generally changes +T. For the source primitive `C_u=((1+i)I+(1-i)X_u)/2`, an anticommuting tag +gives **`Z_t C_u Z_t=i C_u^adjoint`**, including the necessary global i. +For commuting coordinate primitives, k flipped directions contribute i^k. +The checks include exact calibration counterexamples to the untagged frame +and to omission of this global phase. They are not claimed source occurrences. + +Switching to J therefore requires compensating tags, rebinding the actual +recipes and a paid physical contract. No Pauli pass, global phase, owner change, +precision bound or native implementation is priced as free. No supplier or κ +improvement follows here. + +## Reproduce and evidence + +Standard-library Python3.12, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/native-lift-phase-tags +``` + +`verify.py` authenticates all six retained source exports, extracts only the +four changed-interface maps in the frozen recipe subset, constructs the new +tags/certificates and checks the formulas on all512 states,16 ordered pairs and +a six-gate signed word. These pair/word fixtures are algebraic controls, not +asserted supplier adjacencies. `CERTIFICATE.json` is checked with exact types. +No predecessor executable is imported. + +`independent.py` uses separate rows, exhaustive permutation inversion and direct +weight phases. It checks all168 elements of GL(3,2), all28,224 ordered pairs on +all8 states,5,376 compensated frame columns, the actual maps on512 states and +eight signed-word prefixes. It finds2,688 differing columns when middle tags +are deliberately dropped and checks both central-C branches on1,024 columns. +Finite corroboration and the general proof have distinct scopes. Neither is +human or proof-kernel acceptance. + +`test_verify.py` adds semantic and actual CLI damaged-input controls, normal +and optimized execution, and a read-only Git-free positive export. The package +is self-contained: no pending commit, canonical live fixture, network or +third-party dependency is needed for the three standalone commands. The source +notice's original CRLF bytes are preserved by package-local Git attributes. + +## Open next questions + +1. **One priced physical interface.** Pin an actual K/adjoint/frame sequence, + attach all input/output tags, and compare the compensated word against its + original action. This tests whether the algebra helps compilation. A complete + signed native recipe, caller/helper return and nonzero physical tariff are + not supplied here; stop before expansion if the full bill is unfavorable. +2. **Broader recipe alphabet.** A serialized Clifford word may include + translations and nonmonomial children. Start with one exact such boundary + and state the extra relations and global phase before applying this tag rule. + The proved alphabet is only K_G and its adjoint; the complete PR3945 native + inventory and emitted program are outside the retained four-map subset. + +## Credit + +New normalization proof, word certificates and tests: ToikY with substantial +OpenAI Codex assistance, including separate AI math/test contexts. Apache-2.0. +Chris R / Clear1nsight's PR3987 at +`fc536202fdaa924158789a5ef59ac079bbe21922` owns the audited source convention, +general cocycle proof, inverse witness and finite interface audit. Six source +files are retained byte-for-byte. Credit Dugongue PR3945/3929, dataisfire PR3734, +Cinna Davis PR2226, Tekalign, icekylinx, DreamingOfClouds, Sagar Thakrar, +roger-sato, Arham Tahir and the retained native/compiler/phase/owner lineage in +`source/SOURCE-CREDITS.md` and `source/NOTICE-PR3945.md`. Those broader claims +were not replayed or admitted here. Frozen sources and selected frontier remain +unchanged. TASK records handoff-first selection and changed catalogue scope. diff --git a/research/native-lift-phase-tags/SOURCES.json b/research/native-lift-phase-tags/SOURCES.json new file mode 100644 index 0000000000..f252d2c59c --- /dev/null +++ b/research/native-lift-phase-tags/SOURCES.json @@ -0,0 +1,75 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ], + "source_exports": [ + { + "path": "research/native-lift-phase-tags/source/NOTICE-PR3945.md", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_path": "research/staged544-native-quadratic-audit/NOTICE-PR3945.md", + "git_blob": "6dcffa5dfbcf15cdffdcca56115e705e354a0907", + "sha256": "6881464d7731757b63275f056cb9ef8406db04e76c73093d3e5b418529a879cc", + "usage": "package-local byte-exact source export; both standalone checkers hardcode SHA256; no predecessor executable imported" + }, + { + "path": "research/native-lift-phase-tags/source/PROOF.md", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_path": "research/staged544-native-quadratic-audit/PROOF.md", + "git_blob": "a194ca7dbc73de6d4eb78902a9be8635494c515a", + "sha256": "111e31099e97d4f9a376d77ca1159d6ba89e2a6b7dd36d8386888c9b91639e25", + "usage": "package-local byte-exact source export; both standalone checkers hardcode SHA256; no predecessor executable imported" + }, + { + "path": "research/native-lift-phase-tags/source/README.md", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_path": "research/staged544-native-quadratic-audit/README.md", + "git_blob": "cd92a14c733dda76d5572717f4f03d52c256bc1c", + "sha256": "06163fba5ef8fcca2a6940313ffb506320206ce47d2cf1c4eceb8fd0d8039bfd", + "usage": "package-local byte-exact source export; both standalone checkers hardcode SHA256; no predecessor executable imported" + }, + { + "path": "research/native-lift-phase-tags/source/RECIPES.json", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_path": "research/staged544-native-quadratic-audit/RECIPES.json", + "git_blob": "a24e14593fcbf447d874cba7c7125eeb1a803d6b", + "sha256": "64b85f6aef485026eebaec7acddb41999f57e074b0dfde8077b6543700cd684b", + "usage": "package-local byte-exact source export; both standalone checkers hardcode SHA256; no predecessor executable imported" + }, + { + "path": "research/native-lift-phase-tags/source/SOURCE-CREDITS.md", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_path": "research/staged544-native-quadratic-audit/SOURCE-CREDITS.md", + "git_blob": "c054fad87eeaa510865e682ee0c976c4cd728da2", + "sha256": "d4a13d8b8ed9cdb594f00efb3d1a336e09d934423330f02a1514308a720c278b", + "usage": "package-local byte-exact source export; both standalone checkers hardcode SHA256; no predecessor executable imported" + }, + { + "path": "research/native-lift-phase-tags/source/exact_phase.py", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_path": "research/staged544-native-quadratic-audit/exact_phase.py", + "git_blob": "4659b91e1b997a22e98a8631947aa79193fcf96f", + "sha256": "e3d76b3373ff40a83a4b212b3fe1c0b431b3cfdc807da601d6e7f273c02c6d30", + "usage": "package-local byte-exact source export; both standalone checkers hardcode SHA256; no predecessor executable imported" + } + ], + "source_export_contract": "No foreign pending commit is a Git-history dependency. Six exact exports are package-local and hash-authenticated before data reads; no predecessor executable imported. RECIPES is only four-map changed-interface subset, not fullnativeinventory. Generichistory checks cover canonical provenance, not scientific acceptance." +} diff --git a/research/native-lift-phase-tags/TASK.json b/research/native-lift-phase-tags/TASK.json new file mode 100644 index 0000000000..ac30f35cfd --- /dev/null +++ b/research/native-lift-phase-tags/TASK.json @@ -0,0 +1,92 @@ +{ + "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": "changed", + "actual_scope": "Explicit phase-tag trivialization of the source-defined canonical lift cocycle, arbitrary signed-word certificates and mandatory central-frame compensation.", + "scope_change_reason": "Handoff-first inspection of PR3987 identified a bounded normalization implication beyond its already-proved cocycle and inverse warning. Changed scope from the catalogue coordinated-rank/moment audit, with no native implementation expansion.", + "bottleneck_link": "Makes missing signed information computable and compositional at a native interface while exposing required central-child/global-phase compensation; binary equality alone is insufficient.", + "budget_minutes": 60, + "stop_rule": "One exact normalization and signed-word rule. Stop on counterexample, covered scope, or any need to count unpriced physical changes as free. Science cutoff09:16:59UTC and final15minutes reserved for verification/handoff.", + "outcome": "partial", + "evidence": "PROOF proves everydimension phase section and signed-word recurrence. Primary checks frozen four actual maps and typed certificate; separate row/permutation implementation exhaustsGL(3,2) and frame controls. Semantic, damaged-source, optimized and read-only Git-free checks distinguish algebra from native admission.", + "author": "ToikY", + "ai_assistance": "Substantial OpenAI Codex assistance in proof, implementation, testing and separate AI math/test review contexts; not independent human or proof-assistant review.", + "selection": { + "method": "handoff-first, followed by named catalogue provenance; no random task reroll", + "handoff": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/3987#issuecomment-6263187495", + "scope_key": "c191650c0fa8d2fa514e", + "entry_open_pr_bodies_including_drafts": 702, + "pagination": "eight nonempty REST pages plus empty ninth; all702 IDs unique", + "checked_at_utc": "2026-10-19T08:33:12Z", + "decision": "Continue bounded algebraic follow-up. PR3987 owns general cocycle and inverse witness; explicitJ section, coboundary, signed-word tag and centralC compensation are the delta. No full interface replay or change to correct source adjoints.", + "coverage_limit": "All open PR bodies including drafts, repository helper and live1166/current-source comments checked; default-main targeted search bounded. Broader Discussions, closed diffs and arbitrary code not exhaustive; no novelty inference from no-match.", + "pre_submission": { + "checked_at_utc": "2026-10-19T08:46:12Z", + "canonical_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "source_head": "fc536202fdaa924158789a5ef59ac079bbe21922", + "newest_open_pr_bodies": 100, + "latest_new_pr": 4000, + "decision": "Continue exact normalization lemma; main and frozen source unchanged. Latest4000BIT-fusion and3997joint-plane-census updates are distinct. No dependent native expansion." + } + }, + "open_questions": [ + { + "question": "Can one actual physical interface use this phase-tag rule with a complete paid contract?", + "why_it_matters": "Correct signed normalization does not price native tags, wrappers or caller return.", + "first_step": "Pin one exactK/adjoint/frame sequence and attach every input/output tag and global phase. Compare compensated action and full bill.", + "blocked_by": "Recipe rebinding, dirtyhelpers/owners, routing/precision/tape and favorable complete invoice are not supplied." + }, + { + "question": "How do translations and nonmonomial children extend the signed-word certificate?", + "why_it_matters": "The proved alphabet is only sourceK_G and itsadjoint, not everyserializedCliffordrecipe.", + "first_step": "Choose one exact wider boundary and derive the extra signedrelations before compiling.", + "blocked_by": "Broaderrecipealphabet and fullnativeinventory not covered." + } + ] +} diff --git a/research/native-lift-phase-tags/VERIFY.json b/research/native-lift-phase-tags/VERIFY.json new file mode 100644 index 0000000000..2553a5ed8a --- /dev/null +++ b/research/native-lift-phase-tags/VERIFY.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Exactsourcepins; explicitphase tags,coboundary,inverses andsixgate signedword certificate; centralC globali; typedreceipt." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 60, + "checks": "Separate row/permutation oracle; all168GL3 maps and28224orderedpairs/all8states; actualfourmap512states; signedprefixes andcompensated/naiveframe/globalphasecontrols." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 60, + "checks": "Semantic tag,pullback,order/inverse/globalphase controls plusdamagedactualCLI sources/certificate; normal/optimized andread-onlyGit-free positive replays." + } + ] +} diff --git a/research/native-lift-phase-tags/independent.py b/research/native-lift-phase-tags/independent.py new file mode 100644 index 0000000000..95e3798b73 --- /dev/null +++ b/research/native-lift-phase-tags/independent.py @@ -0,0 +1,241 @@ +#!/usr/bin/env python3 +"""Permutation-table oracle for the source-defined canonical lifts. + +No primary/predecessor executable is imported. Gaussian sparse vectors are +integer pairs with a common dyadic denominator. Apache-2.0; ToikY with +substantial OpenAI Codex assistance, not independent human/kernel review. +""" +from __future__ import annotations + +import hashlib +import itertools +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PINS = { + "PROOF.md": "111e31099e97d4f9a376d77ca1159d6ba89e2a6b7dd36d8386888c9b91639e25", + "README.md": "06163fba5ef8fcca2a6940313ffb506320206ce47d2cf1c4eceb8fd0d8039bfd", + "RECIPES.json": "64b85f6aef485026eebaec7acddb41999f57e074b0dfde8077b6543700cd684b", + "exact_phase.py": "e3d76b3373ff40a83a4b212b3fe1c0b431b3cfdc807da601d6e7f273c02c6d30", + "SOURCE-CREDITS.md": "d4a13d8b8ed9cdb594f00efb3d1a336e09d934423330f02a1514308a720c278b", + "NOTICE-PR3945.md": "6881464d7731757b63275f056cb9ef8406db04e76c73093d3e5b418529a879cc", +} + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def weight(value): + return bin(value).count("1") + + +def parity(value): + return weight(value) % 2 + + +def tables(columns): + """Invert a complete permutation, without primary binary elimination.""" + n = len(columns) + require(all(type(c) is int and 0 <= c < 1 << n for c in columns), "column domain") + rows = [sum(((column >> row) & 1) << index for index, column in enumerate(columns)) + for row in range(n)] + forward = tuple(sum(parity(row & x) << index for index, row in enumerate(rows)) + for x in range(1 << n)) + require(len(set(forward)) == 1 << n, "invertible binary permutation") + inverse = tuple(dict((y, x) for x, y in enumerate(forward))[y] for y in range(1 << n)) + inverse_columns = tuple(inverse[1 << i] for i in range(n)) + form = [[(parity(a & b) + int(i == j)) % 2 + for j, b in enumerate(inverse_columns)] for i, a in enumerate(inverse_columns)] + canonical = [] + normal = [] + for x, y in enumerate(forward): + active = [i for i in range(n) if y & (1 << i)] + phase = sum(form[i][i] for i in active) + phase += 2*sum(form[i][j] for i in active for j in active if i < j) + canonical.append(phase % 4) + normal.append((weight(y)-weight(x)) % 4) + differences = [(a-b) % 4 for a, b in zip(canonical, normal)] + require(all(d in (0, 2) for d in differences), "same quadratic parity") + tag = sum((differences[1 << i]//2) << i for i in range(n)) + require(all(d == 2*parity(tag & x) for x, d in enumerate(differences)), + "canonical versus functorial input tag") + return {"columns": tuple(columns), "perm": forward, "back": inverse, + "canonical": tuple(canonical), "normal": tuple(normal), "tag": tag, + "inverse_columns": inverse_columns} + + +def pullback(columns, character): + return sum(parity(column & character) << index for index, column in enumerate(columns)) + + +def check_pair(first, second, product): + """Chronology first then second; operator product is second*first.""" + character = first["tag"] ^ pullback(first["columns"], second["tag"]) ^ product["tag"] + for x, y in enumerate(first["perm"]): + require(second["perm"][y] == product["perm"][x], "binary product") + require((first["normal"][x]+second["normal"][y]) % 4 == product["normal"][x], + "strict J composition with full phase") + defect = (first["canonical"][x]+second["canonical"][y]-product["canonical"][x]) % 4 + require(defect == 2*parity(character & x), "explicit cocycle coboundary") + return character + + +def signed_table(data, sign): + if sign == 1: + return data["perm"], data["canonical"], data["columns"], data["tag"] + require(sign == -1, "signed word alphabet") + phase = tuple((-data["canonical"][x]) % 4 for x in data["back"]) + tag = pullback(data["inverse_columns"], data["tag"]) + return data["back"], phase, data["inverse_columns"], tag + + +def word_checks(actual): + sequence = [(actual[index], sign) for index, sign in + [(0, 1), (2, -1), (1, 1), (3, -1), (0, -1), (1, -1), (2, 1), (3, 1)]] + n = len(actual[0]["columns"]) + permutation = tuple(range(1 << n)) + phases = (0,)*(1 << n) + columns = tuple(1 << i for i in range(n)) + section_tag = 0 + checks = 0 + for data, sign in sequence: + gate_perm, gate_phase, gate_columns, gate_tag = signed_table(data, sign) + section_tag ^= pullback(columns, gate_tag) + columns = tuple(gate_perm[column] for column in columns) + phases = tuple((phase+gate_phase[y]) % 4 for phase, y in zip(phases, permutation)) + permutation = tuple(gate_perm[y] for y in permutation) + combined = tables(columns) + for x in range(1 << n): + require(permutation[x] == combined["perm"][x], "signed-word product") + require(phases[x] == (combined["normal"][x]+2*parity(section_tag & x)) % 4, + "signed-word section tag") + residual = section_tag ^ combined["tag"] + require(phases[x] == (combined["canonical"][x]+2*parity(residual & x)) % 4, + "signed-word canonical tag") + checks += 1 + return checks + + +def rotate(value, phase): + real, imag = value + return ((real, imag), (-imag, real), (-real, -imag), (imag, -real))[phase % 4] + + +def coordinate_gates(state, count): + for axis in range(count): + result = {} + for x, (real, imag) in state.items(): + for y, addition in ((x, (real-imag, real+imag)), + (x ^ (1 << axis), (real+imag, imag-real))): + a, b = result.get(y, (0, 0)) + result[y] = (a+addition[0], b+addition[1]) + state = {x: value for x, value in result.items() if value != (0, 0)} + return state + + +def frame_column(data, count, x, mode): + """All versions have denominator 2^count; compare integer numerators.""" + inverse_x = data["back"][x] + original = mode == "canonical" + phases = data["canonical"] if original else data["normal"] + value = rotate((1, 0), -phases[inverse_x]) + if mode == "compensated": + value = rotate(value, 2*parity(data["tag"] & inverse_x)) + state = coordinate_gates({inverse_x: value}, count) + result = {} + for y, value in state.items(): + phase = phases[y] + if mode == "compensated": + phase += 2*parity(data["tag"] & y) + result[data["perm"][y]] = rotate(value, phase) + return result + + +def two_branch_check(tag): + """The inverse branch carries a necessary global i, even on one C gate.""" + checked = 0 + for u in (1, 16): + branch = parity(tag & u) + for x in range(512): + before = 2*parity(tag & x) + actual = {x: rotate((1, 1), before+2*parity(tag & x)), + x ^ u: rotate((1, -1), before+2*parity(tag & (x ^ u)))} + if branch: + inverse = {x: (1, -1), x ^ u: (1, 1)} + expected = {y: rotate(value, 1) for y, value in inverse.items()} + require(actual != inverse, "missing global i must change the operator") + else: + expected = {x: (1, 1), x ^ u: (1, -1)} + require(actual == expected, "literal two-branch central-C retag") + checked += 1 + return checked + + +def audit(): + for name, pin in PINS.items(): + require(hashlib.sha256((HERE/"source"/name).read_bytes()).hexdigest() == pin, + "independent source bytes: " + name) + items = json.loads((HERE/"source/RECIPES.json").read_bytes())["items"] + columns = sorted({tuple(item["G_columns"]) for item in items if item["kind"] == "warp"}) + require(len(items) == 40 and len(columns) == 4, "changed-interface source inventory") + actual = [tables(g) for g in columns] + for data in actual: + inverse = tables(data["inverse_columns"]) + for x, y in enumerate(data["perm"]): + require((data["normal"][x]+inverse["normal"][y]) % 4 == 0, + "J inverse equals its adjoint") + check_pair(data, inverse, tables(tuple(1 << i for i in range(9)))) + for first in actual: + for second in actual: + product = tables(tuple(second["perm"][column] for column in first["columns"])) + check_pair(first, second, product) + witness_columns = (1, 2, 8, 32, 44, 128, 59, 66, 489) + witness = next(data for data in actual if data["columns"] == witness_columns) + witness_inverse = tables(witness["inverse_columns"]) + require(witness["tag"] == 144 and witness_inverse["tag"] == 68, + "source-defined witness normalization tags") + require(check_pair(witness, witness_inverse, tables(tuple(1 << i for i in range(9)))) == 256, + "credited inverse-defect witness") + branch_checks = two_branch_check(witness["tag"]) + signed_checks = word_checks(actual) + + group = {} + for candidate in itertools.product(range(8), repeat=3): + # A permutation test screens the 512 matrices without trusting elimination. + image = {sum(parity(row & x) << i for i, row in enumerate( + [sum(((c >> r) & 1) << j for j, c in enumerate(candidate)) for r in range(3)])) + for x in range(8)} + if len(image) == 8: + group[candidate] = tables(candidate) + require(len(group) == 168, "complete GL(3,2)") + pair_states = 0 + frame_states = 0 + naive_differences = 0 + for first in group.values(): + for second in group.values(): + product_columns = tuple(second["perm"][column] for column in first["columns"]) + check_pair(first, second, group[product_columns]) + pair_states += 8 + for count in range(4): + for x in range(8): + correct = frame_column(first, count, x, "canonical") + require(frame_column(first, count, x, "compensated") == correct, + "mandatory central-C frame compensation") + if frame_column(first, count, x, "naive") != correct: + naive_differences += 1 + frame_states += 1 + require(naive_differences > 0, "unretagged J substitution must not be accepted") + return {"changed_interface_maps": 4, "actual_basis_states_per_map": 512, + "actual_ordered_pairs": 16, "signed_word_prefix_state_checks": signed_checks, + "gl3_maps": 168, "gl3_ordered_pairs": 28224, "gl3_pair_state_checks": pair_states, + "gl3_frame_column_checks": frame_states, "naive_frame_column_mismatches": naive_differences, + "central_C_branch_column_checks": branch_checks, + "witness_input_tag": 144, "witness_inverse_input_tag": 68, + "credited_inverse_defect": 256, "native_action_replaced": False, "new_kappa": False} + + +if __name__ == "__main__": + print("PASS_INDEPENDENT_NATIVE_LIFT_PHASE_TAGS " + json.dumps(audit(), sort_keys=True)) diff --git a/research/native-lift-phase-tags/source/NOTICE-PR3945.md b/research/native-lift-phase-tags/source/NOTICE-PR3945.md new file mode 100644 index 0000000000..6dcffa5dfb --- /dev/null +++ b/research/native-lift-phase-tags/source/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/native-lift-phase-tags/source/PROOF.md b/research/native-lift-phase-tags/source/PROOF.md new file mode 100644 index 0000000000..a194ca7dbc --- /dev/null +++ b/research/native-lift-phase-tags/source/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/native-lift-phase-tags/source/README.md b/research/native-lift-phase-tags/source/README.md new file mode 100644 index 0000000000..cd92a14c73 --- /dev/null +++ b/research/native-lift-phase-tags/source/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/native-lift-phase-tags/source/RECIPES.json b/research/native-lift-phase-tags/source/RECIPES.json new file mode 100644 index 0000000000..a24e14593f --- /dev/null +++ b/research/native-lift-phase-tags/source/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/native-lift-phase-tags/source/SOURCE-CREDITS.md b/research/native-lift-phase-tags/source/SOURCE-CREDITS.md new file mode 100644 index 0000000000..c054fad87e --- /dev/null +++ b/research/native-lift-phase-tags/source/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/native-lift-phase-tags/source/exact_phase.py b/research/native-lift-phase-tags/source/exact_phase.py new file mode 100644 index 0000000000..4659b91e1b --- /dev/null +++ b/research/native-lift-phase-tags/source/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, + 'phase/sign controls did not distinguish wrong conventions') + +positive=v['word_certificate']([G,Gi]) +adjoint=v['word_certificate']([G,G],[1,-1]) +need(positive=={'product':list(I),'tag':256,'section_tag':256}, 'canonical inverse-pair defect') +need(adjoint=={'product':list(I),'tag':0,'section_tag':0}, 'actual adjoint must cancel') +# A genuine covector pullback differs from applying G to the tag vector. +expected=sum((((G[j]&v['tag'](Gi)).bit_count())%2)<>i)&1)<>j)&1),None) + need(pivot is not None,'singular binary map') + rows[j],rows[pivot]=rows[pivot],rows[j] + for i in range(n): + if i!=j and (rows[i]>>j)&1:rows[i]^=rows[j] + return tuple(sum(((rows[i]>>(n+j))&1)<0,'nonempty binary columns') + g=tuple(g);n=len(g) + need(all(type(x) is int and 0<=x<1<>i)&1: + ans+=((row>>i)&1)+2*((row&y&~((1<<(i+1))-1)).bit_count()) + return ans%4 + +def canonical_phase(g,x): + g=normal(g);y=apply(g,x) + return _q(quadratic(g),y) + +def section_phase(g,x):return (apply(g,x).bit_count()-x.bit_count())%4 + +@lru_cache(maxsize=None) +def _tag(g): + result=0 + for j,col in enumerate(g): + diff=(_q(quadratic(g),col)-(col.bit_count()-1))%4 + need(diff%2==0,'even phase-section difference') + result|=(diff//2)<