From 08b7d336b9ad53332061829b8f76c913bae27833 Mon Sep 17 00:00:00 2001 From: d3lerium Date: Fri, 23 Oct 2026 10:35:41 +1100 Subject: [PATCH 1/2] Prove the all-width two-FULL main-only central obstruction --- research/two-full-central-obstruction/LICENSE | 201 + .../two-full-central-obstruction/ORIGINS.json | 55 + .../two-full-central-obstruction/PROOF.md | 205 + .../two-full-central-obstruction/README.md | 103 + .../two-full-central-obstruction/RESULT.json | 54 + .../two-full-central-obstruction/SOURCES.json | 66 + .../two-full-central-obstruction/TASK.json | 66 + .../two-full-central-obstruction/VERIFY.json | 34 + .../independent/algebra-REVIEW.md | 136 + .../independent/algebra-SOURCES.json | 19 + .../independent/native-ACCOUNTING.json | 225 + .../independent/native-PROVENANCE.json | 39 + .../independent/native-REPORT.md | 110 + .../independent/native-SAME-TWO-BANKS.json | 186 + .../independent/native-WRAPPERS.json | 4162 +++++++++++++++++ .../inputs/native/NATIVE-VALIDATION.json | 142 + .../inputs/native/README.md | 101 + .../native/complex_controller_factor.py | 270 ++ .../inputs/native/native_inventory.py | 270 ++ .../inputs/native/query_thinned_verify.py | 202 + .../predecessors/PR4666-GLOBAL-PROOF.md | 183 + .../two-full-central-obstruction/verify.py | 239 + 22 files changed, 7068 insertions(+) create mode 100644 research/two-full-central-obstruction/LICENSE create mode 100644 research/two-full-central-obstruction/ORIGINS.json create mode 100644 research/two-full-central-obstruction/PROOF.md create mode 100644 research/two-full-central-obstruction/README.md create mode 100644 research/two-full-central-obstruction/RESULT.json create mode 100644 research/two-full-central-obstruction/SOURCES.json create mode 100644 research/two-full-central-obstruction/TASK.json create mode 100644 research/two-full-central-obstruction/VERIFY.json create mode 100644 research/two-full-central-obstruction/independent/algebra-REVIEW.md create mode 100644 research/two-full-central-obstruction/independent/algebra-SOURCES.json create mode 100644 research/two-full-central-obstruction/independent/native-ACCOUNTING.json create mode 100644 research/two-full-central-obstruction/independent/native-PROVENANCE.json create mode 100644 research/two-full-central-obstruction/independent/native-REPORT.md create mode 100644 research/two-full-central-obstruction/independent/native-SAME-TWO-BANKS.json create mode 100644 research/two-full-central-obstruction/independent/native-WRAPPERS.json create mode 100644 research/two-full-central-obstruction/inputs/native/NATIVE-VALIDATION.json create mode 100644 research/two-full-central-obstruction/inputs/native/README.md create mode 100644 research/two-full-central-obstruction/inputs/native/complex_controller_factor.py create mode 100644 research/two-full-central-obstruction/inputs/native/native_inventory.py create mode 100644 research/two-full-central-obstruction/inputs/native/query_thinned_verify.py create mode 100644 research/two-full-central-obstruction/inputs/predecessors/PR4666-GLOBAL-PROOF.md create mode 100644 research/two-full-central-obstruction/verify.py diff --git a/research/two-full-central-obstruction/LICENSE b/research/two-full-central-obstruction/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/two-full-central-obstruction/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/two-full-central-obstruction/ORIGINS.json b/research/two-full-central-obstruction/ORIGINS.json new file mode 100644 index 0000000000..18c187b1be --- /dev/null +++ b/research/two-full-central-obstruction/ORIGINS.json @@ -0,0 +1,55 @@ +{ + "schema_version": 1, + "canonical_base": "624de9dc66858af0945e5f8a0942488d62280d43", + "native_source": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "files": [ + { + "local_path": "inputs/native/complex_controller_factor.py", + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_path": "research/kappa-rebuild/bit/complex_controller_factor.py", + "git_blob": "cb0cff7c8be5f38f2ee52201d9d0907f9dfd7947", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/20bb93cd990d2ff683e4d0fc56b87a42cd5d3296/research/kappa-rebuild/bit/complex_controller_factor.py" + }, + { + "local_path": "inputs/native/native_inventory.py", + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_path": "research/pr4359-p7-padding/native_inventory.py", + "git_blob": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/20bb93cd990d2ff683e4d0fc56b87a42cd5d3296/research/pr4359-p7-padding/native_inventory.py" + }, + { + "local_path": "inputs/native/query_thinned_verify.py", + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_path": "research/query-thinned-controllers/verify.py", + "git_blob": "f1114036fff66f57014e5c1256141fb78ff4c4a9", + "sha256": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/20bb93cd990d2ff683e4d0fc56b87a42cd5d3296/research/query-thinned-controllers/verify.py" + }, + { + "local_path": "inputs/native/NATIVE-VALIDATION.json", + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_path": "research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json", + "git_blob": "d8a2e0a915edce68cfe7472b94bb87dfb9dc24c0", + "sha256": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/20bb93cd990d2ff683e4d0fc56b87a42cd5d3296/research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json" + }, + { + "local_path": "inputs/native/README.md", + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_path": "research/kappa-round3-warp-20261022/README.md", + "git_blob": "e4c18ea0926e0502e6dce637a15a104cccf05624", + "sha256": "6cfcd49a0601f5b1f184a2567fc35dcb0a5c28eb06fce5e510d54895e8d17fde", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/20bb93cd990d2ff683e4d0fc56b87a42cd5d3296/research/kappa-round3-warp-20261022/README.md" + }, + { + "local_path": "inputs/predecessors/PR4666-GLOBAL-PROOF.md", + "source_commit": "08ac39202263203fded429c826ba9228ac9df803", + "source_path": "research/productive-controller-basis-search/GLOBAL-PROOF.md", + "git_blob": "74b67e22e6c063193a83825207cdec19a8fef7a4", + "sha256": "adc377b13924701bf5b0b50b091d8b69c90195d50ce0f6808f7fb4c7e0b16457", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/08ac39202263203fded429c826ba9228ac9df803/research/productive-controller-basis-search/GLOBAL-PROOF.md" + } + ] +} diff --git a/research/two-full-central-obstruction/PROOF.md b/research/two-full-central-obstruction/PROOF.md new file mode 100644 index 0000000000..cb1649cdf5 --- /dev/null +++ b/research/two-full-central-obstruction/PROOF.md @@ -0,0 +1,205 @@ +# Two FULL calls cannot complete two central Gaussian jobs in the main-only model + +Prepared for Chris R / Clear1nsight with substantial OpenAI Codex assistance. +Apache-2.0. This is a written scoped proof with exact finite corroboration and +a separate agent review. It is not a proof-kernel verification or a new kappa. + +## Actual question and boundaries + +The prospective construction in Discussion4902 has two arbitrary 112-field +main banks, two independent 408-helper inventories, and the native supplier's +owned zero centres. Every helper output remains its autonomous, already +specified Gaussian job. Existing transformed helper values are not available +as extra central resources in the main-only controller studied here. + +At frozen source `20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`, each main port of +one FULL invocation, after its authenticated source boundaries, is exactly + + F_s = D_s [[1,0],[Q^-1,1]], + B_s = D_s [[1,-Q],[0,1]]. + +There is one off-diagonal central Gaussian letter per invocation, with no +additional nonmonomial central diagonal factor. The source checks actual +routes and absolute phases, including the inverse/translation convention. +The source all-column implementation is retained as a written premise; this +package does not rerun the native 632-column verification. + +Change the central function by actual columnwise monomial conjugation, for +example S=diag(1,i), acting on both main owners before/after a FULL call. +Different central functions need not commute. The free address grammar is +generated by a fixed finite group of one-column Clifford matrices, lifted +identically in every column. Arbitrary Gaussian-dyadic owner GL operations +and role-dependent admitted monomials are allowed. For the obstruction we +grant arbitrary complex scalar coefficients, even depending on width, and +arbitrary invertible matrices over the free address algebra. This grants +more free operations than a physical implementation supplies. + +The two rank-eight transverse blocks are disjoint from the central axis. +Grant ALL transverse/fresh Clifford operations for free, and central +monomials for free, but retain their tensor-factor separation. This is the +subgroup H used below. Native D_s belong to H and can be absorbed into +adjacent free factors. This does not require D_s to commute with the chosen +S. In particular raw D_0=F_9 Q^-1 has a real translation correction to its +positive transverse-eight normalization; raw D_0 must not be silently +declared to commute with S. The independent source audit emits that exact +correction for all 112 actual ports. + +A main target is a full rank-17 Gaussian up to the declared separated +central/transverse monomial boundaries. It lies outside H: an H element has central Fourier rank zero +and transverse Fourier rank at most sixteen. A central/fresh mixing free +address operation is outside this grammar. Adding arbitrary such mixing +while already granting all fresh Gaussians free could make the central +Gaussian free, invalidating the non-H hypothesis. + +## Algebraic theorem + +Let A be a finite-dimensional twisted group algebra over an infinite field +K, on a finite group Gamma. Its basis multiplication is group multiplication +times nonzero scalar cocycle factors. Let Lambda be a subgroup, and B its +twisted subgroup algebra. Let pi:A->B retain just basis terms in Lambda. +It is a B-bimodule map: left/right multiplication by Lambda preserves both +Lambda and its complement. No domain or positivity property is assumed. + +Take n>=2 owners, including any additional dirty scratch owners returned +unchanged. Let L,W,R be arbitrary invertible matrices in Mat_n(B). Two paid +letters, with a,b supported on individual basis elements outside Lambda, +have the form + + M = L (I+e_i b e_j^T) W (I+e_k a e_l^T) R, + i!=j, k!=l. (1) + +Signs, inverses, monomial pre/post factors, arbitrary orientations, and +different noncommuting central functions are permitted. Nonzero scalar +coefficients can be included in a,b. The physical F/B alphabet is a subset. + +Let d=dim_K B. Then + + dim_K ker pi(M) <= d, (2) + +where pi(M) acts by left multiplication on the right B-module B^n. +Consequently (1) cannot equal a target whose first two projected input +columns vanish; in particular it cannot equal diag(g1,g2,I,...,I) for +independent g1,g2 outside Lambda. + +### Proof + +Expand (1). The term containing no paid letter projects to LWR. Each +single-paid term vanishes under pi, because B a B and B b B have no +Lambda-supported term. The double-paid term has only the selected middle +entry W_jk between its two non-B letters. By the bimodule property, + + pi(M) = L [W + e_i c e_l^T] R, + c = pi(b W_jk a). (3) + +W is invertible on the K-vector space B^n of dimension nd. The perturbation +e_i c e_l^T factors through one copy of B and has image dimension at most +d. If x belongs to the kernel of W+e_i c e_l^T, then Wx lies in that image. +The map x->Wx is injective, so its kernel dimension is at most d. Left/right +multiplication by invertible L,R preserves that dimension, proving (2). + +Two vanished projected input columns instead put two independent copies +of B in the kernel, of total dimension 2d. This contradicts (2). The +argument explicitly permits zero divisors and idempotents in B. + +The same obstruction excludes zero or one paid letter: the projection is +then an invertible free matrix. Arbitrary identity scratch and arbitrary +outer owner GL operations remain in the theorem. Existing transformed +helper jobs are different: their non-B input states cannot be inserted +as identity scratch or absorbed into L,W,R over B. + +## All positive widths, including width-dependent scalar choices + +Let G be the finite group of exact one-column Clifford matrices needed for +the stated address grammar, including its absolute scalar phases. One may +take the full finite seventeen-axis Clifford group; H is the subgroup +retaining the central-monomial/transverse-Clifford separation. Let Z be the +subgroup of scalar matrices. H contains Z. + +At width f, literal address words act as rho(g)^(tensor f). A product of +words lifts as the product of their tensor lifts. A sum of owner-operator +entries lifts by retaining its scalar coefficients; it is not replaced by +the tensor power of a sum. A phase word z=ζI acts as ζ^f, not scalar ζ. + +Choose representatives v_t for the s=|G/Z| projective matrix classes. +For any t and u!=t, projective distinctness gives a linear functional +ell_tu on the one-column matrix space which vanishes on v_u and not on +v_t. The product over u!=t has degree s-1 and isolates v_t. For any +f>=s-1, multiply by a power of a functional nonzero on v_t. This is a +degree-f functional on tensor powers which annihilates all v_u^(tensor f) +except v_t^(tensor f). Thus these s tensor vectors are linearly independent +for every f>=s-1. + +For each such f quotient K[G] by the central-character relations + + z = ζ_z^f. + +The resulting A_f is the twisted group algebra on G/Z; its tensor +representation is injective by the preceding argument. The corresponding +B_f on H/Z has dimension |H/Z|. Projection pi_f onto H/Z is still a +B_f-bimodule map: phase cocycles change coefficients, not support membership. + +Any exact operator identity at that width therefore gives an identity in +A_f. Apply (2) separately at this width. It fails for every sufficiently +large f, even if scalar coefficients and free word choices depend on f. +An alleged construction valid at every positive width is impossible. +This is an existence proof; no enumeration of a huge seventeen-axis group +or of physical tape words is needed. + +For the reduced central one-axis model, the concrete generators used by +the checker have |G|=96, |Z|=4, |G/Z|=24, |H/Z|=8. The sufficient width +bound is f>=23. The full transverse/scratch relaxation uses its own finite +G and finite sufficient bound; 23 is not asserted for that enlarged group. + +## Finite corroboration and discriminating controls + +The standard-library checker constructs the exact 96-element central group +using Gaussian rational entries. Q^2 is the translation X, not identity. +It authenticates all 32 monomial elements, all 98,304 subgroup-support +bimodule checks, and 64 exact two-letter expansion fixtures with genuinely +nontrivial free L/W/R, both orientations, inverses and S conjugation. +These fixtures corroborate (3); they are not a complete circuit enumeration. + +A separate modular Gram calculation proves exact independence of the +24 projective tensor vectors at widths 23,24,25,26: rank 24 over the field +F_1000003[i], i^2=-1, implies rank 24 in characteristic zero. It is a small +finite control of the written all-width argument, not a replacement for it. + +The three-query word with opposite shears and a scalar signed swap returns +diag(Q^-1,Q) exactly in the group algebra. It is a positive control for +complete arbitrary-dirty targets and shows why the projection argument +stops at two letters. It supplies no profitable three-FULL invoice. + +Two semantic fault controls expose the specific bad width-one shortcuts: +the matrix relation Q=((1+i)/2)I+((1-i)/2)X holds at one column but its +scalar sum fails at width two; and the word iI tensors to i^f I, not scalar +iI at every width. Enlarging the free subgroup to contain Q is explicitly +an invalidation of the theorem's hypothesis, not a new negative result. + +No native scientific suite, whole caller/compiler/outer replay, numerical +root search, Lean build or physical tape benchmark is run here. Exact +source hashes and separate source/invoice audit evidence are retained. + +## Credit and nearest predecessor scope + +Cinna Davis / 1337isnot1337's #4666, exact head +`08ac39202263203fded429c826ba9228ac9df803`, proves binary all-full and +minimum-query controller restrictions with independent stage multipliers. +Its common-even-part/rank-factorization approach is relevant predecessor +motivation. Its theorem explicitly does not cover arbitrary complex dyadic +boundaries or changed central queries. This proof uses a monomial-subgroup +bimodule projection and a two-letter nullity bound in characteristic zero, +retaining different noncommuting functions and absolute phases. + +Nick Petalas's #4875, exact head +`e1f0906c35defdc4704f2b3e5e954c2a62981791`, extends Richard Hoekstra's +same-phase rank-three dirty-shear six-call bound to three character values. +It studies a different endpoint and common C/C^-1 alphabet, whereas the +present endpoint has two independent nonmonomial Gaussian jobs. No claim +to replace its theorem or its first/last-row argument is made. + +Credit the source native/helper/Clifford interfaces to Cinna Davis, +Cao Yifan, zxv, Jacob Alan Sussman, Ali Romman, Dugongue and their retained +predecessors. Finite-dimensional rank and separating-polynomial arguments +are elementary tools, with no literature-priority claim. A separate +gpt-6.1-sol/high agent independently reviewed the projection and all-width +arguments; this is not independent human or proof-kernel acceptance. diff --git a/research/two-full-central-obstruction/README.md b/research/two-full-central-obstruction/README.md new file mode 100644 index 0000000000..b5322ac29d --- /dev/null +++ b/research/two-full-central-obstruction/README.md @@ -0,0 +1,103 @@ +# Two changed central functions still cannot complete the two-FULL main-only unit + +**Scoped written obstruction with exact corroboration; no new kappa.** +Two FULL calls of frozen native source +`20bb93cd990d2ff683e4d0fc56b87a42cd5d3296` cannot complete both proposed +independent main-bank Gaussian jobs in the declared columnwise central-word +model. Different noncommuting monomial-conjugate central functions, arbitrary +external owner GL boundaries, arbitrary restored dirty scratch and even +width-dependent scalar coefficients do not remove the obstruction. + +The source helpers remain autonomous and untouched by this main-only +controller. Existing transformed helper values, arbitrary width-specific +address matchers, or central/fresh mixing outside the stated subgroup are +different models. This theorem does not exclude those changes. + +The optimistic target `224 H17 + 2 H` against `2 P` passes its raw budget. +The missing endpoint is nevertheless impossible in this model: project the +literal two-call word onto the free monomial subgroup algebra. Its projection +is an invertible free matrix plus one outer product, so at most one free +owner module can disappear. Two independent nonmonomial targets require +two disappeared modules. [PROOF.md](PROOF.md) gives the exact argument and +all-width phase quotient, including the fresh-axis/scratch scope. + +The exact checker reconstructs a 96-element one-axis Clifford group, a +32-element monomial subgroup, 98,304 support checks, 64 expansion fixtures, +four exact modular tensor-Gram ranks and a complete three-query positive +control. Width-one sum and global-phase mistakes are explicitly detected. +No free-word or circuit search was necessary after the algebraic gate failed. + +## Reproduce + +From the package directory, using Python 3.12 and only its standard library: + +```sh +python3 -I -W error -B verify.py +python3 -I -O -W error -B verify.py +``` + +The verifier is read-only by default. It checks the frozen source bytes, +requires and compares the committed RESULT.json, and emits +`PASS_TWO_FULL_CENTRAL_OBSTRUCTION_MODEL`. Optional `--write-receipt NEW_PATH` +creates a fresh receipt and refuses an existing destination. The native and +compiler verifiers are not imported or executed. + +## Sources, review and limits + +Canonical scientific base is +`624de9dc66858af0945e5f8a0942488d62280d43`; selected conditional kappa +remains 0.00302015. This work answers the prospective +[Discussion4902 contract](https://github.com/CrocSwap/integer-mult-bounds/discussions/4902). +ORIGINS.json authenticates copied exact native and predecessor input files; +SOURCES.json/VERIFY.json provide the opt-in package bindings. The autonomous +owned-zero-centre ABI is distinguished from the retained640 arbitrary-centre +ABI. No independent centre reward is introduced. + +Source raw D0 does not automatically commute with the proposed diagonal S. +Its exact translation correction is a free-subgroup word, so the proof +absorbs D0 into free boundary factors instead of assuming that commutation. +The independent wrapper audit records all 112 actual corrections. + +The frozen independent evidence is under `independent/native-*`. The registered +central-model checker authenticates those exact files and the cited native +source bytes. It does not regenerate the independent audit's 112-port phase +checks or its interval arithmetic. Its PROVENANCE.json explicitly records that +the original audit replay uses local sibling support scripts and the pinned +Git object. Those local runs were performed normally and optimized by the +separate source/accounting agent. No portable native-audit replay is claimed +by the central-model command. + +Credit Cinna Davis / 1337isnot1337 #4666 for the binary controller +obstructions and native lineage; Cao Yifan, zxv, Jacob Alan Sussman, +Ali Romman, Dugongue and retained contributors for the actual native, +Clifford, compiler and outer interfaces; Nick Petalas #4875 and Richard +Hoekstra #1318 for the distinct same-phase shear restrictions. Exact heads +and scope differences are in PROOF.md. Prepared for Chris R / Clear1nsight +with substantial OpenAI Codex assistance. Apache-2.0. Separate agent review +is disclosed, with no independent human or formal-kernel acceptance claim. + +## Open next questions + +The next useful changed mechanism must supply a non-B resource already paid +elsewhere, remove an actual native child, or change the target inventory. +Using existing transformed helper state could do this, but requires its +actual arbitrary-input chronological owner contract and a complete return +invoice; it must not be modelled as identity scratch. A larger free-word +search inside the present alphabet cannot change this endpoint decision. +The structured TASK.json records this reopening condition. + +Three FULL calls can realize the central endpoint, but the complete source +inventory must still pass its own moment screen. No three-call profitability, +physical implementation, native all-column audit, compiler extension or +higher kappa is claimed by this package. + +The separate source/accounting audit also rejects the next unchanged invoice: +three FULL calls on the same two banks have margin in +`[-58.916072241014304,-58.916072241014303]` at C=.0030217758. Its sign-separated +coefficient argument rejects every larger C through 1; four or more FULL calls +with only `224 H(8n+1)+nH` targets are negative for every C in [0,1]. These are +source-bound necessary budget tests, separate from the two-call operator proof. +At the funded comparison, an actual three-call improvement must save more +than 58.916072241014304 in moment before any new work or reserve. Hypothetical +single-rank alternatives include deleting 59 H1 or 8 H8 paid calls, or adding +seven truly independent H9 targets; none is an available construction here. diff --git a/research/two-full-central-obstruction/RESULT.json b/research/two-full-central-obstruction/RESULT.json new file mode 100644 index 0000000000..7dbfe8b183 --- /dev/null +++ b/research/two-full-central-obstruction/RESULT.json @@ -0,0 +1,54 @@ +{ + "bimodule_support_checks": 98304, + "group_order": 96, + "limits": "Written theorem supplies universal quantifiers; central finite model only, no native/outer replay.", + "monomial_subgroup_order": 32, + "no_new_kappa": true, + "own_files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "ORIGINS.json": "6f977f3b457ab0b8b95f2819b680ff450e6df1532ef1e721cac4eb083960b21d", + "PROOF.md": "71cb1a2f41d6376b4e3e23667f2c31a192f566ca9c8a2422d732c2a9dd7cb6fb", + "README.md": "76cf36a478951b984a19703d30d815ec001d05fb2c8164079839d35c139b10c2", + "SOURCES.json": "69b0603e6c62cab5d70aaad2379cb26cbebfa2adb761d23003f3ac20ea55ff72", + "TASK.json": "70eca26a933416627cd79edc451844506f996b2fce411ce4a93b42fcc2aa62a2", + "VERIFY.json": "ae8ef73ebd3541e125e56e0069f3f349776ca1207c00333e0f4a2960768668f3", + "independent/algebra-REVIEW.md": "500acba75f4550d5cf393868e14a64657ec602ef14ac008dca54c26cc5b11d96", + "independent/algebra-SOURCES.json": "594639fb00de36762951215c7bf0cd67360cfe7b536f809a823aa508c0a0aaa0", + "independent/native-ACCOUNTING.json": "488a4f03827c1dd0fdc94a647dd45ef30a45c5844938975800f8993b57b028b9", + "independent/native-PROVENANCE.json": "d7cb8ef83dd81701acfb6fad3429d6214ab9026f18c1c5a35b744e6413b1ef31", + "independent/native-REPORT.md": "445a7423b9559e7ab823967c7766da79a25a36ff9bf01384252b45bb623f489b", + "independent/native-SAME-TWO-BANKS.json": "ba5132d196a095a25b64b31232e18848da7fe2092ebc58a81e6bdb3f3689462e", + "independent/native-WRAPPERS.json": "bd3d02645c2bfc1fdb6c44a2484abf7269c26d5514c248168a0fa792c99d30ca", + "inputs/native/NATIVE-VALIDATION.json": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", + "inputs/native/README.md": "6cfcd49a0601f5b1f184a2567fc35dcb0a5c28eb06fce5e510d54895e8d17fde", + "inputs/native/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "inputs/native/native_inventory.py": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32", + "inputs/native/query_thinned_verify.py": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", + "inputs/predecessors/PR4666-GLOBAL-PROOF.md": "adc377b13924701bf5b0b50b091d8b69c90195d50ce0f6808f7fb4c7e0b16457", + "verify.py": "eb72ec69065a33fe30c10059f21ff2b13f46f16b413280c6eb19e6b52643ddb7" + }, + "projection_formula_fixtures": 64, + "projective_group_order": 24, + "projective_monomial_order": 8, + "semantic_controls": [ + "width1_sum_not_tensorized", + "wordphase_not_scalar_i", + "nonmonomial_free_gate_invalidates_model", + "three_query_positive_control" + ], + "sources": { + "inputs/native/NATIVE-VALIDATION.json": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", + "inputs/native/README.md": "6cfcd49a0601f5b1f184a2567fc35dcb0a5c28eb06fce5e510d54895e8d17fde", + "inputs/native/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "inputs/native/native_inventory.py": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32", + "inputs/native/query_thinned_verify.py": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", + "inputs/predecessors/PR4666-GLOBAL-PROOF.md": "adc377b13924701bf5b0b50b091d8b69c90195d50ce0f6808f7fb4c7e0b16457" + }, + "status": "PASS_TWO_FULL_CENTRAL_OBSTRUCTION_MODEL", + "tensor_gram_ranks_mod_1000003_i_squared_minus1": { + "23": 24, + "24": 24, + "25": 24, + "26": 24 + } +} diff --git a/research/two-full-central-obstruction/SOURCES.json b/research/two-full-central-obstruction/SOURCES.json new file mode 100644 index 0000000000..70292cc555 --- /dev/null +++ b/research/two-full-central-obstruction/SOURCES.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "base_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "LICENSE", + "usage": "provenance", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/kappa-rebuild/bit/complex_controller_factor.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-rebuild/bit/complex_controller_factor.py", + "git_blob": "cb0cff7c8be5f38f2ee52201d9d0907f9dfd7947", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497" + }, + { + "path": "research/pr4359-p7-padding/native_inventory.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/pr4359-p7-padding/native_inventory.py", + "git_blob": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32" + }, + { + "path": "research/query-thinned-controllers/verify.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/query-thinned-controllers/verify.py", + "git_blob": "f1114036fff66f57014e5c1256141fb78ff4c4a9", + "sha256": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950" + }, + { + "path": "research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json", + "git_blob": "d8a2e0a915edce68cfe7472b94bb87dfb9dc24c0", + "sha256": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428" + }, + { + "path": "research/kappa-round3-warp-20261022/README.md", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round3-warp-20261022/README.md", + "git_blob": "e4c18ea0926e0502e6dce637a15a104cccf05624", + "sha256": "6cfcd49a0601f5b1f184a2567fc35dcb0a5c28eb06fce5e510d54895e8d17fde" + }, + { + "path": "research/productive-controller-basis-search/GLOBAL-PROOF.md", + "usage": "provenance", + "pin": "head:08ac39202263203fded429c826ba9228ac9df803:research/productive-controller-basis-search/GLOBAL-PROOF.md", + "git_blob": "74b67e22e6c063193a83825207cdec19a8fef7a4", + "sha256": "adc377b13924701bf5b0b50b091d8b69c90195d50ce0f6808f7fb4c7e0b16457" + } + ] +} diff --git a/research/two-full-central-obstruction/TASK.json b/research/two-full-central-obstruction/TASK.json new file mode 100644 index 0000000000..901ca9d998 --- /dev/null +++ b/research/two-full-central-obstruction/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Two FULL main-only controller calls with different columnwise monomial-conjugate central Gaussian functions; arbitrary owner GL boundaries, independent autonomous source helpers and restored identity scratch. Written group-algebra projection/nullity obstruction and exact finite controls.", + "scope_change_reason": "Explicit Discussion4902 construction assignment changes the local helper-inventory card to a physical-source-bound central endpoint feasibility test. The optimistic paid budget passes but the two-call endpoint fails the stated exact all-width grammar.", + "bottleneck_link": "A two-call endpoint would make a favorable 224H17+2H versus2P complete invoice conceivable; rejecting that precise endpoint prevents unfunded compiler/outer expansion.", + "budget_minutes": 60, + "stop_rule": "Stop after source gate, written projection theorem and small exact corroboration; do not enumerate free words or generalize to width-specific address matchers or existing transformed helper resources.", + "outcome": "negative-result", + "evidence": "Written characteristic-zero twisted-group-algebra proof plus independent agent review;96 central Clifford elements,32 monomials,98304 support checks,64 two-letter expansions,three-letter positive control and exact modular tensor Gram ranks. Native632-column and compiler/outer suites are inherited/unrun.", + "author": "Prepared for Chris R / Clear1nsight", + "ai_assistance": "Substantial OpenAI Codex assistance; user-authorized separate gpt-6.1-sol HIGH algebra, source/accounting and independent-review agents. No independent human or proof-kernel review.", + "open_questions": [ + { + "question": "Can an actual already-transformed helper resource or shared native-word fusion alter the complete two-main-bank invoice without repaying its gain?", + "why_it_matters": "The present main-only free-word grammar is excluded; using an already-paid nonmonomial resource changes its starting algebra and could change the recursive bill.", + "first_step": "Name one actual helper cut and its input/output owner operator, write the literal changed consumer with all returns, and price an optimistic complete bill before search.", + "blocked_by": "No such chronological helper consumer or improved complete invoice is supplied; existing helper jobs cannot be used as identity scratch." + } + ] +} diff --git a/research/two-full-central-obstruction/VERIFY.json b/research/two-full-central-obstruction/VERIFY.json new file mode 100644 index 0000000000..e2e70c9d19 --- /dev/null +++ b/research/two-full-central-obstruction/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Authenticates frozen native/predecessor bytes, exact central Clifford group and monomial subgroup, projection formula/support controls, modular projective tensor ranks and width-one semantic faults. Written proof supplies universal quantifiers; no native or outer replay." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Authenticates frozen native/predecessor bytes, exact central Clifford group and monomial subgroup, projection formula/support controls, modular projective tensor ranks and width-one semantic faults. Written proof supplies universal quantifiers; no native or outer replay." + } + ] +} diff --git a/research/two-full-central-obstruction/independent/algebra-REVIEW.md b/research/two-full-central-obstruction/independent/algebra-REVIEW.md new file mode 100644 index 0000000000..44ec10ae25 --- /dev/null +++ b/research/two-full-central-obstruction/independent/algebra-REVIEW.md @@ -0,0 +1,136 @@ +# Independent review of the two-letter main-only obstruction + +Reviewer: OpenAI Codex gpt-6.1-sol/high, read-only mathematical review for +Discussion https://github.com/CrocSwap/integer-mult-bounds/discussions/4902. +This reviews the invariant proposed by the `sol_upstream_lever_triage` agent; +it does not claim its discovery, enumerate circuits, or change source files. + +Verdict: the group-algebra projection/rank-deficiency argument is sound. +Zero divisors and projectors in the monomial algebra do not invalidate it. +The all-width lift below is explicit, includes global phases, and can even +allow scalar coefficients to depend on width. Its address alphabet must +remain fixed, finite, and lifted identically across columns. + +## Algebraic statement and proof + +Let K be an infinite characteristic-zero splitting field, G a finite group, +and H a subgroup. Set A=K[G] and B=K[H]. No domain property is assumed. +Let pi:A->B discard all basis terms outside H. Since multiplication on +either side by H preserves H and its complement, pi is a B-bimodule map. + +Let n>=2, let L,W,R be arbitrary invertible n-by-n matrices over B, and +let a,b be group elements outside H. A two-letter word has form + + M = L (I+e_i b e_j^T) W (I+e_k a e_l^T) R, + +where i!=j and k!=l. Inverse letters and scalar signs can be included in +a,b and the outer constant matrices. Its B-valued term is exactly + + pi(M) = L [ W + e_i c e_l^T ] R, + c = pi(b W_jk a). + +Indeed the two linear terms vanish: every term of B a B and B b B lies +outside H. The only surviving extra term is the quadratic cross term. + +Regard matrices over B as K-linear maps on the right B-module B^n. +Its dimension is n*d, d=dim_K B. W is invertible on this space. The +perturbation e_i c e_l^T factors through a single copy of B, so its image +has K-dimension at most d. For x in the kernel of W+e_i c e_l^T, Wx lies +in that image. Invertibility of W makes x->Wx injective, proving + + dim_K ker pi(M) <= d. + +The desired target diag(g1,g2,I,...,I), with g1,g2 outside H, projects to +diag(0,0,I,...,I), whose kernel has dimension 2*d. Contradiction. +Arbitrary free L/W/R are retained, as are arbitrary additional dirty +scratch owners returned unchanged. More generally, the contradiction only +needs the first two projected input columns of the final map to vanish; +its other columns need not have an identity block. A scratch endpoint +that retains main-input-dependent garbage is a different contract. + +## All-width faithfulness, with absolute phases + +Assume G is a finite group of distinct one-column complex matrices rho(g). +A literal group word lifts to rho(g) tensor-powered f times. In particular, +the lift of a product is the product of the lifts; it is never the tensor +power of a sum of owner matrices. Constant owner matrices live outside +this tensor lift and retain their scalar coefficients. + +For fixed coefficients, full tensor faithfulness has a short Vandermonde +proof. Choose a linear functional ell on the one-column matrix space so +that all lambda_g=ell(rho(g)) are nonzero and pairwise distinct. Such a +choice exists because the forbidden choices form finitely many proper +hyperplanes over an infinite field. Applying ell tensor-powered f to an +identity sum_g c_g rho(g)^(tensor f)=0 for f=1,...,|G| gives an invertible +Vandermonde system. Thus every c_g is zero. Proportional matrices with +different global phases give different lambda_g and are separated too. + +A stronger version accommodates width-dependent scalar choices. Let Z be +the subgroup of scalar matrices in G, enlarge H to HZ if necessary, and +choose one representative v_t from each projective class t in G/Z. Write +s=|G/Z|. For each t and u!=t, projective distinctness gives a linear +functional ell_tu that vanishes on v_u and not on v_t. Their product is a +degree s-1 polynomial that isolates v_t among all representatives. Extend +to any degree f>=s-1 by a power of a linear functional nonzero on v_t. +Applied to tensor powers, this proves the s vectors v_t^(tensor f) are +linearly independent for every f>=s-1. This is an existence proof and +requires no group enumeration or numerical tensor test. + +At each such f take the quotient A_f of K[G] by the central-character +relations z=scalar(z)^f. It is the twisted group algebra on G/Z, with +dimension s. Its B_f subalgebra on H/Z has dimension |H/Z|. The tensor +representation of A_f is injective by the preceding separating-polynomial +argument. Projection to H/Z remains a B_f-bimodule map: cocycle phase +factors change coefficients, not coset membership. The same nullity proof +therefore applies separately at every sufficiently large width, even when +the coefficients of L,W,R depend on f. The subgroup algebra still has +zero divisors; only its finite vector-space dimension was used. + +## Source applicability and precise limit + +At frozen native source `20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`, +`research/kappa-rebuild/bit/complex_controller_factor.py` explicitly +declares the local main contract + + F_s = D_s [[1,0],[Q^-1,1]], + B_s = D_s [[1,-Q],[0,1]]. + +The file itself labels this an input contract; it alone is not a physical +binding. The same source's `research/pr4359-p7-padding/native_inventory.py` +checks actual routes, entry/exit phase contacts, and the exact cross +operator D_s Q^(-sign). It keeps Q^2 and D_s^2 as translations rather than +silently imposing order two. `research/query-thinned-controllers/verify.py` +independently invokes these native contacts, including the reverse sign. + +The accounting/source-binding reviewer separately confirms Q_f=Q_1 +tensor-powered f and S_f=S_1 tensor-powered f for the proposed +S=diag(1,i), including absolute phase. This is sufficient for the +declared central-word model, provided the proposed main-only wrappers +really use that columnwise finite-group alphabet. It does not certify +every monomial matching operation allowed elsewhere in the native theory. + +The central reduced model may enlarge its scalar field, all free boundary +words to GL_n(B), and scratch inventory: these all strengthen a necessary +obstruction. Fresh D_s can be absorbed into free words only after declaring +a subgroup that includes those fresh-axis Cliffords while retaining the +central/fresh separation. For example allow all fresh Clifford operations +free and allow central monomials free. A full rank-17 Gaussian endpoint +is outside this subgroup because fresh-only rank is at most sixteen and +the central monomial factor has Gaussian rank zero. One may take G to be +the full finite seventeen-axis Clifford group, but H must keep that +separation. Enlarging H to include both arbitrary central/fresh mixing +monomials and all fresh Cliffords can generate the central Gaussian for +free, destroying the assumption a,b,g1,g2 outside H. + +Accordingly, the reviewed obstruction covers arbitrary outer owner GL, +arbitrary scalar choices in a larger field, monomial conjugates of the +central Gaussian within the declared finite columnwise alphabet, and +restored dirty scratch. It does not cover arbitrary width-specific address +monomials, central/fresh address mixing outside H, or using transformed +helper states as additional nonmonomial inputs. Actual helper jobs are +autonomous in this model. Mixing already-transformed helper outputs changes +the starting module and cannot be represented as identity scratch. + +No physical two-call consumer or kappa improvement is established. The +positive optimistic two-call invoice is conditional on an endpoint which +this declared main-only pureword model cannot attain. diff --git a/research/two-full-central-obstruction/independent/algebra-SOURCES.json b/research/two-full-central-obstruction/independent/algebra-SOURCES.json new file mode 100644 index 0000000000..d01cc06fc6 --- /dev/null +++ b/research/two-full-central-obstruction/independent/algebra-SOURCES.json @@ -0,0 +1,19 @@ +{ + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4902", + "files": [ + { + "path": "research/kappa-rebuild/bit/complex_controller_factor.py", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497" + }, + { + "path": "research/pr4359-p7-padding/native_inventory.py", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32" + }, + { + "path": "research/query-thinned-controllers/verify.py", + "sha256": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950" + } + ], + "review_sha256": "500acba75f4550d5cf393868e14a64657ec602ef14ac008dca54c26cc5b11d96" +} diff --git a/research/two-full-central-obstruction/independent/native-ACCOUNTING.json b/research/two-full-central-obstruction/independent/native-ACCOUNTING.json new file mode 100644 index 0000000000..a32b9b2bcd --- /dev/null +++ b/research/two-full-central-obstruction/independent/native-ACCOUNTING.json @@ -0,0 +1,225 @@ +{ + "comparisons": { + "C0031": { + "C": "31/10000", + "decimal": { + "lower": "37.596666929262011", + "upper": "37.596666929262012" + }, + "exact": [ + "58999525806606400378647941097747917006216631899167749911883/1569275433846670190958947355801916604025588861116008628224", + "7374940725825800047330992637218489625777078987395968904221/196159429230833773869868419475239575503198607639501078528" + ], + "maximum_extra_calls_by_single_rank_before_any_reserve": { + "1": 37, + "17": 2, + "8": 4, + "9": 4 + } + }, + "C0032": { + "C": "2/625", + "decimal": { + "lower": "35.721426912841395", + "upper": "35.721426912841396" + }, + "exact": [ + "112113515432542603263989606240028348942675987953609721024051/3138550867693340381917894711603833208051177722232017256448", + "112113515432542603263989606240028348942675987953609723697543/3138550867693340381917894711603833208051177722232017256448" + ], + "maximum_extra_calls_by_single_rank_before_any_reserve": { + "1": 35, + "17": 2, + "8": 4, + "9": 3 + } + }, + "C0033": { + "C": "33/10000", + "decimal": { + "lower": "33.846731446117545", + "upper": "33.846731446117546" + }, + "exact": [ + "26557422087198922866294475285624298660615585806000354387723/784637716923335095479473677900958302012794430558004314112", + "53114844174397845732588950571248597321231171612000710110931/1569275433846670190958947355801916604025588861116008628224" + ], + "maximum_extra_calls_by_single_rank_before_any_reserve": { + "1": 33, + "17": 2, + "8": 4, + "9": 3 + } + }, + "C0034": { + "C": "17/5000", + "decimal": { + "lower": "31.972580383536966", + "upper": "31.972580383536967" + }, + "exact": [ + "50173784952572510283672717729399425075475869433433475013765/1569275433846670190958947355801916604025588861116008628224", + "50173784952572510283672717729399425075475869433433476340707/1569275433846670190958947355801916604025588861116008628224" + ], + "maximum_extra_calls_by_single_rank_before_any_reserve": { + "1": 31, + "17": 1, + "8": 4, + "9": 3 + } + }, + "funded4610": { + "C": "15108879/5000000000", + "decimal": { + "lower": "39.063938114801903", + "upper": "39.063938114801904" + }, + "exact": [ + "15325519608216308202854952225984026434993152257615230464315/392318858461667547739736838950479151006397215279002157056", + "122604156865730465622839617807872211479945218060921846405143/3138550867693340381917894711603833208051177722232017256448" + ], + "maximum_extra_calls_by_single_rank_before_any_reserve": { + "1": 39, + "17": 2, + "8": 4, + "9": 4 + } + } + }, + "crossing_bracket": [ + "511/100000", + "5111/1000000" + ], + "helper_fields": 816, + "local_helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "local_paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "main_target_profile": { + "17": 224 + }, + "new_kappa": null, + "numerical_completion": [ + { + "C": "15108879/5000000000", + "admission": "numerical screen only", + "alpha": { + "lower": "0.996339752194219", + "upper": "0.996339752194220" + }, + "alpha_gap": "1/1000", + "ambient": 17, + "cutoff": 9, + "delta": { + "lower": "0.968019928284328", + "upper": "0.968019928284329" + }, + "eta": { + "lower": "0.000155349378565", + "upper": "0.000155349378566" + }, + "floor": 10, + "gamma": { + "lower": "0.734656945869204", + "upper": "0.734656945869205" + }, + "maximum_target": 17, + "normalized_paid_upper": "134217728253/271656681472", + "power": 1024, + "tail_cap": "97/100", + "tail_offset": "1/5" + }, + { + "C": "17/5000", + "admission": "numerical screen only", + "alpha": { + "lower": "0.997001489949372", + "upper": "0.997001489949373" + }, + "alpha_gap": "1/1000", + "ambient": 17, + "cutoff": 9, + "delta": { + "lower": "0.968092232846957", + "upper": "0.968092232846958" + }, + "eta": { + "lower": "0.000051831039407", + "upper": "0.000051831039408" + }, + "floor": 10, + "gamma": { + "lower": "0.735125688231302", + "upper": "0.735125688231303" + }, + "maximum_target": 17, + "normalized_paid_upper": "134217728253/271656681472", + "power": 1024, + "tail_cap": "97/100", + "tail_offset": "1/5" + } + ], + "paid_calls": 6596, + "paid_profile": { + "1": 4402, + "2": 824, + "3": 1020, + "4": 254, + "5": 80, + "8": 16 + }, + "productive_fields": 1040, + "rank_mass_surplus": 96, + "recursive_boundary_cost_assumed": 0, + "retained_ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "sign_separated_coefficients": { + "1": -4402, + "17": 224, + "2": -824, + "3": -1020, + "4": -198, + "5": -80, + "7": 14, + "8": 78, + "9": 652 + }, + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_local_scalar": 158168, + "source_paths": { + "arithmetic": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "intervals": "research/higher-moment-strictification/verify.py", + "native": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz" + }, + "source_sha256": { + "arithmetic": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "intervals": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "native": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + "status": "PASS_CONDITIONAL_TWO_FULL_SOURCE_ACCOUNTING", + "target_profile": { + "17": 224, + "4": 56, + "7": 14, + "8": 94, + "9": 652 + }, + "unique_raw_crossing": "F(t)/5^t strictly increasing; mathematical crossing near.00511 is beyond retained ordinaryBIT admission", + "wrapper_finite_bill": "not included in moment; actual wrapper and full caller still require construction" +} diff --git a/research/two-full-central-obstruction/independent/native-PROVENANCE.json b/research/two-full-central-obstruction/independent/native-PROVENANCE.json new file mode 100644 index 0000000000..a4f826f946 --- /dev/null +++ b/research/two-full-central-obstruction/independent/native-PROVENANCE.json @@ -0,0 +1,39 @@ +{ + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "published_4867_head": "5e4cce12a9851fbb46cd7c32cc8177e983771539", + "pinned_source_sha256": { + "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", + "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "research/kappa-round6-compiler-tightening-20261022/arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/query-thinned-controllers/verify.py": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", + "research/pr4359-p7-padding/native_inventory.py": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32", + "research/pr4359-p7-padding/TENSOR.md": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + "local_support_sha256": { + "outputs/sol1337-five-call-accounting/accounting.py": "5d50b07074e3a8bab1c474d9521ac7d3100d691272658e61cccf4f95febc4a2a", + "outputs/sol1337-centre-selfblock/witness.py": "247ad39f8ba452928aba70b3f09f399523c60ec6564ade42c4993f4abc2396e3" + }, + "outputs_sha256": { + "ACCOUNTING.json": "488a4f03827c1dd0fdc94a647dd45ef30a45c5844938975800f8993b57b028b9", + "REPORT.md": "445a7423b9559e7ab823967c7766da79a25a36ff9bf01384252b45bb623f489b", + "SAME-TWO-BANKS.json": "ba5132d196a095a25b64b31232e18848da7fe2092ebc58a81e6bdb3f3689462e", + "WRAPPERS.json": "bd3d02645c2bfc1fdb6c44a2484abf7269c26d5514c248168a0fa792c99d30ca", + "accounting-normal.log": "7a2c93a170ca6bb72d80f920725c23fc63daec391b9b49e41546431e1fae6eb4", + "accounting-optimized.log": "7a2c93a170ca6bb72d80f920725c23fc63daec391b9b49e41546431e1fae6eb4", + "accounting.py": "968da74020f9755157a85122fba9908591c5d8cd82f93932e91441b65a34d333", + "same-two-normal.log": "8335c51accc67417489bd5271e73cb0798bf7e1afbd8890778f1446802354c22", + "same-two-optimized.log": "8335c51accc67417489bd5271e73cb0798bf7e1afbd8890778f1446802354c22", + "same_two_banks.py": "1713f4a3e1fb8a5638cef1217643ef1055c85f0f7bbf846a6dd2ed23acf80d81", + "wrappers-normal.log": "acdc1825e2e55429160e776b586cc147a40760ed666040e81ea9ec6cd678345d", + "wrappers-optimized.log": "acdc1825e2e55429160e776b586cc147a40760ed666040e81ea9ec6cd678345d", + "wrappers.py": "a6485847df3d9616aa747c949118f55a73ae41db775d878376306f49a38c270c" + }, + "normal_and_optimized_replays_identical": true, + "source_all_column_semantics": "retained written premise plus frozen632-column receipt; not independently rerun here", + "standalone_Git_free_export": false +} diff --git a/research/two-full-central-obstruction/independent/native-REPORT.md b/research/two-full-central-obstruction/independent/native-REPORT.md new file mode 100644 index 0000000000..a3ba9bc116 --- /dev/null +++ b/research/two-full-central-obstruction/independent/native-REPORT.md @@ -0,0 +1,110 @@ +# Two FULL calls: independent accounting and native-wrapper review + +This output-only review supports prospective Discussion4902. It does not synthesize a controller, certify the algebra agent's obstruction, fund an exponent, or modify published #4867. All arithmetic below is conditional on the advertised independent target endpoints actually being constructed. + +## 1. Frozen complete source profile + +The source is Cao Yifan's #4610 head `20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`. `accounting.py` derives the entire paid census from the literal native word's `climb` and `center` events and independently derives all 408 helper ranks from final-minus-initial chart dimensions. Both equal the frozen arithmetic receipt. + + P = {1:2201,2:412,3:510,4:127,5:40,8:8} + H = {4:28,7:7,8:47,9:326} + +Each FULL call pays 3298 jobs with rank mass 5327, and provides 408 original-input helper endpoints with relative rank mass 3471. Exit-frame dimension 3530 is not helper credit. All boundaries and the two main banks belong to their actual original owners; helpers are counted once per call. + +For two FULL invocations on the same two 112-port main banks, the prospective target224H17+2H versus paid2P is: + + paid = {1:4402,2:824,3:1020,4:254,5:80,8:16} + target = {4:56,7:14,8:94,9:652,17:224} + +There are 6596 paid calls and 1040 productive fields, including exactly 816 helpers. Rank-mass surplus is 96. Ambient 17 equals maximum productive rank 17. No centre target or duplicate helper credit is included. + +## 2. Exact optimistic moment + +For t=1-C, the signed moment is target(t)-paid(t). Every displayed interval is outward-rounded from exact rational bounds; complete rational endpoints are in `ACCOUNTING.json`. + +| C | Lower bound | Upper bound | +|---|---:|---:| +| .0030217758 | 39.063938114801903 | 39.063938114801904 | +| .0031 | 37.596666929262011 | 37.596666929262012 | +| .0032 | 35.721426912841395 | 35.721426912841396 | +| .0033 | 33.846731446117545 | 33.846731446117546 | +| .0034 | 31.972580383536966 | 31.972580383536967 | + +The unique raw crossing lies in(.005110,.005111). The signed coefficients are negative only at ranks<=5 and positive only at ranks>5. Consequently F(t)/5^t is strictly increasing in t, proving uniqueness and the direction of the crossing without extrapolating sampled values. + +The retained ordinary BIT admission is17/5000=.0034. Its other frozen quantities are before-cover.003459, after-cover.00345, atom.004 and ordinary saving8590884599/2500000000000. The mathematical raw crossing is beyond this admission. The retained outer source requires tested saving strictly below the BIT admission; a raw or numerical screen at .0034 does not fund an outer endpoint at .0034. + +The positive margin includes zero added recursive boundary calls. It is not an available allowance until the complete caller supplies the prospective endpoints. For reference, at the funded comparison it could numerically absorb at most 39 addedH1 calls, or 4 addedH8 calls; at .0034 the corresponding separate maxima are 31 and4. These alternatives cannot be simultaneously spent. + +## 3. Actual shared-axis phase wrapper and the rawD0 correction + +The intended S is a native monomial phase. For each actual source port q, + + S|x> = i^{parity(q & x)} |x>. + +At positive column width f this is the columnwise word lift, multiplying by i to the popcount of the shared-coordinate word. Its inverse uses the opposite phase. Multiplication by these unit phases is realizable by real/imaginary swaps and signs; no scalar sqrt2 is required. + +`wrappers.py` authenticates all 112 actual phase recipes and verifies q.q=1 and the eight transverse basis directions perpendicular to q. S and its inverse have Fourier grade0; a=S Q S^-1 has grade1. S commutes, including absolute phase, with the positive transverse8 Gaussian and the next disjoint fresh8 Gaussian. + +**Raw source D0 requires care.** It is F9 Q^-1 and does not itself commute with S on any of the 112 actual ports. The script freshly factors every rawD0 as + + rawD0 = X_t * product_{b in actual transverse8 basis} C_b. + +This is an exact equality of signed tableaux and absolute phases. All 112 literal translations t are emitted in `WRAPPERS.json`; examples(q,t)=(11,15),(19,23),(35,39),(67,71),(131,135). Applying X_t at the output gives the positive transverse8 word. The translation adds no recursive Gaussian call, but its physical finite pass must be charged or fused into an already emitted normalizer. An argument may instead retain rawD0 inside its allowed free subgroup; it must not assume rawD0 commutes with arbitrary central phases. + +The frozen source normalizes each FULL main block to + + F_s = D_s [[1,0],[Q^-1,1]], + B_s = D_s [[1,-Q],[0,1]]. + +There is exactly one off-diagonal central Q letter, and no extra nonmonomial central diagonal letter after the D_s factor. `pr4359-p7-padding/native_inventory.py` explicitly derives the raw diagonal and cross phase polynomials and supplies translations and inverse translations for the entry/exit maps. `query-thinned-controllers/verify.py::native_contacts()` checks the17-axis old9/fresh8 binding. Those files retain the source all-column semantics as a written premise. This review does not rerun the entire632-column native suite; it binds to #4610's existing `NATIVE-VALIDATION.json` and separately checks the stated new S/translation facts. + +## 4. Which interface conjugation preserves + +For W=diag(S,S,I_helpers), conjugating the complete 632-field native invocation as W N W^-1 preserves all autonomous helper outputs. Its original owned centre bank remains initialized, erased and uncredited inside that invocation. Apply both the input inverse and output forward map; output-only retagging is not conjugation. The main scalar bridge must respect the literal physical charts and preserve the full off-diagonal Y coupling. + +For the different retained 640-input ABI, extend W with identity on the eight arbitrary centres. Helpers still remain autonomous, but the centre observations become R_X S^-1 and the incoming-centre scatter becomes S B_Y. The centre selfblock is unchanged; its outputs are not autonomous independent jobs. Those couplings cannot be discarded, zeroed by assumption, or assigned extra productive credit. Any raw inverse-transpose orientation must also carry the correct transposed inverse boundary maps; copying an unrelated forward wrapper is insufficient. + +The declared S and fixed coordinate routes are columnwise lifts of a finite one-column gate alphabet. This review does not certify that every broader permitted f-dependent whole-job address/index matcher belongs to the same finite central group. A finite-group obstruction must retain that scope boundary. + +Permitted scalar adapters here are explicit invertible constant dyadic rational schedules (or explicit Gaussian-dyadic complex schedules compiled into real primitives). Each nonzero scale and inverse, ADD coefficient, sign and role swap must be listed and charged; denominators are powers of two and fixed independently of f. A scalar sqrt2, an arbitrary unpriced coefficient function of f, or an unimplemented diagonal address function is outside this demonstrated native binding. A theorem may use a larger scalar field as a relaxation, without thereby admitting those operations into a positive construction. + +## 5. Finite tariffs and compiler preliminaries + +The source finite scalar allowances are 158120 forward and 158168 backward. The source round6 audit bounds its local routes by + + (3298 + 2*408 + 688)*1000 = 4,802,000, + +hence scalar-plus-route records below 10^7 per FULL. This is a source bound on its listed normalizers and routes; it is not a synthesized two-call controller invoice. One conjugated FULL adds 224 input S^-1 and 224 output S monomial passes before adjacent simplification. Any needed rawD0 normalization adds at most 224 literal output translation passes, unless already fused into actual normalizers. Scalar bridges, target matchers, helper/centre restoration, prefix magnitude and denominator bounds must be included in the new finite word. No recursive boundary cost is hidden in the moment. + +A source-style **numerical** completion screen passes at the funded comparison and.0034 with ambient=max-target 17, power 1024, cutoff 9, floor 10, tail exponent 1/5, cap 97/100 and alpha gap 1/1000. At.0034: alpha<.997001489949373, gamma<.735125688231303, delta<.968092232846958. The exact shifted-exit, capacity and initial-range inequalities also pass. This avoids the earlier ambient41/max-target40 mismatch, but it remains a numerical sufficient-condition screen on a hypothetical complete native caller. + +The inherited tensor theorem requires an actual chronological native unit, arbitrary original productive owners, complete spectators, independently owned/erased centre banks, role-specific whole-job matchers and finite-program closure. The source `arithmetic.py::assemble()` hardcodes 18 FULL and 15 query invocations; its old complete invoice cannot certify this new two-call unit. The new caller must be substituted explicitly before a uniform compiler or outer ledger is transferred. + +The outer ledger `pr4359-p7-padding/dependencies/compiler-refill/endpoint.py::ledger()` has 54 strict predicates, plus its three functional conditions and the later actual-new-BIT-stock condition, making four functional guards. Any future transfer must supply a strict tested/uniform/effective/q/kappa chain; retained BIT admission above the effective and tested savings; the new physical finite-pass and precision constants; all tape, storage, analytic and recovery premises; and all 54+4 positive evaluations. No such new funded transfer is asserted here. + +## 6. Three or more calls on the same two banks + +The separate `same_two_banks.py` gate uses224H25+3H versus3P, with helpers once each and rank-mass surplus 32. + +| C | Lower bound | Upper bound | +|---|---:|---:| +| .0030217758 | -58.916072241014304 | -58.916072241014303 | +| .0031 | -61.258204911542541 | -61.258204911542540 | +| .0032 | -64.251497935591116 | -64.251497935591115 | +| .0033 | -67.243854225575991 | -67.243854225575990 | +| .0034 | -70.235274055936613 | -70.235274055936612 | + +Its unique raw crossing lies in(.001060,.001061), and coefficient sign separation proves negativity for every C at or above the funded comparison through1. More generally, for n FULL calls on the same two banks with only224H(8n+1)+nH targets, rank-mass surplus is224-64n. For every integer n>=4 it is negative already at C=0, and the same sign-separation argument proves negativity for all C in[0,1]. This is an accounting family, not a construction or a new exhaustive operator theorem. + +At the funded comparison, the three-call deficit alone requires, for example, at least 59 extra independentH1 jobs, 8 extraH8 jobs, 7 extraH9 jobs, 4 extraH17 jobs or 3 extraH25 jobs. Equivalently, a genuine call deletion/fusion must save more than58.916072241014304 in moment before paying any new cost or reserve. The exact thresholds for all requested points and source paid ranks are in `SAME-TWO-BANKS.json`. Added helper jobs require independent original inputs and actual endpoints; deleting paid jobs requires an actual chronological replacement. None of these improvements is freely available. + +## Reproduction and provenance + +Run each script normally and with `python3 -I -O` from this worktree. All six runs pass, and each normal/optimized pair has identical text output. + + python3 outputs/two-full-accounting-review/accounting.py + python3 outputs/two-full-accounting-review/wrappers.py + python3 outputs/two-full-accounting-review/same_two_banks.py + +These output scripts explicitly reuse the earlier outputs `sol1337-five-call-accounting/accounting.py` and `sol1337-centre-selfblock/witness.py`; neither main routine is run by import. They require the pinned Git source object and are not a Git-free export. `PROVENANCE.json` records these local support hashes and all relevant pinned source hashes. No source or earlier scientific package was edited. Credits: Cao Yifan's #4610 source/profile, Cinna Davis's native/helper/centre contracts, zxv's phase and interval implementations, Jacob Alan Sussman's integer compiler, and substantial OpenAI Codex assistance. diff --git a/research/two-full-central-obstruction/independent/native-SAME-TWO-BANKS.json b/research/two-full-central-obstruction/independent/native-SAME-TWO-BANKS.json new file mode 100644 index 0000000000..1ac3616b93 --- /dev/null +++ b/research/two-full-central-obstruction/independent/native-SAME-TWO-BANKS.json @@ -0,0 +1,186 @@ +{ + "all_C_at_or_above_funded_three_call_negative": true, + "comparisons": { + "C0031": { + "C": "31/10000", + "decimal": { + "lower": "-61.258204911542541", + "upper": "-61.258204911542540" + }, + "margin": [ + "-192261992178458286203554772367578079265112431304473724628999/3138550867693340381917894711603833208051177722232017256448", + "-12016374511153642887722173272973629954069526956529607545729/196159429230833773869868419475239575503198607639501078528" + ], + "minimum_deleted_paid_calls_by_single_rank_before_any_reserve": { + "1": 62, + "2": 31, + "3": 21, + "4": 16, + "5": 13, + "8": 8 + }, + "minimum_extra_independent_jobs_by_single_rank_before_any_reserve": { + "1": 62, + "17": 4, + "2": 31, + "25": 3, + "3": 21, + "4": 16, + "5": 13, + "7": 9, + "8": 8, + "9": 7 + } + }, + "C0032": { + "C": "2/625", + "decimal": { + "lower": "-64.251497935591116", + "upper": "-64.251497935591115" + }, + "margin": [ + "-403313189192692725971996601751871535562280945316484912312359/6277101735386680763835789423207666416102355444464034512896", + "-403313189192692725971996601751871535562280945316484904439163/6277101735386680763835789423207666416102355444464034512896" + ], + "minimum_deleted_paid_calls_by_single_rank_before_any_reserve": { + "1": 65, + "2": 33, + "3": 22, + "4": 17, + "5": 13, + "8": 9 + }, + "minimum_extra_independent_jobs_by_single_rank_before_any_reserve": { + "1": 65, + "17": 4, + "2": 33, + "25": 3, + "3": 22, + "4": 17, + "5": 13, + "7": 10, + "8": 9, + "9": 8 + } + }, + "C0033": { + "C": "33/10000", + "decimal": { + "lower": "-67.243854225575991", + "upper": "-67.243854225575990" + }, + "margin": [ + "-105524128513363008990392090769088997373462512914521186811363/1569275433846670190958947355801916604025588861116008628224", + "-211048257026726017980784181538177994746925025829042369696575/3138550867693340381917894711603833208051177722232017256448" + ], + "minimum_deleted_paid_calls_by_single_rank_before_any_reserve": { + "1": 68, + "2": 34, + "3": 23, + "4": 17, + "5": 14, + "8": 9 + }, + "minimum_extra_independent_jobs_by_single_rank_before_any_reserve": { + "1": 68, + "17": 4, + "2": 34, + "25": 3, + "3": 23, + "4": 17, + "5": 14, + "7": 10, + "8": 9, + "9": 8 + } + }, + "C0034": { + "C": "17/5000", + "decimal": { + "lower": "-70.235274055936613", + "upper": "-70.235274055936612" + }, + "margin": [ + "-220436980330939411848366239257555919837910739565621733379177/3138550867693340381917894711603833208051177722232017256448", + "-220436980330939411848366239257555919837910739565621729504359/3138550867693340381917894711603833208051177722232017256448" + ], + "minimum_deleted_paid_calls_by_single_rank_before_any_reserve": { + "1": 71, + "2": 36, + "3": 24, + "4": 18, + "5": 15, + "8": 9 + }, + "minimum_extra_independent_jobs_by_single_rank_before_any_reserve": { + "1": 71, + "17": 5, + "2": 36, + "25": 3, + "3": 24, + "4": 18, + "5": 15, + "7": 11, + "8": 9, + "9": 8 + } + }, + "funded4610": { + "C": "15108879/5000000000", + "decimal": { + "lower": "-58.916072241014304", + "upper": "-58.916072241014303" + }, + "margin": [ + "-46227772413279741819411984638875647099867007614594697121339/784637716923335095479473677900958302012794430558004314112", + "-369822179306237934555295877111005176798936060916757568984299/6277101735386680763835789423207666416102355444464034512896" + ], + "minimum_deleted_paid_calls_by_single_rank_before_any_reserve": { + "1": 59, + "2": 30, + "3": 20, + "4": 15, + "5": 12, + "8": 8 + }, + "minimum_extra_independent_jobs_by_single_rank_before_any_reserve": { + "1": 59, + "17": 4, + "2": 30, + "25": 3, + "3": 20, + "4": 15, + "5": 12, + "7": 9, + "8": 8, + "9": 7 + } + } + }, + "general_n": "For each integer n>=4, target224H(8n+1)+nH versus nP has F_n(1)=224-64n<0 and the same coefficient sign separation, so is negative at every C in[0,1]. This assumes the declared target population only.", + "needed_change": "Additional independently productive original owners, changed target demand, or actual deletion/fusion of paid source operations must add more moment than the reported deficit; none is constructed or freely credited.", + "new_kappa": null, + "rank_mass_surplus": 32, + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_or_boundary_costs": "Finite wrapper passes and all compiler/outer reserves are separate. Deleting calls or adding helper jobs is only a numerical necessary improvement, not an available operation.", + "status": "PASS_SAME_TWO_BANKS_THREE_PLUS_CALLS_ACCOUNTING", + "three_call_crossing_bracket": [ + "53/50000", + "1061/1000000" + ], + "three_call_paid": { + "1": 6603, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120, + "8": 24 + }, + "three_call_targets": { + "25": 224, + "4": 84, + "7": 21, + "8": 141, + "9": 978 + } +} diff --git a/research/two-full-central-obstruction/independent/native-WRAPPERS.json b/research/two-full-central-obstruction/independent/native-WRAPPERS.json new file mode 100644 index 0000000000..7d8ae034a0 --- /dev/null +++ b/research/two-full-central-obstruction/independent/native-WRAPPERS.json @@ -0,0 +1,4162 @@ +{ + "status": "PASS_ACTUAL_SOURCE_SHARED_AXIS_PHASE_WRAPPERS", + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "phase_source": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "phase_source_sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "ports": [ + { + "port": 0, + "q": 11, + "transverse_axes": [ + 13, + 14, + 7, + 16, + 32, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 15, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 11, + 11, + 0, + 11, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 1, + "q": 19, + "transverse_axes": [ + 21, + 22, + 8, + 7, + 32, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 23, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 19, + 19, + 0, + 0, + 19, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 2, + "q": 35, + "transverse_axes": [ + 37, + 38, + 8, + 16, + 7, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 39, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 35, + 35, + 0, + 0, + 0, + 35, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 3, + "q": 67, + "transverse_axes": [ + 69, + 70, + 8, + 16, + 32, + 7, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 71, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 67, + 67, + 0, + 0, + 0, + 0, + 67, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 4, + "q": 131, + "transverse_axes": [ + 133, + 134, + 8, + 16, + 32, + 64, + 7, + 256 + ], + "raw_D0_to_positive_D8_translation": 135, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 131, + 131, + 0, + 0, + 0, + 0, + 0, + 131, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 5, + "q": 259, + "transverse_axes": [ + 261, + 262, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "raw_D0_to_positive_D8_translation": 263, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 259, + 259, + 0, + 0, + 0, + 0, + 0, + 0, + 259, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 6, + "q": 13, + "transverse_axes": [ + 14, + 11, + 7, + 16, + 32, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 15, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 13, + 0, + 13, + 13, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 7, + "q": 21, + "transverse_axes": [ + 22, + 19, + 8, + 7, + 32, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 23, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 21, + 0, + 21, + 0, + 21, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 8, + "q": 37, + "transverse_axes": [ + 38, + 35, + 8, + 16, + 7, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 39, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 37, + 0, + 37, + 0, + 0, + 37, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 9, + "q": 69, + "transverse_axes": [ + 70, + 67, + 8, + 16, + 32, + 7, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 71, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 69, + 0, + 69, + 0, + 0, + 0, + 69, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 10, + "q": 133, + "transverse_axes": [ + 134, + 131, + 8, + 16, + 32, + 64, + 7, + 256 + ], + "raw_D0_to_positive_D8_translation": 135, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 133, + 0, + 133, + 0, + 0, + 0, + 0, + 133, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 11, + "q": 261, + "transverse_axes": [ + 262, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "raw_D0_to_positive_D8_translation": 263, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 261, + 0, + 261, + 0, + 0, + 0, + 0, + 0, + 261, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 12, + "q": 41, + "transverse_axes": [ + 42, + 4, + 35, + 16, + 11, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 43, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 41, + 0, + 0, + 41, + 0, + 41, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 13, + "q": 73, + "transverse_axes": [ + 74, + 4, + 67, + 16, + 32, + 11, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 75, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 73, + 0, + 0, + 73, + 0, + 0, + 73, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 14, + "q": 137, + "transverse_axes": [ + 138, + 4, + 131, + 16, + 32, + 64, + 11, + 256 + ], + "raw_D0_to_positive_D8_translation": 139, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 137, + 0, + 0, + 137, + 0, + 0, + 0, + 137, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 15, + "q": 265, + "transverse_axes": [ + 266, + 4, + 259, + 16, + 32, + 64, + 128, + 11 + ], + "raw_D0_to_positive_D8_translation": 267, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 265, + 0, + 0, + 265, + 0, + 0, + 0, + 0, + 265, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 16, + "q": 49, + "transverse_axes": [ + 50, + 4, + 8, + 35, + 19, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 51, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 49, + 0, + 0, + 0, + 49, + 49, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 17, + "q": 81, + "transverse_axes": [ + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 83, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 81, + 0, + 0, + 0, + 81, + 0, + 81, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 18, + "q": 145, + "transverse_axes": [ + 146, + 4, + 8, + 131, + 32, + 64, + 19, + 256 + ], + "raw_D0_to_positive_D8_translation": 147, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 145, + 0, + 0, + 0, + 145, + 0, + 0, + 145, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 19, + "q": 273, + "transverse_axes": [ + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "raw_D0_to_positive_D8_translation": 275, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 273, + 0, + 0, + 0, + 273, + 0, + 0, + 0, + 273, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 20, + "q": 161, + "transverse_axes": [ + 162, + 4, + 8, + 16, + 131, + 64, + 35, + 256 + ], + "raw_D0_to_positive_D8_translation": 163, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 161, + 0, + 0, + 0, + 0, + 161, + 0, + 161, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 21, + "q": 289, + "transverse_axes": [ + 290, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "raw_D0_to_positive_D8_translation": 291, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 289, + 0, + 0, + 0, + 0, + 289, + 0, + 0, + 289, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 22, + "q": 193, + "transverse_axes": [ + 194, + 4, + 8, + 16, + 32, + 131, + 67, + 256 + ], + "raw_D0_to_positive_D8_translation": 195, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 193, + 0, + 0, + 0, + 0, + 0, + 193, + 193, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 23, + "q": 321, + "transverse_axes": [ + 322, + 4, + 8, + 16, + 32, + 259, + 128, + 67 + ], + "raw_D0_to_positive_D8_translation": 323, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 321, + 0, + 0, + 0, + 0, + 0, + 321, + 0, + 321, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 24, + "q": 385, + "transverse_axes": [ + 386, + 4, + 8, + 16, + 32, + 64, + 259, + 131 + ], + "raw_D0_to_positive_D8_translation": 387, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 385, + 0, + 0, + 0, + 0, + 0, + 0, + 385, + 385, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 25, + "q": 14, + "transverse_axes": [ + 13, + 11, + 7, + 16, + 32, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 15, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 14, + 14, + 14, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 26, + "q": 22, + "transverse_axes": [ + 21, + 19, + 8, + 7, + 32, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 23, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 22, + 22, + 0, + 22, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 27, + "q": 38, + "transverse_axes": [ + 37, + 35, + 8, + 16, + 7, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 39, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 38, + 38, + 0, + 0, + 38, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 28, + "q": 70, + "transverse_axes": [ + 69, + 67, + 8, + 16, + 32, + 7, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 71, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 70, + 70, + 0, + 0, + 0, + 70, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 29, + "q": 134, + "transverse_axes": [ + 133, + 131, + 8, + 16, + 32, + 64, + 7, + 256 + ], + "raw_D0_to_positive_D8_translation": 135, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 134, + 134, + 0, + 0, + 0, + 0, + 134, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 30, + "q": 262, + "transverse_axes": [ + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "raw_D0_to_positive_D8_translation": 263, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 262, + 262, + 0, + 0, + 0, + 0, + 0, + 262, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 31, + "q": 26, + "transverse_axes": [ + 25, + 4, + 19, + 11, + 32, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 27, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 26, + 0, + 26, + 26, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 32, + "q": 74, + "transverse_axes": [ + 73, + 4, + 67, + 16, + 32, + 11, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 75, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 74, + 0, + 74, + 0, + 0, + 74, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 33, + "q": 138, + "transverse_axes": [ + 137, + 4, + 131, + 16, + 32, + 64, + 11, + 256 + ], + "raw_D0_to_positive_D8_translation": 139, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 138, + 0, + 138, + 0, + 0, + 0, + 138, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 34, + "q": 266, + "transverse_axes": [ + 265, + 4, + 259, + 16, + 32, + 64, + 128, + 11 + ], + "raw_D0_to_positive_D8_translation": 267, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 266, + 0, + 266, + 0, + 0, + 0, + 0, + 266, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 35, + "q": 50, + "transverse_axes": [ + 49, + 4, + 8, + 35, + 19, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 51, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 50, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 36, + "q": 146, + "transverse_axes": [ + 145, + 4, + 8, + 131, + 32, + 64, + 19, + 256 + ], + "raw_D0_to_positive_D8_translation": 147, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 146, + 0, + 0, + 146, + 0, + 0, + 146, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 37, + "q": 274, + "transverse_axes": [ + 273, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "raw_D0_to_positive_D8_translation": 275, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 274, + 0, + 0, + 274, + 0, + 0, + 0, + 274, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 38, + "q": 98, + "transverse_axes": [ + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 99, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 98, + 0, + 0, + 0, + 98, + 98, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 39, + "q": 162, + "transverse_axes": [ + 161, + 4, + 8, + 16, + 131, + 64, + 35, + 256 + ], + "raw_D0_to_positive_D8_translation": 163, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 162, + 0, + 0, + 0, + 162, + 0, + 162, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 40, + "q": 290, + "transverse_axes": [ + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "raw_D0_to_positive_D8_translation": 291, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 290, + 0, + 0, + 0, + 290, + 0, + 0, + 290, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 41, + "q": 194, + "transverse_axes": [ + 193, + 4, + 8, + 16, + 32, + 131, + 67, + 256 + ], + "raw_D0_to_positive_D8_translation": 195, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 194, + 0, + 0, + 0, + 0, + 194, + 194, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 42, + "q": 322, + "transverse_axes": [ + 321, + 4, + 8, + 16, + 32, + 259, + 128, + 67 + ], + "raw_D0_to_positive_D8_translation": 323, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 322, + 0, + 0, + 0, + 0, + 322, + 0, + 322, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 43, + "q": 386, + "transverse_axes": [ + 385, + 4, + 8, + 16, + 32, + 64, + 259, + 131 + ], + "raw_D0_to_positive_D8_translation": 387, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 386, + 0, + 0, + 0, + 0, + 0, + 386, + 386, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 44, + "q": 28, + "transverse_axes": [ + 2, + 25, + 21, + 13, + 32, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 29, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 28, + 28, + 28, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 45, + "q": 44, + "transverse_axes": [ + 2, + 41, + 37, + 16, + 13, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 45, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 44, + 44, + 0, + 44, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 46, + "q": 140, + "transverse_axes": [ + 2, + 137, + 133, + 16, + 32, + 64, + 13, + 256 + ], + "raw_D0_to_positive_D8_translation": 141, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 140, + 140, + 0, + 0, + 0, + 140, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 47, + "q": 268, + "transverse_axes": [ + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "raw_D0_to_positive_D8_translation": 269, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 268, + 268, + 0, + 0, + 0, + 0, + 268, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 48, + "q": 84, + "transverse_axes": [ + 2, + 81, + 8, + 69, + 32, + 21, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 85, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 84, + 0, + 84, + 0, + 84, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 49, + "q": 148, + "transverse_axes": [ + 2, + 145, + 8, + 133, + 32, + 64, + 21, + 256 + ], + "raw_D0_to_positive_D8_translation": 149, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 148, + 0, + 148, + 0, + 0, + 148, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 50, + "q": 276, + "transverse_axes": [ + 2, + 273, + 8, + 261, + 32, + 64, + 128, + 21 + ], + "raw_D0_to_positive_D8_translation": 277, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 276, + 0, + 276, + 0, + 0, + 0, + 276, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 51, + "q": 100, + "transverse_axes": [ + 2, + 97, + 8, + 16, + 69, + 37, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 101, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 100, + 0, + 0, + 100, + 100, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 52, + "q": 164, + "transverse_axes": [ + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "raw_D0_to_positive_D8_translation": 165, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 164, + 0, + 0, + 164, + 0, + 164, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 53, + "q": 292, + "transverse_axes": [ + 2, + 289, + 8, + 16, + 261, + 64, + 128, + 37 + ], + "raw_D0_to_positive_D8_translation": 293, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 292, + 0, + 0, + 292, + 0, + 0, + 292, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 54, + "q": 196, + "transverse_axes": [ + 2, + 193, + 8, + 16, + 32, + 133, + 69, + 256 + ], + "raw_D0_to_positive_D8_translation": 197, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 196, + 0, + 0, + 0, + 196, + 196, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 55, + "q": 324, + "transverse_axes": [ + 2, + 321, + 8, + 16, + 32, + 261, + 128, + 69 + ], + "raw_D0_to_positive_D8_translation": 325, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 324, + 0, + 0, + 0, + 324, + 0, + 324, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 56, + "q": 388, + "transverse_axes": [ + 2, + 385, + 8, + 16, + 32, + 64, + 261, + 133 + ], + "raw_D0_to_positive_D8_translation": 389, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 388, + 0, + 0, + 0, + 0, + 388, + 388, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 57, + "q": 56, + "transverse_axes": [ + 2, + 4, + 49, + 41, + 25, + 64, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 57, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 56, + 56, + 56, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 58, + "q": 88, + "transverse_axes": [ + 2, + 4, + 81, + 73, + 32, + 25, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 89, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 88, + 88, + 0, + 88, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 59, + "q": 152, + "transverse_axes": [ + 2, + 4, + 145, + 137, + 32, + 64, + 25, + 256 + ], + "raw_D0_to_positive_D8_translation": 153, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 152, + 152, + 0, + 0, + 152, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 60, + "q": 280, + "transverse_axes": [ + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "raw_D0_to_positive_D8_translation": 281, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 280, + 280, + 0, + 0, + 0, + 280, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 61, + "q": 104, + "transverse_axes": [ + 2, + 4, + 97, + 16, + 73, + 41, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 105, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 104, + 0, + 104, + 104, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 62, + "q": 168, + "transverse_axes": [ + 2, + 4, + 161, + 16, + 137, + 64, + 41, + 256 + ], + "raw_D0_to_positive_D8_translation": 169, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 168, + 0, + 168, + 0, + 168, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 63, + "q": 296, + "transverse_axes": [ + 2, + 4, + 289, + 16, + 265, + 64, + 128, + 41 + ], + "raw_D0_to_positive_D8_translation": 297, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 296, + 0, + 296, + 0, + 0, + 296, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 64, + "q": 200, + "transverse_axes": [ + 2, + 4, + 193, + 16, + 32, + 137, + 73, + 256 + ], + "raw_D0_to_positive_D8_translation": 201, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 200, + 0, + 0, + 200, + 200, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 65, + "q": 328, + "transverse_axes": [ + 2, + 4, + 321, + 16, + 32, + 265, + 128, + 73 + ], + "raw_D0_to_positive_D8_translation": 329, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 328, + 0, + 0, + 328, + 0, + 328, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 66, + "q": 392, + "transverse_axes": [ + 2, + 4, + 385, + 16, + 32, + 64, + 265, + 137 + ], + "raw_D0_to_positive_D8_translation": 393, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 392, + 0, + 0, + 0, + 392, + 392, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 67, + "q": 112, + "transverse_axes": [ + 2, + 4, + 8, + 97, + 81, + 49, + 128, + 256 + ], + "raw_D0_to_positive_D8_translation": 113, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 112, + 112, + 112, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 68, + "q": 176, + "transverse_axes": [ + 2, + 4, + 8, + 161, + 145, + 64, + 49, + 256 + ], + "raw_D0_to_positive_D8_translation": 177, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 176, + 176, + 0, + 176, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 69, + "q": 304, + "transverse_axes": [ + 2, + 4, + 8, + 289, + 273, + 64, + 128, + 49 + ], + "raw_D0_to_positive_D8_translation": 305, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 304, + 304, + 0, + 0, + 304, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 70, + "q": 208, + "transverse_axes": [ + 2, + 4, + 8, + 193, + 32, + 145, + 81, + 256 + ], + "raw_D0_to_positive_D8_translation": 209, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 208, + 0, + 208, + 208, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 71, + "q": 336, + "transverse_axes": [ + 2, + 4, + 8, + 321, + 32, + 273, + 128, + 81 + ], + "raw_D0_to_positive_D8_translation": 337, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 336, + 0, + 336, + 0, + 336, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 72, + "q": 400, + "transverse_axes": [ + 2, + 4, + 8, + 385, + 32, + 64, + 273, + 145 + ], + "raw_D0_to_positive_D8_translation": 401, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 400, + 0, + 0, + 400, + 400, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 73, + "q": 224, + "transverse_axes": [ + 2, + 4, + 8, + 16, + 193, + 161, + 97, + 256 + ], + "raw_D0_to_positive_D8_translation": 225, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 224, + 224, + 224, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 74, + "q": 352, + "transverse_axes": [ + 2, + 4, + 8, + 16, + 321, + 289, + 128, + 97 + ], + "raw_D0_to_positive_D8_translation": 353, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 352, + 352, + 0, + 352, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 75, + "q": 416, + "transverse_axes": [ + 2, + 4, + 8, + 16, + 385, + 64, + 289, + 161 + ], + "raw_D0_to_positive_D8_translation": 417, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 416, + 0, + 416, + 416, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 76, + "q": 448, + "transverse_axes": [ + 2, + 4, + 8, + 16, + 32, + 385, + 321, + 193 + ], + "raw_D0_to_positive_D8_translation": 449, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 448, + 448, + 448, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 77, + "q": 508, + "transverse_axes": [ + 2, + 505, + 501, + 493, + 477, + 445, + 381, + 253 + ], + "raw_D0_to_positive_D8_translation": 509, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 0, + 508, + 508, + 508, + 508, + 508, + 508, + 508, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 78, + "q": 506, + "transverse_axes": [ + 505, + 4, + 499, + 491, + 475, + 443, + 379, + 251 + ], + "raw_D0_to_positive_D8_translation": 507, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 506, + 0, + 506, + 506, + 506, + 506, + 506, + 506, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 79, + "q": 502, + "transverse_axes": [ + 501, + 499, + 8, + 487, + 471, + 439, + 375, + 247 + ], + "raw_D0_to_positive_D8_translation": 503, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 502, + 502, + 0, + 502, + 502, + 502, + 502, + 502, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 80, + "q": 494, + "transverse_axes": [ + 493, + 491, + 487, + 16, + 463, + 431, + 367, + 239 + ], + "raw_D0_to_positive_D8_translation": 495, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 494, + 494, + 494, + 0, + 494, + 494, + 494, + 494, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 81, + "q": 478, + "transverse_axes": [ + 477, + 475, + 471, + 463, + 32, + 415, + 351, + 223 + ], + "raw_D0_to_positive_D8_translation": 479, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 478, + 478, + 478, + 478, + 0, + 478, + 478, + 478, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 82, + "q": 446, + "transverse_axes": [ + 445, + 443, + 439, + 431, + 415, + 64, + 319, + 191 + ], + "raw_D0_to_positive_D8_translation": 447, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 446, + 446, + 446, + 446, + 446, + 0, + 446, + 446, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 83, + "q": 382, + "transverse_axes": [ + 381, + 379, + 375, + 367, + 351, + 319, + 128, + 127 + ], + "raw_D0_to_positive_D8_translation": 383, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 382, + 382, + 382, + 382, + 382, + 382, + 0, + 382, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 84, + "q": 254, + "transverse_axes": [ + 253, + 251, + 247, + 239, + 223, + 191, + 127, + 256 + ], + "raw_D0_to_positive_D8_translation": 255, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 0, + 254, + 254, + 254, + 254, + 254, + 254, + 254, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 85, + "q": 505, + "transverse_axes": [ + 506, + 4, + 499, + 491, + 475, + 443, + 379, + 251 + ], + "raw_D0_to_positive_D8_translation": 507, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 505, + 0, + 0, + 505, + 505, + 505, + 505, + 505, + 505, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 86, + "q": 501, + "transverse_axes": [ + 502, + 499, + 8, + 487, + 471, + 439, + 375, + 247 + ], + "raw_D0_to_positive_D8_translation": 503, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 501, + 0, + 501, + 0, + 501, + 501, + 501, + 501, + 501, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 87, + "q": 493, + "transverse_axes": [ + 494, + 491, + 487, + 16, + 463, + 431, + 367, + 239 + ], + "raw_D0_to_positive_D8_translation": 495, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 493, + 0, + 493, + 493, + 0, + 493, + 493, + 493, + 493, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 88, + "q": 477, + "transverse_axes": [ + 478, + 475, + 471, + 463, + 32, + 415, + 351, + 223 + ], + "raw_D0_to_positive_D8_translation": 479, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 477, + 0, + 477, + 477, + 477, + 0, + 477, + 477, + 477, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 89, + "q": 445, + "transverse_axes": [ + 446, + 443, + 439, + 431, + 415, + 64, + 319, + 191 + ], + "raw_D0_to_positive_D8_translation": 447, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 445, + 0, + 445, + 445, + 445, + 445, + 0, + 445, + 445, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 90, + "q": 381, + "transverse_axes": [ + 382, + 379, + 375, + 367, + 351, + 319, + 128, + 127 + ], + "raw_D0_to_positive_D8_translation": 383, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 381, + 0, + 381, + 381, + 381, + 381, + 381, + 0, + 381, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 91, + "q": 253, + "transverse_axes": [ + 254, + 251, + 247, + 239, + 223, + 191, + 127, + 256 + ], + "raw_D0_to_positive_D8_translation": 255, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 253, + 0, + 253, + 253, + 253, + 253, + 253, + 253, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 92, + "q": 499, + "transverse_axes": [ + 501, + 502, + 8, + 487, + 471, + 439, + 375, + 247 + ], + "raw_D0_to_positive_D8_translation": 503, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 499, + 499, + 0, + 0, + 499, + 499, + 499, + 499, + 499, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 93, + "q": 491, + "transverse_axes": [ + 493, + 494, + 487, + 16, + 463, + 431, + 367, + 239 + ], + "raw_D0_to_positive_D8_translation": 495, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 491, + 491, + 0, + 491, + 0, + 491, + 491, + 491, + 491, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 94, + "q": 475, + "transverse_axes": [ + 477, + 478, + 471, + 463, + 32, + 415, + 351, + 223 + ], + "raw_D0_to_positive_D8_translation": 479, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 475, + 475, + 0, + 475, + 475, + 0, + 475, + 475, + 475, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 95, + "q": 443, + "transverse_axes": [ + 445, + 446, + 439, + 431, + 415, + 64, + 319, + 191 + ], + "raw_D0_to_positive_D8_translation": 447, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 443, + 443, + 0, + 443, + 443, + 443, + 0, + 443, + 443, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 96, + "q": 379, + "transverse_axes": [ + 381, + 382, + 375, + 367, + 351, + 319, + 128, + 127 + ], + "raw_D0_to_positive_D8_translation": 383, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 379, + 379, + 0, + 379, + 379, + 379, + 379, + 0, + 379, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 97, + "q": 251, + "transverse_axes": [ + 253, + 254, + 247, + 239, + 223, + 191, + 127, + 256 + ], + "raw_D0_to_positive_D8_translation": 255, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 251, + 251, + 0, + 251, + 251, + 251, + 251, + 251, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 98, + "q": 487, + "transverse_axes": [ + 493, + 491, + 494, + 16, + 463, + 431, + 367, + 239 + ], + "raw_D0_to_positive_D8_translation": 495, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 487, + 487, + 487, + 0, + 0, + 487, + 487, + 487, + 487, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 99, + "q": 471, + "transverse_axes": [ + 477, + 475, + 478, + 463, + 32, + 415, + 351, + 223 + ], + "raw_D0_to_positive_D8_translation": 479, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 471, + 471, + 471, + 0, + 471, + 0, + 471, + 471, + 471, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 100, + "q": 439, + "transverse_axes": [ + 445, + 443, + 446, + 431, + 415, + 64, + 319, + 191 + ], + "raw_D0_to_positive_D8_translation": 447, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 439, + 439, + 439, + 0, + 439, + 439, + 0, + 439, + 439, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 101, + "q": 375, + "transverse_axes": [ + 381, + 379, + 382, + 367, + 351, + 319, + 128, + 127 + ], + "raw_D0_to_positive_D8_translation": 383, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 375, + 375, + 375, + 0, + 375, + 375, + 375, + 0, + 375, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 102, + "q": 247, + "transverse_axes": [ + 253, + 251, + 254, + 239, + 223, + 191, + 127, + 256 + ], + "raw_D0_to_positive_D8_translation": 255, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 247, + 247, + 247, + 0, + 247, + 247, + 247, + 247, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 103, + "q": 463, + "transverse_axes": [ + 477, + 475, + 471, + 478, + 32, + 415, + 351, + 223 + ], + "raw_D0_to_positive_D8_translation": 479, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 463, + 463, + 463, + 463, + 0, + 0, + 463, + 463, + 463, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 104, + "q": 431, + "transverse_axes": [ + 445, + 443, + 439, + 446, + 415, + 64, + 319, + 191 + ], + "raw_D0_to_positive_D8_translation": 447, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 431, + 431, + 431, + 431, + 0, + 431, + 0, + 431, + 431, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 105, + "q": 367, + "transverse_axes": [ + 381, + 379, + 375, + 382, + 351, + 319, + 128, + 127 + ], + "raw_D0_to_positive_D8_translation": 383, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 367, + 367, + 367, + 367, + 0, + 367, + 367, + 0, + 367, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 106, + "q": 239, + "transverse_axes": [ + 253, + 251, + 247, + 254, + 223, + 191, + 127, + 256 + ], + "raw_D0_to_positive_D8_translation": 255, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 239, + 239, + 239, + 239, + 0, + 239, + 239, + 239, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 107, + "q": 415, + "transverse_axes": [ + 445, + 443, + 439, + 431, + 446, + 64, + 319, + 191 + ], + "raw_D0_to_positive_D8_translation": 447, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 415, + 415, + 415, + 415, + 415, + 0, + 0, + 415, + 415, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 108, + "q": 351, + "transverse_axes": [ + 381, + 379, + 375, + 367, + 382, + 319, + 128, + 127 + ], + "raw_D0_to_positive_D8_translation": 383, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 351, + 351, + 351, + 351, + 351, + 0, + 351, + 0, + 351, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 109, + "q": 223, + "transverse_axes": [ + 253, + 251, + 247, + 239, + 254, + 191, + 127, + 256 + ], + "raw_D0_to_positive_D8_translation": 255, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 223, + 223, + 223, + 223, + 223, + 0, + 223, + 223, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 110, + "q": 319, + "transverse_axes": [ + 381, + 379, + 375, + 367, + 351, + 382, + 128, + 127 + ], + "raw_D0_to_positive_D8_translation": 383, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 319, + 319, + 319, + 319, + 319, + 319, + 0, + 0, + 319, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + }, + { + "port": 111, + "q": 191, + "transverse_axes": [ + 253, + 251, + 247, + 239, + 223, + 254, + 127, + 256 + ], + "raw_D0_to_positive_D8_translation": 255, + "raw_D0_commutes_with_S": false, + "S_quadratic_rows": [ + 191, + 191, + 191, + 191, + 191, + 191, + 0, + 191, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "monomial": true, + "conjugated_gaussian_grade": 1 + } + ], + "exact_S": "S|x>=i^parity(q&x)|x>; its columnwise positive-width lift multiplies by i^popcount(shared-coordinate word)", + "main_only_conjugation": "W=diag(S,S,I_helpers,I_centres); W N W^-1", + "source_632": "Autonomous helper outputs unchanged; original owned centres stay initialized, erased and uncredited inside each native invocation.", + "retained_640": "Helper outputs remain autonomous but centre coupling becomes R_X*S^-1 and main centre scatter becomes S*B_Y. No autonomous-centre or extra-centre reward follows.", + "raw_D0_warning": "RawD0=F9*Q^-1 includes a per-port translation; it need not commute with S. The emitted exact translation normalizes it to the positive transverse8 word before that commutation is used.", + "recursive_cost": 0, + "finite_boundary": "One conjugated FULL invocation adds224 inputS^-1 and224 outputS passes before adjacent wrapper simplification. Finite scalar/route bill must include these448 passes plus the explicit rawD0 endpoint translations if not already fused into source normalizers.", + "allwidth": "Only literal word products, inverses, disjoint-axis commutation and coordinate phase lift are used. No sum is tensorized and no width-one scalar-phase identification is assumed.", + "two_call_endpoint_constructed": false, + "new_kappa": null +} diff --git a/research/two-full-central-obstruction/inputs/native/NATIVE-VALIDATION.json b/research/two-full-central-obstruction/inputs/native/NATIVE-VALIDATION.json new file mode 100644 index 0000000000..d8a2e0a915 --- /dev/null +++ b/research/two-full-central-obstruction/inputs/native/NATIVE-VALIDATION.json @@ -0,0 +1,142 @@ +{ + "actual_word_canonical_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd", + "controls": [ + { + "name": "wrong_paid_rank", + "rejected": "Paid rank and source frame" + } + ], + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "native": { + "backward": { + "arbitrary_owned_C0_cleared": true, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 6396, + "role": [ + "L", + 225 + ] + }, + "max_denominator": 64, + "max_formal_prefix_l1": "169", + "paid_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5327, + "real_scalar_allowance": 158168, + "scalar_frames_checked": true, + "second_literal": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158168, + "direction": "backward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3290, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5327 + } + }, + "forward": { + "arbitrary_owned_C0_cleared": true, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "l1_witness": { + "event": 19036, + "role": [ + "L", + 224 + ] + }, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "paid_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5327, + "real_scalar_allowance": 158120, + "scalar_frames_checked": true, + "second_literal": { + "all_scalar_frames_checked": true, + "clean_J": false, + "conservative_real_scalar_primitive_allowance": 158120, + "direction": "forward", + "dyadic_coefficients_and_unit_scales_checked": true, + "event_counts": { + "adapter": 448, + "center": 8, + "climb": 3290, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "expected_restored_arbitrary_cleanup_buffers": 0, + "expected_restored_helpers": 408, + "explicitly_owned_C_fields_cleared": 1, + "free_warp_operator_endpoint_matches": true, + "independent_borrowed_input_fields": 632, + "mismatch_examples": [], + "negative_control_omitted_last_cleanup_scalar": false, + "original_data_fields": 224, + "paid_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "paid_rank_mass": 5327 + } + } + }, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "seconds": 4.510284199990565, + "status": "PASS_JOINT_HELPER_MAPS_NATIVE_BOTH_632_INTERPRETERS", + "verifier_sha256": "785f67e358ac4cff60a64db4b012c43a02a833d90926d72624880040f9648c66" +} diff --git a/research/two-full-central-obstruction/inputs/native/README.md b/research/two-full-central-obstruction/inputs/native/README.md new file mode 100644 index 0000000000..e4c18ea092 --- /dev/null +++ b/research/two-full-central-obstruction/inputs/native/README.md @@ -0,0 +1,101 @@ +# Joint helper entrances and native maps + +TL;DR: the new local paid profile is +`{1:2201,2:412,3:510,4:127,5:40,8:8}`, with the same productive helper census +`{4:28,7:7,8:47,9:326}` as PR4610. Compared with PR4610, four copies of two +rank-four jobs become rank-three plus rank-five jobs. Strict concavity improves +the paid moment at every real exponent between zero and one. The full p16 price +and Lean proof are supplied in the companion round-three package. + +All 408 helper inputs remain arbitrary and independent. The new witness changes +26 helper entrances, 316 scalar contact frames, 20 warp frame pairs and 20 native +G maps. It preserves all main input/output interfaces, every scalar opcode, +coefficient and chronological order, all owned-center jobs, and all helper exits. +All 4,429 frame registry entries are byte-for-byte inherited from PR4610. + +Both retained exact interpreters pass all 632 arbitrary-input columns in both +orientations. Exact Clifford admission passes all 20 changed native G operators +on 512 columns with absolute phase, all 180 actual warp classes, 105 new paid +frame pairs, and all 26 changed helper boundaries, in both orientations. +The native scalar allowances remain 158120 forward and 158168 backward. + +## Reproduce the mathematical witness + +From the repository root, using Python 3.14 and only its standard library: + +```sh +python3.14 -B research/kappa-round3-warp-20261022/regenerate.py +python3.14 -B research/kappa-round3-warp-20261022/verify_candidate.py +python3.14 -B research/kappa-round3-warp-20261022/phase_check.py +``` + +`ACTUAL-WORD.json.gz` is the admitted witness. Its decompressed canonical SHA256 +is `cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd`. +`PATCH.json` reconstructs every byte of it from the exact frozen PR4610 word. +The patch guards each old boundary/contact before changing it. No discovery +solver is used by these checks. `SOURCES.json` pins inherited sources and phase +evidence, with predecessor attribution retained. + +The source-local Windows interpreter for this run is +`C:\Users\caoyi\AppData\Local\Python\pythoncore-3.14-64\python.exe`. +No virtual environment was created or activated. + +## Discovery and bounded unsuccessful searches + +The discovery scripts use SciPy 1.18.1 and NumPy 2.5.4, installed in ignored +`.deps/` using the global interpreter. Admission does not use either package. + +1. `line_free_milp.py --operator all --seconds 180` frees all 72 late native map + contacts, preserving the twelve operators' additional prelude line maps. + Its 977794 variables and 202730 constraints yield the unchanged old invoice. +2. `helper_line_milp.py --operator all --seconds 180` also frees all 408 helper + entrances, optimizing the complete paid-minus-productive moment. Its + 1636247 variables and 308777 constraints discover the positive witness. +3. `both_boundary_milp.py --operator all --seconds 180` additionally frees every + helper exit. Its 2000950 variables and 385938 constraints yield the same new + paid/helper profile. This separate output is not the frozen witness. + +Every enumerated quotient interval in these runs has dimension at most five; +the interval enumerator does not truncate those domains. HiGHS reports floating +finite-model optimality. That report is discovery evidence and is not an exact +ceiling or an impossibility proof for other circuits, words, or interfaces. +Scripts that discover a positive candidate can overwrite their discovery +outputs; the separately frozen actual word and guarded patch remain authoritative. + +During this round Pierre-Loic Doulcet's public PR4626 was found independently +proposing a helper621 two-chart change on PR4610, at source head +`c665f908fc991aa558ea8a8cd33e9ad26f97a22d`. Its result is credited and is not +claimed as new here. `combine_621.py` checks the direct combination with the new +joint-map witness. That particular combination worsens the moment; the saved +negative invoice screen does not rule out jointly redesigned combinations. + +## Scope, credit and open next questions + +These are finite exact circuit/census/phase certificates and scoped Lean +obligations. The full integer-multiplication theorem retains the repository's +analytic decomposition, native supplier, allowed owned-storage erasure, +whole-job normalizers, finite-template closure, precision, prime-avoidance and +exact-recovery assumptions. No measured runtime speedup or independent review +is claimed. + +The new lever is to change helper input charts and native maps together. Freeing +only native maps leaves the old invoice unchanged in the tested model. The +helper credit couples interface choices to the paid contact graph; every helper +is charged and credited using its actual entrance and exit. + +Open next questions: + +- Free the twelve prelude line contracts jointly with late map contacts. A first + step is an exact simultaneous two-subspace map test. Shared G consistency and + arbitrary-input semantic replay are the admission blockers. +- Change scalar chronological order or the owned-center walk, then replay the + whole word. Current solver domains preserve both, so their reported optimum + does not constrain these directions. +- Prove an exact finite-model dual bound if a ceiling is needed. Floating solver + status alone supplies no such certificate. + +Credit the PR4610 predecessor by Cao Yifan, Cinna Davis's PR4470 native supplier +and cumulative sources, Dugongue's transported warp-frame lemma, zxv's native +and compiler work, Jacob Alan Sussman's mixed-target recursion, and Pierre-Loic +Doulcet's separate PR4626 contribution. Prepared by **Cao Yifan**, with +substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/two-full-central-obstruction/inputs/native/complex_controller_factor.py b/research/two-full-central-obstruction/inputs/native/complex_controller_factor.py new file mode 100644 index 0000000000..cb0cff7c8b --- /dev/null +++ b/research/two-full-central-obstruction/inputs/native/complex_controller_factor.py @@ -0,0 +1,270 @@ +#!/usr/bin/env python3 +"""Exact complex controller factorizations over an integral Laurent ring. + +The native local operator is an EXPLICIT INPUT CONTRACT supplied by the +complex reconstruction: F_s=D_s S_y(Q^-1), B_s=D_s S_x(-Q). +No order-two relation, numerical Fourier characters, phase erasure, or +F2-to-complex lift is used in the acceptance check. All Laurent +coefficients are reconstructed and multiplied over Q. Binary candidates +are only a finite discovery filter, not an exhaustive rational census. +Apache-2.0; substantial OpenAI assistance. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import json +import time + +import mixed_productive_bit as B + +HERE = Path(__file__).resolve().parent + + +def plus(a, b, coefficient=1): + result = dict(a) + for term, value in b.items(): + result[term] = result.get(term, 0)+coefficient*value + if not result[term]: + del result[term] + return result + + +def monomial_times(polynomial, exponents, coefficient=1): + return {tuple(a+b for a, b in zip(term, exponents)):coefficient*value + for term, value in polynomial.items()} + + +def controller(p, keep, wrong_reverse_sign=False): + n, stages = 2*p, 2*p+1 + zero = (0,)*(stages+1) + matrix = [[{zero:1} if i == j else {} for j in range(n)] for i in range(n)] + events, idle = [], [] + def term(q, selected): + return (q,)+tuple(int(s in selected) for s in range(stages)) + def idle_call(pair, selected, kind): + index = len(idle) + retained = bool(keep >> index & 1) + idle.append(dict(index=index, kind=kind, pair=pair, stages=list(selected), + rank=8*len(selected), retained=retained)) + if retained: + for role in (2*pair, 2*pair+1): + matrix[role] = [monomial_times(x, term(0, selected)) for x in matrix[role]] + events.append(["IDLE", pair, list(selected)]) + def local(stage, pair, reverse): + x, y = 2*pair, 2*pair+1 + if reverse: + x, y = y, x + sign = -1 if reverse and not wrong_reverse_sign else 1 + exponent = 1 if reverse else -1 + matrix[y] = [plus(a, monomial_times(b, term(exponent, []), sign)) + for a, b in zip(matrix[y], matrix[x])] + for role in (x, y): + matrix[role] = [monomial_times(x, term(0, [stage])) for x in matrix[role]] + events.append(["LOCAL", stage, pair, reverse]) + if stage % 2 and stage <= 2*p-3: + idle_call((stage+1)//2, list(range(stage+1)), "initial") + elif stage % 2 == 0 and 2 <= stage <= 2*p-2: + idle_call(stage//2, [stage], "middle") + elif stage == 2*p: + for j in range(p-1): + idle_call(j, list(range(2*j+3, 2*p+1)), "terminal") + def bridge(dst, src, coefficient): + for d, s, c in ((2*dst, 2*src, coefficient), (2*src+1, 2*dst+1, -coefficient)): + matrix[d] = [plus(a, b, c) for a, b in zip(matrix[d], matrix[s])] + events.append(["ADD", d, s, c]) + local(0, 0, False) + for j in range(p): + local(2*j+1, j, True) + if j < p-1: + bridge(j, j+1, 1) + local(2*j+2, j, False) + if j < p-1: + bridge(j, j+1, -1) + for j in reversed(range(p-1)): + bridge(j+1, j, 1) + for j in range(p): + matrix[2*j], matrix[2*j+1] = matrix[2*j+1], [monomial_times(x, zero, -1) for x in matrix[2*j]] + events.append(["SIGNED_SWAP", 2*j, 2*j+1]) + coefficients = {} + for i, row in enumerate(matrix): + for j, polynomial in enumerate(row): + for key, value in polynomial.items(): + coefficients.setdefault(key, [[Q(0)]*n for _ in range(n)])[i][j] += value + coefficients = {key:matrix for key, matrix in coefficients.items() if any(any(row) for row in matrix)} + return coefficients, events, idle + + +def matrix_rank(rows): + basis = {} + for row in rows: + row = list(map(Q, row)) + for j in sorted(basis): + if row[j]: + scale = row[j] + row = [a-scale*b for a, b in zip(row, basis[j])] + pivot = next((j for j, x in enumerate(row) if x), None) + if pivot is not None: + scale = row[pivot] + basis[pivot] = [x/scale for x in row] + return len(basis) + + +def scalar_program(matrix): + n = len(matrix) + work = [row[:] for row in matrix] + elimination = [] + for j in range(n): + pivot = next(i for i in range(j, n) if work[i][j]) + if pivot != j: + work[j], work[pivot] = work[pivot], work[j] + elimination.append(["SWAP", j, pivot]) + if work[j][j] != 1: + scale = 1/work[j][j] + work[j] = [scale*x for x in work[j]] + elimination.append(["SCALE", j, str(scale)]) + for i in range(n): + if i != j and work[i][j]: + scale = -work[i][j] + work[i] = [a+scale*b for a, b in zip(work[i], work[j])] + elimination.append(["ADD", i, j, str(scale)]) + program = [] + for op in reversed(elimination): + if op[0] == "SWAP": + program.append(op) + elif op[0] == "SCALE": + program.append(["SCALE", op[1], str(1/Q(op[2]))]) + else: + program.append(["ADD", op[1], op[2], str(-Q(op[3]))]) + replay = [[Q(i == j) for j in range(n)] for i in range(n)] + for op in program: + if op[0] == "SWAP": + replay[op[1]], replay[op[2]] = replay[op[2]], replay[op[1]] + elif op[0] == "SCALE": + replay[op[1]] = [Q(op[2])*x for x in replay[op[1]]] + else: + replay[op[1]] = [a+Q(op[3])*b for a, b in zip(replay[op[1]], replay[op[2]])] + B.need(replay == matrix, "Exact signed scalar boundary program") + coefficients = [Q(x) for row in matrix for x in row] + B.need(all(q.denominator & (q.denominator-1) == 0 for q in coefficients), "Dyadic boundary coefficients") + return program + + +def factor(coefficients): + n = len(next(iter(coefficients.values()))) + total = [[sum(matrix[i][j] for matrix in coefficients.values()) for j in range(n)] for i in range(n)] + inverse = B.rational_inverse(total) + projectors = {key:B.matrix_multiply(inverse, matrix) for key, matrix in coefficients.items()} + for key, matrix in projectors.items(): + if B.matrix_multiply(matrix, matrix) != matrix: + return None + for other, second in projectors.items(): + if key != other and any(any(row) for row in B.matrix_multiply(matrix, second)): + return None + columns, diagonal = [], [] + for key, matrix in sorted(projectors.items()): + for column in zip(*matrix): + if matrix_rank(columns+[column]) > len(columns): + columns.append(list(column)) + diagonal.append(key) + B.need(len(columns) == n, "All rational projector images") + right = [list(row) for row in zip(*columns)] + left = B.matrix_multiply(B.rational_inverse(right), inverse) + transformed = {key:B.matrix_multiply(B.matrix_multiply(left, matrix), right) + for key, matrix in coefficients.items()} + expected = {key:[[Q(i == j and diagonal[i] == key) for j in range(n)] for i in range(n)] + for key in set(diagonal)} + B.need(transformed == expected, "Every Laurent coefficient equals the advertised diagonal") + return dict(left=left, right=right, diagonal=diagonal, + left_program=scalar_program(left), right_program=scalar_program(right)) + + +def serialize_matrix(matrix): + return [[str(x) for x in row] for row in matrix] + + +def serialize_case(p, keep, coefficients, events, idle, result): + # Rank normalization is an input contract of the complex native source: + # D0=F9 Q^-1; Ds for s>0 transform fresh eight-axis blocks; Q^2 and + # Ds^2 are explicitly free Pauli/translation operators. The EXACT + # Laurent monomials remain in this receipt for a separate phase audit. + jobs = Counter() + for term in result["diagonal"]: + B.need(term[0] in (-1, 1), "Only stated central-Q endpoint normalization") + B.need(all(x in (0, 1) for x in term[1:]), "No hidden squared stage transforms") + jobs[1+8*sum(term[1:])] += 112 + scalar_coefficients = [x for matrix in (result["left"], result["right"]) for row in matrix for x in row] + return dict(pairs=p, stages=2*p+1, keep_idle_mask=keep, + coefficient_variables=["Q"]+[f"D{s}" for s in range(2*p+1)], + coefficient_matrices=[dict(exponents=list(key), matrix=serialize_matrix(matrix)) + for key, matrix in sorted(coefficients.items())], + left=serialize_matrix(result["left"]), right=serialize_matrix(result["right"]), + left_program=result["left_program"], right_program=result["right_program"], + exact_diagonal_monomials=[list(term) for term in result["diagonal"]], + all_boundary_entries_integral=all(x.denominator == 1 for x in scalar_coefficients), + maximum_boundary_absolute_coefficient=str(max(map(abs, scalar_coefficients))), + endpoint_after_stated_free_Pauli_normalization=dict(sorted(jobs.items())), + retained_idle_windows=[row for row in idle if row["retained"]], + omitted_idle_windows=[row for row in idle if not row["retained"]], + physical_events=events, + full_Laurent_identity=True, native_operator_contract_independently_replayed=False) + + +def run(max_p): + start = time.monotonic() + cases, census = [], {} + for p in range(1, max_p+1): + binary_candidates = [] + for keep in range(1 << (3*(p-1))): + binary_coefficients, _, _ = B.physical_controller(p, keep) + if B.simultaneous_monomial_factor(binary_coefficients) is not None: + binary_candidates.append(keep) + passed = 0 + for keep in binary_candidates: + coefficients, events, idle = controller(p, keep) + result = factor(coefficients) + if result is not None: + cases.append(serialize_case(p, keep, coefficients, events, idle, result)) + passed += 1 + census[p] = dict(binary_discovery_trials=1 << (3*(p-1)), + binary_candidates=len(binary_candidates), exact_Laurent_factorizations=passed) + print(json.dumps(dict(pairs=p, **census[p])), flush=True) + chosen = next(row for row in cases if row["pairs"] == 3 and row["keep_idle_mask"] == 43) + left = [[Q(x) for x in row] for row in chosen["left"]] + right = [[Q(x) for x in row] for row in chosen["right"]] + wrong, _, _ = controller(3, 43, True) + transformed = {key:B.matrix_multiply(B.matrix_multiply(left, matrix), right) + for key, matrix in wrong.items()} + expected = {tuple(key):[[Q(i == j and tuple(chosen["exact_diagonal_monomials"][i]) == tuple(key)) + for j in range(6)] for i in range(6)] + for key in chosen["exact_diagonal_monomials"]} + B.need(transformed != expected, "Incorrect backward sign rejected over Q") + return dict(schema="complex-controller-integral-Laurent-factorization/1", + status="PASS_EXACT_LAURENT_IDENTITIES_CONDITIONAL_ON_NATIVE_LOCAL_CONTRACT", + local_contract=dict(forward="D_s * [[1,0],[Q^-1,1]]", + backward="D_s * [[1,-Q],[0,1]]", + commutation="Q,D0,...,D(2p) commute; no finite-order relation used"), + census=census, cases=cases, + selected_p3_keep43=chosen, + controls=dict(wrong_backward_sign_rejected=True), + source_sha256={Path(__file__).name:sha256(Path(__file__).read_bytes()).hexdigest(), + "mixed_productive_bit.py":sha256((HERE/"mixed_productive_bit.py").read_bytes()).hexdigest()}, + runtime_seconds=time.monotonic()-start, + scope="Exact formal operator identity and emitted constant dyadic adapters. Native source binding, free-phase normalization, helper ownership, complete tariffs and all-size transfer belong to separate certificates.", + new_kappa=False) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--max-p", type=int, default=5) + parser.add_argument("--output", type=Path, default=HERE/"COMPLEX-CONTROLLER-FACTOR.json") + args = parser.parse_args() + B.need(3 <= args.max_p <= 6, "Bounded candidate menu") + data = run(args.max_p) + args.output.write_text(json.dumps(data, indent=2, sort_keys=True)+"\n") + print(json.dumps(dict(status=data["status"], seconds=data["runtime_seconds"], cases=len(data["cases"])))) + + +if __name__ == "__main__": + main() diff --git a/research/two-full-central-obstruction/inputs/native/native_inventory.py b/research/two-full-central-obstruction/inputs/native/native_inventory.py new file mode 100644 index 0000000000..8d2d96e399 --- /dev/null +++ b/research/two-full-central-obstruction/inputs/native/native_inventory.py @@ -0,0 +1,270 @@ +#!/usr/bin/env python3 +"""Dimension-independent exact native phase audit for an all-fresh controller. + +Uses the original nine-axis native supplier, with fresh eight-axis blocks. +No helper is hosted in a main idle field. Source all-column semantics remain +a written premise; this checks each finite raw contact and endpoint phase. +""" +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256 +from pathlib import Path +import gzip +import importlib.util +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +NATIVE = HERE/'dependencies/tensor-strictification/native_inventory.py' + + +def need(test, why): + if not test: + raise AssertionError(why) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def norm(terms): + out = Counter() + for axis, value in terms: + out[axis] += value + return tuple(sorted((axis, value % 4) for axis, value in out.items() if axis and value % 4)) + + +def act(columns, value): + result = 0 + while value: + low = value & -value + result ^= columns[low.bit_length()-1] + value ^= low + return result + + +@lru_cache(None) +def polynomial(terms, dimension): + linear = [0]*dimension + quadratic = [0]*dimension + for axis, value in terms: + support = [i for i in range(dimension) if axis >> i & 1] + for i in support: + linear[i] = (linear[i]+value) % 4 + if value % 2: + for j in support: + if i < j: + quadratic[i] ^= 1 << j + return tuple(linear), tuple(quadratic) + + +def contact(old, new, route, dimension): + moved = norm((act(route, axis), value) for axis, value in old) + left, right = polynomial(moved, dimension), polynomial(new, dimension) + need(left[1] == right[1], 'Actual native contact has identical quadratic part') + delta = tuple((a-b) % 4 for a, b in zip(right[0], left[0])) + need(all(value in (0, 2) for value in delta), 'Even linear phase is a physical translation') + shift = sum((value//2) << i for i, value in enumerate(delta)) + need(polynomial(norm(list(moved)+[(shift, 2)]), dimension) == right, 'Full native forward phase') + inverse_shift = act(route, shift) + inverse = norm([(act(route, axis), value) for axis, value in new]+[(inverse_shift, 2)]) + need(polynomial(inverse, dimension) == polynomial(old, dimension), 'Full inverse contact phase') + return {'translation': shift, 'inverse_translation': inverse_shift} + + +def scalar_invoice(case, native_scalar): + word = case['right_program']+case['left_program'] + counts = Counter(row[0] for row in word) + need(all(Q(row[-1]) in (1, -1) for row in word if row[0] in ('ADD', 'SCALE')), + 'Literal boundary word has only unit coefficients') + adds = counts['ADD']+3*counts['SWAP'] + negs = counts['SCALE']+counts['SWAP'] + bridges = sum(row[0] == 'ADD' for row in case['physical_events']) + swaps = sum(row[0] == 'SIGNED_SWAP' for row in case['physical_events']) + return native_scalar+112*(8*(adds+bridges+3*swaps)+2*negs) + + +def run(source_root, p=7, keep=232127, output_dir=None): + root = Path(source_root).resolve() + base = root/'research/kappa-rebuild' + need((p, keep) == (7, 232127), 'This source-bound native admission is p7 keep232127') + inventory = load(NATIVE, 'checked_native_inventory') + native_gate = inventory.run(root) + factor = load(HERE/'factor_receipt.py', 'fixed_p7_factor') + case, factor_pins = factor.run(root) + replay_path = base/'transfer-audit/p3_native_audit.py' + need(sha256(replay_path.read_bytes()).hexdigest() == '5504a55a50546418d10c522984438cdeedb44993f7c1dab7bd4aa1ae0515d902', + 'Exact independent Laurent replay source') + audit = load(replay_path, 'independent_laurent_replay') + audit.replay(case) + corrupted = json.loads(json.dumps(case)) + next(row for row in corrupted['physical_events'] if row[0] == 'LOCAL' and row[3])[3] = False + wrong_orientation_rejected = False + try: + audit.replay(corrupted) + except AssertionError: + wrong_orientation_rejected = True + need(wrong_orientation_rejected, 'A wrong native reverse orientation fails the exact whole Laurent word') + phase_path = root/'research/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json' + if not phase_path.exists(): + phase_path = root/'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json' + need(sha256(phase_path.read_bytes()).hexdigest() == 'c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa', + 'Exact original native port phase source') + phases = read(phase_path) + dimension = 9+16*p + axes = tuple(1 << i for i in range(dimension)) + def completed(stage): + return norm((axis, 1) for axis in axes[:9+8*stage]) + def stage_frame(stage, q): + return norm([(axis, 1) for axis in axes[:9]]+[(q, -1)] if stage == 0 + else [(axis, 1) for axis in axes[9+8*(stage-1):9+8*stage]]) + contacts = [] + stages = [row for row in case['physical_events'] if row[0] == 'LOCAL'] + need([row[1] for row in stages] == list(range(2*p+1)), 'Exact chronological stage sequence') + for _, stage, pair, backward in stages: + sign = -1 if backward else 1 + spectator = norm((axis, 1) for axis in axes[9:9+8*stage]) + for port, recipe in enumerate(phases['recipes']): + q = recipe['q'] + basis = recipe['idle_children'][0]['orthogonal_axes'][:8] + need(all((b & q).bit_count() % 2 == 0 for b in basis), 'Actual owner basis is orthogonal to q') + need(all((a & b).bit_count() % 2 == int(i == j) for i, a in enumerate(basis) + for j, b in enumerate(basis)), 'Actual eight-vector basis is orthonormal') + swaps = [] if stage == 0 else [b ^ axes[9+8*(stage-1)+i] for i, b in enumerate(basis)] + route = tuple(e ^ act(swaps, sum(((e & v).bit_count() % 2) << i for i, v in enumerate(swaps))) + for e in axes) + need(all(act(route, route[i]) == axes[i] for i in range(dimension)), 'Full dimension route is an involution') + need(all((a & b).bit_count() % 2 == int(i == j) for i, a in enumerate(route) + for j, b in enumerate(route)), 'Full dimension route is orthogonal') + need(act(route, q) == q, 'Actual q is fixed') + raw_x = norm([(q, 1)]) if stage == 0 else completed(stage-1) + raw_y = () if stage == 0 else norm(list(raw_x)+[(q, -1)]) + local_x0 = norm(list(spectator)+[(q, sign)]) + local_y0 = spectator + local_x1 = norm(list(spectator)+[(axis, sign) for axis in axes[:9]]) + local_y1 = norm(list(local_x1)+[(q, -sign)]) + out_x = completed(stage) + out_y = norm(list(out_x)+[(q, -1)]) + maps = {name: contact(old, new, route, dimension) for name, old, new in ( + ('entry_X', raw_x, local_x0), ('entry_Y', raw_y, local_y0), + ('exit_X', local_x1, out_x), ('exit_Y', local_y1, out_y))} + delta = stage_frame(stage, q) + for incoming, outgoing in ((raw_x, out_x), (raw_y, out_y)): + need(polynomial(norm(list(outgoing)+[(a, -c) for a, c in incoming]), dimension) + == polynomial(delta, dimension), 'Raw diagonal operator is exactly D_s') + cross = norm(list(out_y if sign == 1 else out_x)+ + [(a, -c) for a, c in (raw_x if sign == 1 else raw_y)]) + need(polynomial(cross, dimension) == polynomial(norm(list(delta)+[(q, -sign)]), dimension), + 'Raw cross operator is exactly D_s Q^(-sign)') + contacts.append({'stage': stage, 'pair': pair, 'port': port, 'backward': backward, + 'route': route, 'maps': maps}) + endpoints = [] + target_main = Counter() + omitted_endpoint_phase_rejected = 0 + for role, term in enumerate(case['exact_diagonal_monomials']): + qp, selected = term[0], term[1:] + need(qp in (-1, 1) and set(selected) <= {0, 1}, 'Actual endpoint exponent alphabet') + for port, recipe in enumerate(phases['recipes']): + q = recipe['q'] + physical = norm([(q, qp)]+[entry for stage, yes in enumerate(selected) if yes for entry in stage_frame(stage, q)]) + positive = list(axes[:9]) if selected[0] else [q] + positive += [axis for stage in range(1, len(selected)) if selected[stage] + for axis in axes[9+8*(stage-1):9+8*stage]] + shift = q if qp == -1 else 0 + need(inventory.independent_axes(positive), 'Actual endpoint target axes independent') + need(len(positive) == 1+8*sum(selected), 'Exact productive endpoint rank') + need(polynomial(norm(list(physical)+[(shift, 2)]), dimension) + == polynomial(norm((axis, 1) for axis in positive), dimension), 'Complete endpoint phase normalization') + if shift: + need(polynomial(physical, dimension) != polynomial(norm((axis, 1) for axis in positive), dimension), + 'Omitting the endpoint translation fails') + omitted_endpoint_phase_rejected += 1 + endpoints.append({'role': role, 'port': port, 'rank': len(positive), 'axes': positive, 'translation': shift}) + target_main[len(positive)] += 1 + recorded = Counter((row['pair'], tuple(row['stages'])) for row in case['retained_idle_windows']) + literal = Counter((row[1], tuple(row[2])) for row in case['physical_events'] if row[0] == 'IDLE') + need(recorded == literal, 'Bijection of every paid whole idle and every literal controller IDLE') + need(all(row['rank'] == 8*len(row['stages']) for row in case['retained_idle_windows']), + 'Every paid window rank matches the literal stage count') + idle = Counter() + idle_records = [] + for window in case['retained_idle_windows']: + selected = window['stages'] + need(case['physical_events'].count(['IDLE', window['pair'], selected]) == 1, + 'Each full idle is attached to its original literal pair and event') + for port, recipe in enumerate(phases['recipes']): + q = recipe['q'] + if 0 in selected: + need(selected == list(range(len(selected))) and len(selected) >= 2, 'Initial window contiguous from stage0') + positive = recipe['idle_children'][0]['orthogonal_axes'][:] + positive += [axis for stage in selected[2:] for axis in axes[9+8*(stage-1):9+8*stage]] + shift = recipe['idle_children'][0]['translation_after'] + else: + positive = [axis for stage in selected for axis in axes[9+8*(stage-1):9+8*stage]] + shift = 0 + desired = norm(entry for stage in selected for entry in stage_frame(stage, q)) + actual = norm([(axis, 1) for axis in positive]+[(shift, 2)]) + need(inventory.independent_axes(positive) and len(positive) == window['rank'], 'Exact whole idle rank') + need(polynomial(actual, dimension) == polynomial(desired, dimension), 'Exact complete whole idle phase') + idle[len(positive)] += 2 + idle_records.append({'window': window['index'], 'pair': window['pair'], 'stages': selected, + 'port': port, 'owners': [f'X{window["pair"]}:{port}', f'Y{window["pair"]}:{port}'], + 'axes': positive, 'translation': shift}) + receipt = read(base/'complex/full-identity-certificates/RESULT.json')['providers']['THREE-base'] + target_helpers = Counter({int(k): v*(2*p+1) for k, v in receipt['helper_boundary']['widths'].items()}) + targets = target_main+target_helpers + paid = Counter({int(k): v*(2*p+1) for k, v in receipt['unsplit_replays']['forward']['paid_profile'].items()}) + paid.update(idle) + scalar = scalar_invoice(case, sum(receipt['split_replays']['backward' if row[3] else 'forward'] + ['independent_native_replay']['conservative_real_scalar_primitive_allowance'] for row in stages)) + artifact = {'contacts': contacts, 'endpoints': endpoints, 'whole_idles': idle_records, 'formal': case} + artifact_json = json.dumps(artifact, sort_keys=True, separators=(',', ':')).encode() + artifact_bytes = gzip.compress(artifact_json, compresslevel=9, mtime=0) + if output_dir is not None: + output = Path(output_dir) + output.mkdir(parents=True, exist_ok=True) + (output/'NATIVE-GEOMETRY.json.gz').write_bytes(artifact_bytes) + result = {'status': 'PASS_EXACT_LAURENT_ALL_MAIN_CONTACTS_ENDPOINTS_AND_FULL_IDLE_PHASES', + 'p': p, 'keep': keep, 'dimension': dimension, 'contacts': 4*len(contacts), + 'main_fields': 224*p, 'fresh_helper_fields': 408*(2*p+1), + 'targets': dict(sorted(targets.items())), 'paid': dict(sorted(paid.items())), + 'native_scalar_allowance': scalar, 'scalar_allowance': scalar, + 'productive_fields': sum(targets.values()), 'paid_calls': sum(paid.values()), 'whole_idle_profile': dict(sorted(idle.items())), + 'rank_margin': sum(k*v for k, v in targets.items())-sum(k*v for k, v in paid.items()), + 'artifact_sha256': sha256(artifact_json).hexdigest(), + 'artifact_hash_encoding': 'Uncompressed UTF-8 JSON, sort_keys=True, separators=(comma,colon)', + 'native_source_gate': native_gate['status'], + 'negative_controls': {'wrong_native_orientation_rejected': wrong_orientation_rejected, + 'omitted_endpoint_translation_rejected': omitted_endpoint_phase_rejected}, + 'source_sha256': {str(path.relative_to(root)): sha256(path.read_bytes()).hexdigest() + for path in (phase_path, base/'transfer-audit/p3_native_audit.py', + base/'complex/full-identity-certificates/RESULT.json')}, + 'limits': 'Finite exact physical controller admission; inherited all-column local word, tensor strictification, new full-word precision/stock and outer transfer remain written proof obligations.'} + result['source_sha256'].update(native_gate['source_sha256']) + result['source_sha256'].update(factor_pins) + result['factor_receipt_sha256'] = factor.RECEIPT_SHA256 + result['schema'] = 'source-bound-p7-all-fresh-complete-native-controller/1' + return result + + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, default=HERE/'source') + parser.add_argument('--output-dir', type=Path) + args = parser.parse_args() + result = run(args.source_root, output_dir=args.output_dir) + if args.output_dir: + (args.output_dir/'NATIVE.json').write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print(json.dumps({k:result[k] for k in ('status','contacts','dimension','productive_fields','paid_calls','targets','paid','native_scalar_allowance')}, sort_keys=True)) diff --git a/research/two-full-central-obstruction/inputs/native/query_thinned_verify.py b/research/two-full-central-obstruction/inputs/native/query_thinned_verify.py new file mode 100644 index 0000000000..f1114036ff --- /dev/null +++ b/research/two-full-central-obstruction/inputs/native/query_thinned_verify.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 +"""Exact finite replay for the conditional query-thinned construction. + +Apache-2.0. Prepared for Cinna Davis with substantial OpenAI Codex assistance. +Retains zxv's native/factor/tail work and Jacob Alan Sussman's integer flow. +""" +from fractions import Fraction as Q +from hashlib import sha1, sha256 +import argparse +import json +import sys +sys.dont_write_bytecode = True +import controller as C +HERE, ROOT, need = C.HERE, C.ROOT, C.need + + +def encode(x): + if isinstance(x, Q): return str(x) + if isinstance(x, dict): return {str(k): encode(v) for k, v in x.items()} + if isinstance(x, (list, tuple)): return [encode(v) for v in x] + return x + + +def authenticate(): + count = 0 + for row in json.loads((HERE/'SOURCES.json').read_text())['files']: + if row['usage'] != 'input': continue + path = ROOT/row['path']; raw = path.read_bytes() + need(not path.is_symlink(), 'No source alias') + need(sha256(raw).hexdigest() == row['sha256'], 'Changed source: '+row['path']) + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == row['git_blob'], 'Changed Git blob') + count += 1 + return count + + +def controllers(): + B, E = C.engines(); result = {} + for kind, p, a in [('complex', 17, 8), ('bit', 16, 7)]: + row = json.loads((HERE/(kind.upper()+'-CONTROLLER.json')).read_text()) + thick, mask = C.thick_stages(p), C.keep_mask(p, a) + if kind == 'complex': + coefficients, events, idles = E.controller(p, mask) + coefficients = C.specialize_complex(coefficients, thick) + left = [[Q(x) for x in r] for r in row['boundaries']['left']] + right = [[Q(x) for x in r] for r in row['boundaries']['right']] + diagonal = [tuple(term) for term in row['diagonal']] + transformed = {k: B.matrix_multiply(B.matrix_multiply(left, m), right) for k, m in coefficients.items()} + expected = {k: [[Q(i == j and diagonal[i] == k) for j in range(2*p)] for i in range(2*p)] for k in set(diagonal)} + need(transformed == expected, 'All exact rational Laurent coefficients, including signs and Q powers') + for name, matrix in [('left', left), ('right', right)]: + need(E.scalar_program(matrix) == row['boundaries'][name+'_program'], 'Literal unit scalar boundary program') + changed = dict(coefficients) + k = next(iter(changed)); changed[k] = [r[:] for r in changed[k]]; changed[k][0][0] += 1 + need(B.matrix_multiply(B.matrix_multiply(left, changed[k]), right) != expected.get(k), 'A changed physical coefficient is rejected') + else: + coefficients, events, idles = B.physical_controller(p, mask) + coefficients = C.specialize_bit(coefficients, thick) + fresh = B.simultaneous_monomial_factor(coefficients) + need(fresh == row['boundaries'], 'Exact binary physical operator and scalar boundaries') + diagonal = fresh['diagonal_monomials'] + need(C.replay_events(row['physical_events'], p, kind) == coefficients, + 'Emitted native/query/idle word equals the specialized physical source') + mutant = json.loads(json.dumps(row['physical_events'])) + # Every removed stage is forward; changing its direction must change + # the actual operator rather than merely a tariff field. + next(ev for ev in mutant if ev[0] == 'QUERY_SHEAR')[3] = True + need(C.replay_events(mutant, p, kind) != coefficients, 'Wrong query orientation rejected') + invoice = C.inventories(kind, p, a, diagonal, idles) + ports = 112 if kind == 'complex' else 111 + boundary_records = (sum(len(row['boundaries'][name+'_program']) for name in ('left', 'right')) + if kind == 'complex' else row['boundaries']['boundary_unit_ADDs_per_port']) + scalar_upper = (p+2)*10**6+16*invoice['thin_queries']+32*ports*(len(row['physical_events'])+boundary_records) + need(scalar_upper < invoice['raw_scalar_record_bound'], 'Conservative complete scalar/route count fits') + need(encode(invoice) == row['invoice'], 'Literal and closed-form complete '+kind+' invoice') + result[kind] = invoice + return result + + +def native_contacts(): + n = C.load(ROOT/'research/pr4359-p7-padding/native_inventory.py', 'thinned_native_phases') + phases = json.loads((ROOT/'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json').read_text()) + axes = tuple(1 << i for i in range(17)); old = [(a, 1) for a in axes[:9]]; fresh = [(a, 1) for a in axes[9:]] + checks = 0 + for recipe in phases['recipes']: + q = recipe['q']; basis = recipe['idle_children'][0]['orthogonal_axes'][:8] + need(all((b&q).bit_count() % 2 == 0 for b in basis), 'Old eight-space perpendicular to q') + swaps = [b ^ axes[9+i] for i, b in enumerate(basis)] + route = tuple(e ^ n.act(swaps, sum(((e&v).bit_count() % 2) << i for i, v in enumerate(swaps))) for e in axes) + need(all(n.act(route, route[i]) == axes[i] for i in range(17)), 'Exact physical route inverse') + need(all((a&b).bit_count() % 2 == int(i == j) for i, a in enumerate(route) for j, b in enumerate(route)), 'Orthogonal physical route') + need(n.act(route, q) == q, 'Central query direction fixed') + need(n.polynomial(n.norm([(q, -1)]), 17) == n.polynomial(n.norm([(q, 1), (q, 2)]), 17), + 'Inverse thin Gaussian is one positive query and a physical translation') + for sign in (-1, 1): + raw = (n.norm(old), n.norm(old+[(q, -1)])) + entry = (n.norm(fresh+[(q, sign)]), n.norm(fresh)) + out0 = n.norm(fresh+[(a, sign) for a in axes[:9]]) + local_out = (out0, n.norm(list(out0)+[(q, -sign)])) + out = (n.norm(old+fresh), n.norm(old+fresh+[(q, -1)])) + for x, y in list(zip(raw, entry))+list(zip(local_out, out)): + n.contact(x, y, route, 17); checks += 1 + for x, y in zip(raw, out): + need(n.polynomial(n.norm(list(y)+[(a, -c) for a, c in x]), 17) == n.polynomial(n.norm(fresh), 17), 'Exactly the fresh eight-axis multiplier') + bit = C.load(ROOT/'research/kappa-rebuild/bit/bit_native_binding.py', 'thinned_binary_charts') + ports = json.loads((ROOT/'research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json').read_text())['ports'] + local = json.loads((ROOT/'research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json').read_text())['local'] + for direction in local['signed_directions']: + need({int(k): v for k, v in direction['profile'].items()} == C.engines()[0].LOCAL, + 'Every actual binary local child remains charged') + need(direction['unit_ADDs'] < 10**6 and direction['owned_COPY_episodes'] == 9, + 'Native binary scalar and owned-center bills retained') + for row in ports: + p = [[Q(x) for x in r] for r in row['central_projector']]; rho = [[Q(x) for x in r] for r in row['chart_15']] + active = [[p[i][j] if i < 8 and j < 8 else Q(i == j and i >= 8) for j in range(15)] for i in range(15)] + full = [[Q(i == j and i < 8) for j in range(15)] for i in range(15)] + need(bit.multiply(rho, rho) == bit.ident(15) and bit.multiply(bit.multiply(rho, active), rho) == full, 'BIT exact arbitrary-column chart') + need(bit.multiply(p, p) == p and sum(p[i][i] for i in range(8)) == 1, 'BIT query rank one') + # Formal independent X,Y,Z columns. Mutants execute the same word with + # an actual omitted operation; they are not merely different receipts. + for e in (-1, 1): + def execute(clear=True, erase=True): + x, y, z = {('X', 0): 1}, {('Y', 0): 1}, {('Z', 0): 1} + if clear: z = {} + for key, value in x.items(): z[key] = z.get(key, 0)+value + z = {(name, power+e): value for (name, power), value in z.items()} + for key, value in z.items(): y[key] = y.get(key, 0)+(-1 if e == 1 else 1)*value + if erase: z = {} + return x, y, z + expected = ({('X', 0): 1}, {('Y', 0): 1, ('X', e): -1 if e == 1 else 1}, {}) + need(execute() == expected, 'Completed arbitrary-input owned-query shear') + need(execute(clear=False) != expected and execute(erase=False) != expected, 'Clear/erase omission controls rejected') + return {'complex_contacts_and_inverses': checks, 'binary_charts': len(ports), + 'thin_paid_rank_per_port': 1, 'thin_productive_credit': 0, 'owned_stream_restored_zero': True} + + +def tail(E, invoice, tested, uniform, cutoff, floor, alpha_gap): + T, P = invoice['targets'], invoice['paid']; t, u, v = 1-tested, Q(1, 5), 1024 + target, paid = E.moment(T, t), E.moment(P, t) + alpha = E.divide(paid, target) + other = C.load(ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py', 'separate_rational_moment_engine') + tl, th = other.moment(T, tested); pl, ph = other.moment(P, tested) + need(tl > ph and max(target[0], tl) <= min(target[1], th) + and max(paid[0], pl) <= min(paid[1], ph), 'Separate rational interval engine agrees') + gamma = E.divide(E.moment(P, t+u), E.mul(E.power(cutoff, u), target)) + delta = E.divide((Q(sum(T.values())*floor),)*2, E.mul(E.power(cutoff, tested), target)) + need(alpha[1] < 1-alpha_gap and gamma[1] < Q(31, 32) and delta[1] < Q(19, 20), 'Three completely charged tail ratios') + need(Q(31, 32)**128 < Q(1, 16) and Q(19, 20)**128 < Q(1, 16), 'Exact decay blocks') + surplus = 1-Q(1)/(1+v*alpha_gap)-Q(4, 2**32) + need(surplus > 0, 'Original and completion tails both fit') + need(cutoff**64 < floor**63 and max(T) < 256, 'Strict ranks after completion and splitting') + h = Q(1, 64); z, z0 = 1-uniform, (t+1-uniform)/2; gap = z0-t + B, debt = (5+8*h)*v, 1+8*v*(1-z0) + x = (gap*B+debt)/(h*gap); H0 = -((-x.numerator)//x.denominator) + x = H0*(1-z0)/(z-z0); H1 = x.numerator//x.denominator+1 + need(H0 >= 8*v and H0*h*gap >= gap*B+debt and H1*(z-z0) > H0*(1-z0), 'Effective integer compiler bound') + return {'tested_saving': tested, 'uniform_saving': uniform, 'alpha': E.display(alpha), + 'gamma': E.display(gamma), 'delta': E.display(delta), 'tensor_power': v, + 'cutoff_base': cutoff, 'target_floor_base': floor, 'tail_exponent': u, + 'normalized_surplus_lower': surplus, 'compiler_H0': H0, 'uniform_H1': H1, + 'uniform_N': '2^'+str(H1), 'winning_word_materialized': False} + + +def run(): + count = authenticate(); rows = controllers(); native = native_contacts() + E = C.load(ROOT/'research/higher-moment-strictification/verify.py', 'credited_exact_intervals') + kappa, tested = Q('.00296'), Q('.00296030'); d = (tested-kappa)/7 + complex_ = tail(E, rows['complex'], tested, kappa+6*d, 20, 21, Q(1, 30000000)) + bit = tail(E, rows['bit'], Q('.00346'), Q('.003459'), 17, 18, Q(1, 250000)) + before, after, atom, old = Q('.003459'), Q('.00345'), Q('.004'), Q('.0000384599') + ordinary, admitted = (1-atom)*after+atom*old, Q('.0034') + need(before > after and atom > ordinary > admitted and atom < 1-ordinary, 'Complete ordinary BIT conversion') + need(Q('.003') < ordinary and 2**26 > 256/(before-after), 'Old atom rejected and finite prime bound') + L = C.load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'complete_outer_ledger') + params = {'kappa': kappa, 'tested_saving': tested, 'complex_uniform_saving': kappa+6*d, + 'b': kappa+5*d, 'a': kappa+4*d, 'q': kappa+3*d, 'bit_saving': admitted, + 'epsilon': 1-d, 'beta': 1-3*d, 'r0': d/10, 'stop': d, 'layout': d, 'd': d} + outer = L.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear'] = params['beta']*(1-atom) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete predicate inventory') + need(all(x > 0 for group in ('strict_checks', 'functional_checks') for x in outer[group].values()), 'All outer predicates') + controls = {} + for label, changes in [('old_BIT_cap', {'bit_saving': Q('.0027')}), ('closed_uniform_gap', {'complex_uniform_saving': params['b']}), + ('unfunded_kappa', {'kappa': tested}), ('closed_epsilon', {'epsilon': Q(1)}), ('missing_layout', {'layout': Q(0)})]: + bad = L.ledger(dict(params, **changes)); failed = [k for k, v in bad['strict_checks'].items() if v <= 0] + need(failed, 'Reject '+label); controls[label] = failed + return encode({'schema': 'query-thinned-productive-controllers/1', 'status': 'PASS_CONDITIONAL_QUERY_THINNED_KAPPA_00296', + 'kappa': kappa, 'relative_gain_over_p7': kappa/Q('.00268647')-1, + 'source_inputs_authenticated': count, 'native': native, 'complex_invoice': rows['complex'], 'bit_invoice': rows['bit'], + 'complex_strictification': complex_, 'bit_strictification': bit, + 'ordinary_BIT': {'before_cover': before, 'after_cover': after, 'atom': atom, 'ordinary_saving': ordinary, + 'admitted': admitted, 'prime_rule': 'odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses'}, + 'outer': outer, 'minimum_outer_margin_minus_kappa': min(outer['margins'].values())-kappa, + 'negative_controls': controls, 'old_atom_rejected': True, + 'scope': 'Conditional native construction; all-column, erasure, whole-job matching, fixed-tape, precision, analytic, prime and exact-recovery premises retained. No unconditional theorem or selected promotion.'}) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('--write', action='store_true'); args = parser.parse_args() + result = run(); output = HERE/'RESULT.json' + if args.write: output.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: need(result == json.loads(output.read_text()), 'Complete receipt matches exact replay') + print(json.dumps({k: result[k] for k in ('status', 'kappa', 'source_inputs_authenticated', 'minimum_outer_margin_minus_kappa')}, sort_keys=True)) diff --git a/research/two-full-central-obstruction/inputs/predecessors/PR4666-GLOBAL-PROOF.md b/research/two-full-central-obstruction/inputs/predecessors/PR4666-GLOBAL-PROOF.md new file mode 100644 index 0000000000..74b67e22e6 --- /dev/null +++ b/research/two-full-central-obstruction/inputs/predecessors/PR4666-GLOBAL-PROOF.md @@ -0,0 +1,183 @@ +# Two global obstructions for controllers without idle work + +Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance. +Apache-2.0. These are written binary-algebra proofs, supported by finite checks; +there is no formal-kernel or independent human acceptance claim. + +## Contract + +Let n=2p main fields, Q a central involution, and work over +`F2[Q,D_1,...,D_f]/(Q^2-1)`. Every full native call has its **own independent** +commuting multiplier D_i and is + + (I+(D_i+1)P_i)(I+Q N_i), + +with P_i a binary rank-two projector, N_i a rank-one nilpotent, and +`P_i N_i=N_i P_i=N_i`. A thin call is `I+Q N_i`. Arbitrary invertible binary +basis changes between calls are allowed and absorbed by conjugation. There +are no idle multipliers or repeated/specialized stage variables. + +Success means constant invertible binary L,R give independent main jobs: + + L M R = diag(Q*m_1(D), ..., Q*m_n(D)), + +where every m_j is a monomial. This is an algebraic prerequisite of the +retained native/query supplier model, not a native implementation theorem. + +**Theorem A.** If every call is full, success requires at least 3p calls. +For a fixed local inventory, its target-minus-paid concave moment **per full +call** is no larger than that of a three-call unit. Thus it cannot admit a +larger raw saving than the disjoint three-call construction. + +**Theorem B.** Every successful controller needs at least 2p+1 query-bearing +calls. If it uses exactly 2p+1 and p>=2, at most **two** calls can be full. +For the retained BIT inventory, its complete target-minus-paid moment is at +most **-15 for every exponent t in [0,1]**, so it cannot supply a recursive +saving. The binary theorem is not asserted for arbitrary complex words. + +Thus both all-full controllers of arbitrary length and minimum-query mixed +controllers fail to supply the hoped-for large improvement by deleting idles. +The changed premise still open is a mixed controller with additional queries, +a changed target, dependent stage multipliers, or a different local family. + +## Common tangent and projector identities + +Set all D_i=1 and write Q=1+e with e^2=0. Normalize the derivative by the +invertible constant operator at e=0. A call's contribution is a conjugate + + R_i = u_i v_i^T, v_i^T u_i=0, + +of its nilpotent. The desired endpoint gives + + sum_i R_i = I_n. (1) + +For a full call, differentiate in its unique D_i and normalize on the right. +At D=1 its projector is conjugated by the later query calls. Since the desired +endpoint is independently diagonal, these normalized projectors E_i are +constant in Q, have rank two, commute pairwise, and satisfy + + E_i R_i = R_i E_i = R_i, + [E_i, sum_{j>i} R_j] = 0. (2) + +The second identity is the Q derivative of the conjugated projector. Each +R_j is written in the same final coordinate system. These are necessary +identities; no converse or free physical implementation is assumed. + +## Proof of A: edge parity + +Use the common binary output basis diagonalizing all full projectors E_i. +Each E_i selects two coordinates. Its R_i is therefore supported on that +coordinate pair and is one of the three nonzero rank-one nilpotents + + [0 1;0 0], [0 0;1 0], [1 1;1 1]. + +For any unordered coordinate pair, (1) requires zero off-diagonal sum. +Consequently the parity of the number of each of these three types is equal. +If that common parity is odd, there are at least three calls on the pair, +and the pair contributes one to both diagonal entries. Otherwise it contributes +zero to the diagonal. Every coordinate must meet an odd number of the former +pairs. There are at least n/2=p such pairs, and hence at least 3p calls. +Disjoint three-call swaps attain the call bound. + +For the moment claim let f be the number of full calls, v the local port count, +b the transverse block rank, and t in (0,1). Each independent D_i occurs with +total degree two in the determinant, so `sum_j degree(m_j)=2f`. Jensen gives + + main target moment <= n*v*(1+2*b*f/n)^t. + +Put a=f/p>=3. Dividing by f bounds this by +`(2v/a)*(1+b*a)^t`. Its derivative in a has the sign of +`(t-1)*b*a-1`, which is negative. The bound is therefore at most +`(2v/3)*(1+3b)^t`, exactly the per-call main moment of disjoint three-call +units. Helper targets and paid jobs are f copies of the same fixed local +inventory, so adding them preserves the comparison. This is a global bound +within the declared no-idle, all-full contract, not a bound on other families. + +## Proof of B: the minimum-query simplex + +If there are at most n rank-one terms in (1), rank already forces exactly n. +Writing U for their columns and V for their rows gives UV=I with both square. +Then VU=I, contradicting the zero diagonal `v_i^T u_i=0`. Thus there are +at least n+1 calls. + +At exactly n+1, U has n+1 columns and V has n+1 rows. VU is a rank-n projector +of corank one. Write `VU=I+a b^T`. Its zero diagonal forces `a_i b_i=1` for +every i. Over F2, both a and b are the all-one vector. Hence + + v_i^T u_j = 0 if i=j, and 1 otherwise; + sum_i u_i = 0, sum_i v_i = 0. (3) + +Every proper subset of at most n of either frame is independent. +Index the queries 0,...,n. For an interior position s, put + + k=n-s, U_s=sum_{j>s}u_j, V_s=sum_{j>s}v_j^T. + +Commutation (2), applied to u_s and v_s^T, forces the image of E_s to contain +u_s,U_s and its row space to contain v_s^T,V_s. Both pairs are independent. +Their pairing matrix is `[0 k; k 0]` over F2. If k is even it is zero, so no +rank-two projector exists. If k is odd, the projector is uniquely + + E_s = u_s V_s + U_s v_s^T. (4) + +In particular s must be odd, since n is even. + +Two distinct interior positions s1 were both full, their commuting +projectors would force the image of E_0 to be +`span(u_0,u_s+U_s)` and its row space to be +`span(v_0^T,v_s^T+V_s)`. These two independent pairs have **all four pairings +zero**, contradicting idempotence. Thus an initial full call can coexist with +an interior full call only at s=1. + +Similarly, a terminal full call at n can coexist with an interior full call +only at s=n-1. Otherwise its forced image is `span(u_n,U_s)` and its forced +row space `span(v_n^T,V_s)`, again with all pairings zero. + +For n>=4, the single possible interior full call cannot be both at 1 and n-1. +There are therefore at most two full calls: either both endpoints, or one +interior and one endpoint. For n=2 this exception disappears and the familiar +three-full-call controller is permitted, as it must be. + +For the retained BIT profile, with L=2p+1 calls and f full calls, independent +stage degrees give first-order surplus + + 2*p*111 - 63*f - 111*(L-f) = 48*f - 111. + +At f<=2 this is at most -15. Here we can also exclude every interior concave +moment, rather than relying only on that first-order calculation. The BIT +helper profile is 439 jobs of rank 8, and its paid profile is +`{1:1323,2:1342,3:79,4:44,5:102,6:11,7:19}`. Let P(t) be its paid moment. +The n monomial degrees are nonnegative integers summing to 2f. Since n>=4 +and f<=2, concavity maximizes their main moment by putting degree one on +2f fields and zero on the others. The full margin is consequently at most + + f B(t)-111, B(t)=661*8^t-P(t)-111. + +For every t in [0,1], + + B'(t)/8^t >= 661*log(8)-sum_{r=2}^7 P_r log(r) > 0. + +The last strict inequality is the exact integer comparison +`8^661 > product_{r=2}^7 r^(P_r)`, checked without floating point. +Thus B(t)<=B(1)=48, and the margin is at most `48f-111<=-15`. + +## Verification and unproved extensions + +`global_check.py` checks the simplex pairings, forced-projector formulas, +noncommutators and endpoint degeneracies through 32 pairs. It independently +exhausts the two-coordinate nilpotents and their parity table, tests the n=2 +exception, and checks a real n=4/f=2 factored word that attains the full-call +bound. The exact logarithmic-product inequality certifies the all-t BIT +rejection. The original complete n=4 search supports, but does not replace, the +written all-p proof. + +The proof uses characteristic two and constant binary boundaries. It does not +reduce arbitrary complex dyadic operators modulo two. It also leaves mixed +words with more than 2p+1 calls open. Repeated or dependent D_i, nonmonomial +outputs, nonbinary boundaries and changed recursive suppliers are outside its +scope. No kappa improvement is claimed. diff --git a/research/two-full-central-obstruction/verify.py b/research/two-full-central-obstruction/verify.py new file mode 100644 index 0000000000..5a1adc4ed8 --- /dev/null +++ b/research/two-full-central-obstruction/verify.py @@ -0,0 +1,239 @@ +#!/usr/bin/env python3 +"""Exact finite corroboration of the written two-FULL pureword obstruction. + +No circuit search or native scientific replay. Apache-2.0; substantial OpenAI +Codex assistance. The all-size theorem is in PROOF.md, not these fixtures. +""" +from fractions import Fraction as F +from hashlib import sha256 +from pathlib import Path +import argparse +import json + +HERE = Path(__file__).resolve().parent +ZERO, ONE, IMAG = (F(0), F(0)), (F(1), F(0)), (F(0), F(1)) + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def plus(a, b): + return a[0]+b[0], a[1]+b[1] + + +def times(a, b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +def negative(a): + return -a[0], -a[1] + + +def conjugate(a): + return a[0], -a[1] + + +def cmul(a, b): + return tuple(plus(times(a[2*i], b[j]), times(a[2*i+1], b[2+j])) + for i in range(2) for j in range(2)) + + +def scalar(a, z): + return tuple(times(x, z) for x in a) + + +def group(): + ident = (ONE, ZERO, ZERO, ONE) + x = (ZERO, ONE, ONE, ZERO) + s = (ONE, ZERO, ZERO, IMAG) + u, v = (F(1, 2), F(1, 2)), (F(1, 2), F(-1, 2)) + q = (u, v, v, u) + rows, lookup, cursor = [ident], {ident: 0}, 0 + while cursor < len(rows): + need(len(rows) <= 128, 'Explicit finite central group capacity') + for gen in (q, s): + item = cmul(rows[cursor], gen) + if item not in lookup: + lookup[item] = len(rows); rows.append(item) + cursor += 1 + table = [[lookup[cmul(a, b)] for b in rows] for a in rows] + monomial = {i for i, a in enumerate(rows) if + all(sum(a[2*r+c] != ZERO for c in range(2)) == 1 for r in range(2)) + and all(sum(a[2*r+c] != ZERO for r in range(2)) == 1 for c in range(2))} + need(len(rows) == 96 and len(monomial) == 32, 'Exact generated group/subgroup sizes') + need(cmul(q, q) == x, 'Native Gaussian square is translation, not identity') + return rows, table, monomial, lookup[q], lookup[s], lookup[x] + + +def algebra(table): + def add(a, b): + out = dict(a) + for g, c in b.items(): + out[g] = plus(out.get(g, ZERO), c) + return {g: c for g, c in out.items() if c != ZERO} + def mul(a, b): + out = {} + for g, c in a.items(): + for h, d in b.items(): + at = table[g][h] + out[at] = plus(out.get(at, ZERO), times(c, d)) + return {g: c for g, c in out.items() if c != ZERO} + def mm(a, b): + return [[add(mul(a[i][0], b[0][j]), mul(a[i][1], b[1][j])) + for j in range(2)] for i in range(2)] + return add, mul, mm + + +def finite_projection(rows, table, subgroup, q, s, x): + add, mul, mm = algebra(table) + unit = [[{0: ONE}, {}], [{}, {0: ONE}]] + def shear(i, letter, coefficient=ONE): + out = [[dict(z) for z in row] for row in unit] + out[i][1-i] = {letter: coefficient} + return out + def diagonal(a, b): + return [[{a: ONE}, {}], [{}, {b: ONE}]] + def project(a): + return {g: c for g, c in a.items() if g in subgroup} + w = mm(mm(shear(0, 0, (F(1, 2), F(0))), diagonal(s, x)), + mm(shear(1, 0, IMAG), shear(0, 0, negative(ONE)))) + left = mm(diagonal(x, s), shear(0, 0, IMAG)) + right = mm(shear(1, 0, (F(-2), F(0))), diagonal(s, x)) + qi = next(g for g in range(len(rows)) if table[q][g] == 0) + si = next(g for g in range(len(rows)) if table[s][g] == 0) + qb = table[table[s][q]][si] + letters = [q, qi, qb, next(g for g in range(len(rows)) if table[qb][g] == 0)] + checks = 0 + for a in letters: + for b in letters: + for i in range(2): + for k in range(2): + actual = mm(mm(mm(mm(left, shear(i, b)), w), shear(k, a)), right) + projected = [[project(z) for z in row] for row in actual] + middle = [[dict(z) for z in row] for row in w] + cross = project(mul(mul({b: ONE}, w[1-i][k]), {a: ONE})) + middle[i][1-k] = add(middle[i][1-k], cross) + need(projected == mm(mm(left, middle), right), 'Exact bimodule cross-term formula') + checks += 1 + triple = mm(mm(shear(1, qi), shear(0, q, negative(ONE))), shear(1, qi)) + swap = [[{}, {0: ONE}], [{0: negative(ONE)}, {}]] + need(mm(swap, triple) == diagonal(qi, q), 'Three-query complete dirty two-owner positive control') + need(q not in subgroup and qb not in subgroup, 'Both changed central functions remain outside free subgroup') + need(all(((table[table[h][g]][k] in subgroup) == (g in subgroup)) + for h in subgroup for k in subgroup for g in range(len(rows))), 'Bimodule support law') + return checks + + +def fp_ops(prime=1000003): + need(prime % 4 == 3 and all(prime % d for d in range(2, 1001)), + 'Fixed prime and irreducible quadratic for exact modular rank') + def add(a, b): + return ((a[0]+b[0]) % prime, (a[1]+b[1]) % prime) + def mul(a, b): + return ((a[0]*b[0]-a[1]*b[1]) % prime, (a[0]*b[1]+a[1]*b[0]) % prime) + def inv(a): + d = pow((a[0]*a[0]+a[1]*a[1]) % prime, -1, prime) + return (a[0]*d % prime, -a[1]*d % prime) + def power(a, n): + out = (1, 0) + while n: + if n & 1: + out = mul(out, a) + a = mul(a, a); n //= 2 + return out + def reduce(a): + return tuple(z.numerator * pow(z.denominator, -1, prime) % prime for z in a) + return add, mul, inv, power, reduce + + +def tensor_rank_controls(rows, subgroup): + phases = (ONE, IMAG, negative(ONE), negative(IMAG)) + representatives = sorted({min(scalar(a, z) for z in phases) for a in rows}) + need(len(representatives) == 24, 'Exact projective group has 24 classes') + add, mul, inv, power, reduce = fp_ops() + base = [[reduce(sum_gaussian(times(conjugate(x), y) for x, y in zip(a, b))) + for b in representatives] for a in representatives] + ranks = {} + for width in range(23, 27): + matrix = [[power(z, width) for z in row] for row in base] + rank = 0 + for col in range(24): + pivot = next((r for r in range(rank, 24) if matrix[r][col] != (0, 0)), None) + if pivot is None: + continue + matrix[rank], matrix[pivot] = matrix[pivot], matrix[rank] + scale = inv(matrix[rank][col]); matrix[rank] = [mul(z, scale) for z in matrix[rank]] + for r in range(rank+1, 24): + factor = matrix[r][col] + matrix[r] = [add(a, tuple(-v for v in mul(factor, b))) + for a, b in zip(matrix[r], matrix[rank])] + rank += 1 + need(rank == 24, 'Projective tensor Gram full rank at a sufficient width') + ranks[str(width)] = rank + return ranks + + +def sum_gaussian(items): + out = ZERO + for x in items: + out = plus(out, x) + return out + + +def semantic_controls(rows, table, subgroup, q, x): + u, v = (F(1, 2), F(1, 2)), (F(1, 2), F(-1, 2)) + reconstructed = tuple(plus(times(u, a), times(v, b)) for a, b in zip(rows[0], rows[x])) + need(reconstructed == rows[q], 'Width-one Gaussian matrix relation exists') + delta = plus(times(rows[q][0], rows[q][0]), negative(times(u, ONE))) + need(delta != ZERO, 'Same scalar sum does not tensorize at width two') + iphase = tuple(times(IMAG, z) for z in rows[0]) + need(iphase in rows, 'Absolute i word phase retained as a group element') + need(times(IMAG, IMAG) != IMAG, 'Width-two word phase cannot become width-independent scalar i') + need({q: ONE} != {0: u, x: v}, 'Group-algebra Gaussian is not its accidental width-one sum') + # Existing transformed helper state or a nonmonomial free address gate is + # outside the theorem, rather than an identity-scratch counterexample. + need(q not in subgroup, 'Adding Q to the free subgroup invalidates the hypothesis') + return ['width1_sum_not_tensorized', 'wordphase_not_scalar_i', + 'nonmonomial_free_gate_invalidates_model', 'three_query_positive_control'] + + +def authenticate(): + path = HERE/'ORIGINS.json' + manifest = json.loads(path.read_text()) + for row in manifest['files']: + target = HERE/row['local_path'] + need(sha256(target.read_bytes()).hexdigest() == row['sha256'], 'Frozen source bytes: '+row['local_path']) + return {row['local_path']: row['sha256'] for row in manifest['files']} + + +def run(): + source_hashes = authenticate() + rows, table, subgroup, q, s, x = group() + checks = finite_projection(rows, table, subgroup, q, s, x) + return {'status': 'PASS_TWO_FULL_CENTRAL_OBSTRUCTION_MODEL', 'group_order': len(rows), + 'monomial_subgroup_order': len(subgroup), 'projective_group_order': 24, + 'projective_monomial_order': 8, 'projection_formula_fixtures': checks, + 'bimodule_support_checks': len(rows)*len(subgroup)**2, + 'tensor_gram_ranks_mod_1000003_i_squared_minus1': tensor_rank_controls(rows, subgroup), + 'semantic_controls': semantic_controls(rows, table, subgroup, q, x), + 'sources': source_hashes, 'no_new_kappa': True, + 'own_files': {p.relative_to(HERE).as_posix(): sha256(p.read_bytes()).hexdigest() + for p in sorted(HERE.rglob('*')) if p.is_file() + and p.name != 'RESULT.json' and '__pycache__' not in p.parts}, + 'limits': 'Written theorem supplies universal quantifiers; central finite model only, no native/outer replay.'} + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(); parser.add_argument('--write-receipt', type=Path) + args = parser.parse_args(); result = run() + encoded = json.dumps(result, sort_keys=True, indent=2)+'\n' + if args.write_receipt: + with args.write_receipt.open('x') as handle: + handle.write(encoded) + else: + receipt = HERE/'RESULT.json' + need(receipt.is_file(), 'Committed scientific receipt is required') + need(json.loads(receipt.read_text()) == result, 'Source-bound scientific receipt equality') + print(encoded, end='') From 7eb4ef5251f7ba96c7e5d78c42fc98e66b7be4ba Mon Sep 17 00:00:00 2001 From: d3lerium Date: Fri, 23 Oct 2026 10:42:09 +1100 Subject: [PATCH 2/2] Add full-monomial two-owner grade obstruction and portable CZ replay --- .../two-full-central-obstruction/ORIGINS.json | 8 + .../two-full-central-obstruction/PROOF.md | 94 +++++++++++ .../two-full-central-obstruction/README.md | 25 +++ .../two-full-central-obstruction/RESULT.json | 19 ++- .../two-full-central-obstruction/SOURCES.json | 7 + .../two-full-central-obstruction/TASK.json | 8 +- .../two-full-central-obstruction/VERIFY.json | 25 +++ .../grade/PROOF.md | 121 ++++++++++++++ .../grade/RESULT.json | 143 +++++++++++++++++ .../grade/check.py | 83 ++++++++++ .../inputs/native/clifford_exact.py | 149 ++++++++++++++++++ .../verify_grade.py | 52 ++++++ 12 files changed, 726 insertions(+), 8 deletions(-) create mode 100644 research/two-full-central-obstruction/grade/PROOF.md create mode 100644 research/two-full-central-obstruction/grade/RESULT.json create mode 100644 research/two-full-central-obstruction/grade/check.py create mode 100644 research/two-full-central-obstruction/inputs/native/clifford_exact.py create mode 100644 research/two-full-central-obstruction/verify_grade.py diff --git a/research/two-full-central-obstruction/ORIGINS.json b/research/two-full-central-obstruction/ORIGINS.json index 18c187b1be..edf0931c8a 100644 --- a/research/two-full-central-obstruction/ORIGINS.json +++ b/research/two-full-central-obstruction/ORIGINS.json @@ -50,6 +50,14 @@ "git_blob": "74b67e22e6c063193a83825207cdec19a8fef7a4", "sha256": "adc377b13924701bf5b0b50b091d8b69c90195d50ce0f6808f7fb4c7e0b16457", "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/08ac39202263203fded429c826ba9228ac9df803/research/productive-controller-basis-search/GLOBAL-PROOF.md" + }, + { + "local_path": "inputs/native/clifford_exact.py", + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/20bb93cd990d2ff683e4d0fc56b87a42cd5d3296/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" } ] } diff --git a/research/two-full-central-obstruction/PROOF.md b/research/two-full-central-obstruction/PROOF.md index cb1649cdf5..66df36c04d 100644 --- a/research/two-full-central-obstruction/PROOF.md +++ b/research/two-full-central-obstruction/PROOF.md @@ -203,3 +203,97 @@ predecessors. Finite-dimensional rank and separating-polynomial arguments are elementary tools, with no literature-priority claim. A separate gpt-6.1-sol/high agent independently reviewed the projection and all-width arguments; this is not independent human or proof-kernel acceptance. + +## Addendum: full monomial routing, exactly two owners and no additional states + +The preceding theorem grants arbitrary restored dirty scratch but restricts +the free address subgroup to separated central/transverse operations. The +following theorem removes that address separation for **exactly two main +owners**, without access to scratch or transformed helper states. These are +two distinct scopes; no theorem here simultaneously grants both extensions. + +This direct-column argument was independently derived by the parent agent +and checked/refined by the separate gpt-6.1-sol/high reviewer. Its unchanged +review note and one literal controlled-phase check are under `grade/`. + +Take G to be a fixed finite group of exact one-column seventeen-axis Clifford +matrices, including phases. Let H now be its FULL monomial Clifford subgroup, +including central/fresh axis mixing, and let B be its subgroup algebra. Let +grade(g) be the Gaussian Fourier rank of a Clifford word g. Multiplication +on either side by a monomial preserves grade. The projection pi_16 retaining +basis words of grade at most sixteen is therefore a B-bimodule map. + +At a fixed sufficiently large column width use the same central-character +twisted quotient and faithful tensor representation proved above. Scalar +phases leave grade unchanged, so pi_16 remains well-defined and bimodular. +Scalar choices may depend on width, and all free matrices below may be any +invertible matrices over B. + +Retain each actual native transverse factor instead of absorbing it. A FULL +main map is + + T_s = diag(D_sx,D_sy) E_s, + +where each D factor has Fourier rank eight, and E_s is an elementary upper +or lower shear with one central letter. The two letters may differ and need +not commute. Role-dependent rank-eight D factors, signs, inverses and all +actual raw-D0 translations are allowed. Call-specific monomial boundaries +are absorbed into L,W,R. Suppose a successful word existed: + + L T_2 W T_1 R = diag(g1,g2), + +with both g_j of Fourier rank seventeen and L,W,R invertible over B. +The target is pure grade seventeen. Bimodularity and invertibility give + + pi_16(T_2 W T_1)=0. (4) + +Let c be the input column untouched by the first shear and r the output row +untouched by the second; let i denote the other row. Direct multiplication +in the original factor order gives + + (T_2 W T_1)_rc = D_2r W_rc D_1c. + +Every basis word of W_rc is monomial. Fourier-rank subadditivity gives grade +at most 8+0+8=16 for every basis word in this entry. Thus the entry equals +its pi_16 projection and is zero by (4). The D factors are group units, so +W_rc=0. The other entry of the same input column then simplifies to + + (T_2 W T_1)_ic = D_2i W_ic D_1c, + +because its possible second-shear contribution factors through W_rc. +It too is supported on grades at most sixteen, hence is zero. Therefore +W_ic=0 as well. An entire column of W is zero, contradicting invertibility. +Choosing untouched row/column directly handles every pair of shear +orientations; no commuting of D factors past changed central letters is used. + +This proves that full monomial Clifford routing, including controlled phases +and arbitrary non-diagonal owner GL2 words, cannot supply the two independent +rank-seventeen jobs using two FULL calls on exactly two main owners. It does +not cover added owners or existing transformed helper resources. Arbitrary +width-specific address operations outside the finite columnwise alphabet +also remain outside both theorems. + +### Literal controlled-phase check and portable replay + +The separate reviewer tested C_f=(-1)^(sum_columns q_column*a_column), with a +one old transverse axis, applied to only Y between two FULL calls. This +costs one monomial pass per port and zero additional Gaussian calls. Its +two off-diagonal pure words have grade seventeen: counting only those +maximal-grade words would incorrectly suggest two productive outputs. +Its nonzero M22 word has grade sixteen, so the full matrix fails (4). +The pure q/a coordinate swap is a discriminating control with only one +grade-seventeen off-diagonal word. Neither is a completed endpoint. + +The unchanged author check and RESULT.json are in `grade/`. `verify_grade.py` +is an explicit portable adapter: it hash-authenticates the author code and +retained Clifford engine, substitutes vendored bytes for its single Git +source-loading line, and executes every scientific line unchanged in private +scratch. The regenerated receipt must equal the frozen author receipt. +No package output is rewritten. Normal and optimized registered replays +run this small check; there is no circuit enumeration or boundary synthesis. + +The addendum changes the alphabet covered by the source-bound ceiling, not +the source paid profile or the selected result. Its stronger two-owner +scope rules out expanding an unpriced controlled-phase/mixed-routing search. +The next construction must name an additional paid resource, original owner, +changed native operation or target invoice before another search is justified. diff --git a/research/two-full-central-obstruction/README.md b/research/two-full-central-obstruction/README.md index b5322ac29d..0b74451d25 100644 --- a/research/two-full-central-obstruction/README.md +++ b/research/two-full-central-obstruction/README.md @@ -101,3 +101,28 @@ At the funded comparison, an actual three-call improvement must save more than 58.916072241014304 in moment before any new work or reserve. Hypothetical single-rank alternatives include deleting 59 H1 or 8 H8 paid calls, or adding seven truly independent H9 targets; none is an available construction here. + +## Addendum: full monomial routing on exactly two owners + +The same package now also closes **full monomial Clifford interstage routing**, +including central/fresh mixing and arbitrary owner GL2, when there are exactly +two main owners and no access to other states. The original separated-address +theorem permits restored dirty scratch; this additional full-monomial theorem +has a different owner boundary. Their two relaxations are not combined. + +Retain the native rank-eight transverse factors in their actual order. The +untouched row/column entry of two triangular FULL maps is D2 W_rc D1, supported +only on Fourier grades at most sixteen. Two rank-seventeen targets require +every lower-grade entry to vanish, forcing W_rc=0 and then the other entry in +that input column to vanish as well. This makes the arbitrary interstage W +singular. [PROOF.md](PROOF.md) contains the complete all-width argument. + +An actual interstage controlled-phase word makes both off-diagonal pure words +rank seventeen, but retains a nonzero rank-sixteen diagonal word. It therefore +fails the endpoint gate despite its favorable maximal-rank count. The portable +`verify_grade.py` regenerates this unchanged independent check in private +scratch from authenticated vendored Clifford source and compares its receipt. +Its only adaptation replaces one Git source-loader line; scientific code is +unchanged. Run it normally or with `-I -O -W error -B`. Both registered variants +are below one second. This small portable check is separate from the larger +native accounting/wrapper audit, whose local-only replay limit remains above. diff --git a/research/two-full-central-obstruction/RESULT.json b/research/two-full-central-obstruction/RESULT.json index 7dbfe8b183..35fb95e384 100644 --- a/research/two-full-central-obstruction/RESULT.json +++ b/research/two-full-central-obstruction/RESULT.json @@ -6,12 +6,14 @@ "no_new_kappa": true, "own_files": { "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", - "ORIGINS.json": "6f977f3b457ab0b8b95f2819b680ff450e6df1532ef1e721cac4eb083960b21d", - "PROOF.md": "71cb1a2f41d6376b4e3e23667f2c31a192f566ca9c8a2422d732c2a9dd7cb6fb", - "README.md": "76cf36a478951b984a19703d30d815ec001d05fb2c8164079839d35c139b10c2", - "SOURCES.json": "69b0603e6c62cab5d70aaad2379cb26cbebfa2adb761d23003f3ac20ea55ff72", - "TASK.json": "70eca26a933416627cd79edc451844506f996b2fce411ce4a93b42fcc2aa62a2", - "VERIFY.json": "ae8ef73ebd3541e125e56e0069f3f349776ca1207c00333e0f4a2960768668f3", + "ORIGINS.json": "27502ba9b20cff63d95087454104215c5fa4823e9f658f1766f44b36e01b92c2", + "PROOF.md": "9babe77410543665f197cd1846d71d775d306c97716aedefc6f25f4256f5a699", + "README.md": "52663560c13b18547752af243b47693a9c7e76cd3cb7bb86328e609533c5a4e1", + "SOURCES.json": "f8c183475fbd29f248f7d4b73440b2e4fc19a07cd2f9f34ef308e1b6f02629fe", + "TASK.json": "545427fe9840bbd412cb5127b27d1039babad7c44961222f3ab08a5fa81ab230", + "VERIFY.json": "fd7db98db5d6938844232e96ce2e7140c2b453b8b8d261f1a602d597e94fdf62", + "grade/PROOF.md": "8fd775a9903eca0f53b186d7fb684d9f5f74afc9c105082b3d4981bd950fca33", + "grade/check.py": "6d77983fccc03afc9bbc2b8b06dc1dc9db0baf2431f503bca834cf42b69edc2b", "independent/algebra-REVIEW.md": "500acba75f4550d5cf393868e14a64657ec602ef14ac008dca54c26cc5b11d96", "independent/algebra-SOURCES.json": "594639fb00de36762951215c7bf0cd67360cfe7b536f809a823aa508c0a0aaa0", "independent/native-ACCOUNTING.json": "488a4f03827c1dd0fdc94a647dd45ef30a45c5844938975800f8993b57b028b9", @@ -21,11 +23,13 @@ "independent/native-WRAPPERS.json": "bd3d02645c2bfc1fdb6c44a2484abf7269c26d5514c248168a0fa792c99d30ca", "inputs/native/NATIVE-VALIDATION.json": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", "inputs/native/README.md": "6cfcd49a0601f5b1f184a2567fc35dcb0a5c28eb06fce5e510d54895e8d17fde", + "inputs/native/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", "inputs/native/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", "inputs/native/native_inventory.py": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32", "inputs/native/query_thinned_verify.py": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", "inputs/predecessors/PR4666-GLOBAL-PROOF.md": "adc377b13924701bf5b0b50b091d8b69c90195d50ce0f6808f7fb4c7e0b16457", - "verify.py": "eb72ec69065a33fe30c10059f21ff2b13f46f16b413280c6eb19e6b52643ddb7" + "verify.py": "eb72ec69065a33fe30c10059f21ff2b13f46f16b413280c6eb19e6b52643ddb7", + "verify_grade.py": "bd75531cbb6256e02931dd695c96055e623855ae3a8c0fd58c5c52b592edf8f5" }, "projection_formula_fixtures": 64, "projective_group_order": 24, @@ -39,6 +43,7 @@ "sources": { "inputs/native/NATIVE-VALIDATION.json": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", "inputs/native/README.md": "6cfcd49a0601f5b1f184a2567fc35dcb0a5c28eb06fce5e510d54895e8d17fde", + "inputs/native/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", "inputs/native/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", "inputs/native/native_inventory.py": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32", "inputs/native/query_thinned_verify.py": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950", diff --git a/research/two-full-central-obstruction/SOURCES.json b/research/two-full-central-obstruction/SOURCES.json index 70292cc555..028238ee4a 100644 --- a/research/two-full-central-obstruction/SOURCES.json +++ b/research/two-full-central-obstruction/SOURCES.json @@ -61,6 +61,13 @@ "pin": "head:08ac39202263203fded429c826ba9228ac9df803:research/productive-controller-basis-search/GLOBAL-PROOF.md", "git_blob": "74b67e22e6c063193a83825207cdec19a8fef7a4", "sha256": "adc377b13924701bf5b0b50b091d8b69c90195d50ce0f6808f7fb4c7e0b16457" + }, + { + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" } ] } diff --git a/research/two-full-central-obstruction/TASK.json b/research/two-full-central-obstruction/TASK.json index 901ca9d998..5a7627f4b7 100644 --- a/research/two-full-central-obstruction/TASK.json +++ b/research/two-full-central-obstruction/TASK.json @@ -62,5 +62,11 @@ "first_step": "Name one actual helper cut and its input/output owner operator, write the literal changed consumer with all returns, and price an optimistic complete bill before search.", "blocked_by": "No such chronological helper consumer or improved complete invoice is supplied; existing helper jobs cannot be used as identity scratch." } - ] + ], + "additive_scope": { + "object": "Full monomial Clifford routing on exactly two main owners, no other states", + "result": "Untouched row/column lower-grade purity obstruction retains both actual rank-eight transverse factors and excludes two rank-seventeen independent outputs.", + "limits": "Distinct from original separated-address dirty-scratch scope; no simultaneous full-routing plus added-owner/helper-resource claim.", + "evidence": "Written additive proof and unchanged independent one-CZ grade check, with portable authenticated-loader adapter; no enumeration." + } } diff --git a/research/two-full-central-obstruction/VERIFY.json b/research/two-full-central-obstruction/VERIFY.json index e2e70c9d19..3bcfeef5f8 100644 --- a/research/two-full-central-obstruction/VERIFY.json +++ b/research/two-full-central-obstruction/VERIFY.json @@ -29,6 +29,31 @@ ], "timeout_seconds": 60, "checks": "Authenticates frozen native/predecessor bytes, exact central Clifford group and monomial subgroup, projection formula/support controls, modular projective tensor ranks and width-one semantic faults. Written proof supplies universal quantifiers; no native or outer replay." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify_grade.py" + ], + "timeout_seconds": 60, + "checks": "Hash-authenticates unchanged independent one-CZ grade checker and retained exact Clifford engine, adapts only Git source-loader to vendored bytes, regenerates unchanged scientific receipt in private scratch; verifies both maximal off-diagonal grades17 and failed lower-grade purity. No new endpoint or broad search." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify_grade.py" + ], + "timeout_seconds": 60, + "checks": "Hash-authenticates unchanged independent one-CZ grade checker and retained exact Clifford engine, adapts only Git source-loader to vendored bytes, regenerates unchanged scientific receipt in private scratch; verifies both maximal off-diagonal grades17 and failed lower-grade purity. No new endpoint or broad search." } ] } diff --git a/research/two-full-central-obstruction/grade/PROOF.md b/research/two-full-central-obstruction/grade/PROOF.md new file mode 100644 index 0000000000..4cdf1e1a29 --- /dev/null +++ b/research/two-full-central-obstruction/grade/PROOF.md @@ -0,0 +1,121 @@ +# Full monomial routing does not complete the two-owner, two-FULL unit + +This note audits the lower-grade argument proposed by the root agent and +gives a direct-column formulation retaining the actual transverse factors. +It is an additive mathematical note for Discussion4902, not a new PR or a +physical consumer. All helper jobs remain autonomous and unchanged. There +are exactly two main owners per port, without access to other transformed +states or scratch owners in this extension. + +## A single controlled-phase check and its rejected endpoint gate + +Normalize the ambient axes to one central q, eight old A axes, and eight +fresh B axes. Let a be one A axis. The literal controlled phase + + C_f: value[address] *= (-1)^(sum_columns q_column*a_column) + +is a monomial Clifford. Apply it only to the Y owner between the two FULL +calls. It is one pass per port, 112 passes for the actual 112-port bank, +with zero extra Gaussian calls. Its literal inverse and inverse transpose +are itself. It requires only predetermined signs, independent of input data. +For source normalized coordinates q=bit8, a=bit0, this is the quadratic +phase with exactly the cross term q*a and no linear/global phase. The +checker relabels these as bits0/1 and retains all other fifteen axes. + +Writing positive central Q and positive transverse D_A,D_B, the main word is + + M = D_B [[1,-Q],[0,1]] diag(I,C) D_A [[1,0],[Q^-1,1]]. + +All factors are literal words. Matrix multiplication gives + + M11 = D_B D_A - D_B Q C D_A Q^-1, + M12 = -D_B Q C D_A, + M21 = D_B C D_A Q^-1, + M22 = D_B C D_A. + +The exact pinned Clifford engine finds grades16,16 for the two M11 words, +17 for M12 and M21, and16 for M22. These are true17-axis signed-tableau +calculations, not width-one owner/address interchange. The off-diagonal +rank17 words pass the maximal-grade image-count gate. They nevertheless +fail the necessary lower-grade purity gate: M22 is a nonzero group unit of +grade16, and arbitrary invertible monomial-algebra outer matrices cannot +erase the whole grade16 matrix component. + +The pure coordinate swap q<->a is retained as a discriminating control: +only M21 then has grade17. The controlled phase avoids that one-copy +obstruction but does not produce an endpoint. Its positive maximal-grade +gate must not be reported as a positive feasibility result. + +## The stronger two-owner theorem, with arbitrary interstage words + +Let G be a fixed finite group of one-column17-axis Clifford matrices, +including absolute phases. Let H be its full monomial subgroup, B=K[H], +A=K[G], with K enlarged if needed for a necessary obstruction. Gaussian +Fourier rank is invariant under monomial multiplication on either side. +Projection pi_<=16 onto group basis elements of rank at most16 is therefore +a B-bimodule map. The same holds in the central-character twisted quotient +needed at a fixed tensor width; scalar phases do not change Fourier rank. + +Let each actual FULL main block have form + + T_s = diag(D_sx,D_sy) E_s, + +where both D_sx,D_sy have Gaussian rank eight, and E_s is either elementary +upper or lower shear with one arbitrary central Clifford letter. The +letters may differ, need not commute, and may include signs or inverses. +Allow arbitrary L,W,R in GL_2(B). Suppose + + L T_2 W T_1 R = diag(g1,g2), + +where both g1,g2 are single Clifford words of Fourier rank17, up to arbitrary +monomial boundaries. The target is pure grade17. By the bimodule property +and invertibility of L,R, pi_<=16(T_2 W T_1)=0. + +Choose the input column c untouched by E_1 (column2 for a lower shear, +column1 for an upper shear). Choose the output row r untouched by E_2. +Let i be the other row. Direct multiplication in the actual factor order +gives + + M_rc = D_2r W_rc D_1c. + +Every group word in W_rc is monomial. Fourier-rank subadditivity implies +every word of this entry has rank at most8+0+8=16. Thus it is its own +pi_<=16 projection and must vanish. The D factors are group units, hence +W_rc=0. The other entry in that input column then simplifies to + + M_ic = D_2i W_ic D_1c, + +because its possible second-shear contribution factors through W_rc=0. +It too is supported only on grades at most16, so it vanishes and W_ic=0. +The entire c-th column of W is zero, contradicting its invertibility. + +No commutation of a changed central letter with a raw transverse factor is +needed in this direct-column proof. In particular the raw D0 translation +correction cannot break it. Role-dependent D factors of rank eight are +allowed. The proof keeps every transverse operation explicitly and grants +the full monomial Clifford subgroup, including central/fresh axis mixing, +controlled phases, and arbitrary non-diagonal interstage W. + +The all-width group-algebra implication is the separating-polynomial proof +in [the retained independent review](../independent/algebra-REVIEW.md): for all sufficiently large f, +distinct projective Clifford words tensor-powered f times are linearly +independent after specializing global phases. Thus accidental one-column +matrix sums do not invalidate the pure-grade argument. Width-dependent +scalar choices and free words are permitted within the same fixed finite +one-column alphabet. Arbitrary width-specific address operations outside +that alphabet remain outside the claim. + +## Exact scope and stopping decision + +This closes two FULL calls on exactly two main owners per port under the +declared macro endpoint, even with arbitrary full-monomial owner boundaries +and interstage words. It does not close access to transformed helper +states, additional scratch mixing, changed native operations, inter-port +mixing with unbound coordinate frames, a different target invoice, or a +non-columnwise address grammar. The separate separated-H theorem covers a +different relaxed scratch model; these scopes must not be combined silently. + +The hypothetical invoice `224H17+2H` against `2P` remains positive before +finite/compiler/outer work, but this endpoint cannot be attained in the +two-owner model. The controlled-phase policy is stopped. No wider circuit +enumeration or synthesis was run and no kappa improvement is claimed. diff --git a/research/two-full-central-obstruction/grade/RESULT.json b/research/two-full-central-obstruction/grade/RESULT.json new file mode 100644 index 0000000000..e079fbcbda --- /dev/null +++ b/research/two-full-central-obstruction/grade/RESULT.json @@ -0,0 +1,143 @@ +{ + "status": "PASS_EXACT_CZ_GRADES_BUT_FAIL_LOWER_GRADE_PURITY_GATE", + "source_commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "compiler_path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "compiler_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "physical_monomial": "C_f=(-1)^(sum_columns q_column*a_column), applied to interstage Y only", + "monomial_passes_per_port": 1, + "main_ports": 112, + "total_main_monomial_passes": 112, + "extra_gaussian_calls": 0, + "helper_inputs_and_targets_unchanged": true, + "old_two_axis_grades": { + "M11_first": 1, + "M11_cross": 1, + "M12_minus": 2, + "M21": 2, + "M22": 1 + }, + "full17_axis_grades": { + "M11_first": 16, + "M11_cross": 16, + "M12_minus": 17, + "M21": 17, + "M22": 16 + }, + "pure_swap_control_grades": { + "M11_first": 16, + "M11_cross": 16, + "M12_minus": 15, + "M21": 17, + "M22": 16 + }, + "old_two_axis_literal_words": { + "M11_first": [ + [ + "C", + 2, + 1 + ] + ], + "M11_cross": [ + [ + "C", + 1, + -1 + ], + [ + "C", + 2, + 1 + ], + [ + "D", + [ + 2, + 1 + ], + [ + 0, + 0 + ] + ], + [ + "C", + 1, + 1 + ] + ], + "M12_minus": [ + [ + "C", + 2, + 1 + ], + [ + "D", + [ + 2, + 1 + ], + [ + 0, + 0 + ] + ], + [ + "C", + 1, + 1 + ] + ], + "M21": [ + [ + "C", + 1, + -1 + ], + [ + "C", + 2, + 1 + ], + [ + "D", + [ + 2, + 1 + ], + [ + 0, + 0 + ] + ] + ], + "M22": [ + [ + "C", + 2, + 1 + ], + [ + "D", + [ + 2, + 1 + ], + [ + 0, + 0 + ] + ] + ] + }, + "max_rank_projection_image": "2*dim_K B, since [[c,b],[a,0]] is injective on B^2 for group units a,b", + "optimistic_profile": "224H17+2H versus 2P; source funded-C unwrapped surplus about39.063938", + "maximal_grade_count_gate_passed": true, + "lower_grade_purity_gate_passed": false, + "lower_grade_obstruction": "M22 is a nonzero grade16 group unit; invertible outer GL2(B) cannot erase a nonzero grade16 matrix component", + "endpoint_identity_proved": false, + "native_full_caller_proved": false, + "compiler_reserve_funded": false, + "scope": "one literal interstage controlled phase; no enumeration, no outer boundary synthesis, no kappa" +} diff --git a/research/two-full-central-obstruction/grade/check.py b/research/two-full-central-obstruction/grade/check.py new file mode 100644 index 0000000000..6a2937d208 --- /dev/null +++ b/research/two-full-central-obstruction/grade/check.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python3 +"""One literal controlled-phase opportunity, no enumeration; Apache-2.0. + +Substantial OpenAI Codex assistance; native #4610 and exact Clifford engine +credits retained. Does not assert a two-call endpoint or physical consumer. +""" +from pathlib import Path +from hashlib import sha256 +import json,os,subprocess,sys,types + +HERE=Path(__file__).resolve().parent +PIN='20bb93cd990d2ff683e4d0fc56b87a42cd5d3296' +PATH='research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py' +raw=subprocess.check_output(['git','show',PIN+':'+PATH],env={**os.environ,'GIT_NO_REPLACE_OBJECTS':'1'}) +ce=types.ModuleType('controlled_phase_exact');sys.modules[ce.__name__]=ce +exec(compile(raw,PATH,'exec'),ce.__dict__) + +def need(ok,message): + if not ok:raise ValueError(message) + +def grade(op):return ce.rank([x for x,z,p in op.tab[op.n:]]) + +# Physical bit0 is the shared q coordinate; bit1 is one already-paid A axis. +# C is exactly (-1)^(q*a), a monomial of absolute phase +1 at address zero. +q=ce.cgate(2,1);a=ce.cgate(2,2);C=ce.diag(2,(2,1)) +need(grade(C)==0,'one literal monomial controlled phase') +terms={ + 'M11_first':a, + 'M11_cross':q.adjoint().then(a).then(C).then(q), + 'M12_minus':a.then(C).then(q), + 'M21':q.adjoint().then(a).then(C), + 'M22':a.then(C), +} +grades={name:grade(op) for name,op in terms.items()} +need(grades['M12_minus']==grades['M21']==2,'both offdiagonal words have maximal old-two-axis grade') +need(grades['M22']==grades['M11_first']==1,'old diagonal grade is one') +need(grade(C.then(C))==0 and C.then(C).tab==ce.ident(2).tab,'C inverse is same literal monomial') +# Absolute phase is retained by the exact circuit word. The four-column +# monomial C action is also checked independently from its literal definition. +phase={x:(-1 if x==3 else 1) for x in range(4)} +need(phase=={0:1,1:1,2:1,3:-1},'controlled-phase address convention') + +# Lift the exact literal words to all17 axes. Spectator A hasseven axes, +# fresh B haseight, so offdiagonal rank is2+15=17 at every column width. +def lift(op,n): + out=ce.ident(n) + for g in op.circuit: + if g[0]=='C':gate=ce.cgate(n,g[1],g[2]) + elif g[0]=='D':gate=ce.diag(n,tuple(g[1])+(0,)*(n-op.n),tuple(g[2])+(0,)*(n-op.n)) + else:raise ValueError('unexpected literal gate '+repr(g)) + out=out.then(gate) + return out +spectator=ce.fourier(17,range(2,17)) +full={name:grade(lift(op,17).then(spectator)) for name,op in terms.items()} +need(full['M12_minus']==full['M21']==17 and full['M22']==16,'actual17-axis support grades') + +# Control: a pure q<->a address swap instead of C has only one rank17 word. +P=ce.perm(2,(2,1)) +swap={ + 'M11_first':a, + 'M11_cross':q.adjoint().then(a).then(P).then(q), + 'M12_minus':a.then(P).then(q), + 'M21':q.adjoint().then(a).then(P), + 'M22':a.then(P), +} +swapgrades={name:grade(op)+15 for name,op in swap.items()} +need([name for name,r in swapgrades.items() if r==17]==['M21'],'pure-swap one-copy obstruction control') + +result=dict(status='PASS_EXACT_CZ_GRADES_BUT_FAIL_LOWER_GRADE_PURITY_GATE', + source_commit=PIN,compiler_path=PATH,compiler_sha256=sha256(raw).hexdigest(), + physical_monomial='C_f=(-1)^(sum_columns q_column*a_column), applied to interstage Y only', + monomial_passes_per_port=1,main_ports=112,total_main_monomial_passes=112, + extra_gaussian_calls=0,helper_inputs_and_targets_unchanged=True, + old_two_axis_grades=grades,full17_axis_grades=full,pure_swap_control_grades=swapgrades, + old_two_axis_literal_words={name:op.circuit for name,op in terms.items()}, + max_rank_projection_image='2*dim_K B, since [[c,b],[a,0]] is injective on B^2 for group units a,b', + optimistic_profile='224H17+2H versus 2P; source funded-C unwrapped surplus about39.063938', + maximal_grade_count_gate_passed=True,lower_grade_purity_gate_passed=False, + lower_grade_obstruction='M22 is a nonzero grade16 group unit; invertible outer GL2(B) cannot erase a nonzero grade16 matrix component', + endpoint_identity_proved=False,native_full_caller_proved=False,compiler_reserve_funded=False, + scope='one literal interstage controlled phase; no enumeration, no outer boundary synthesis, no kappa') +(HERE/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n') +print(json.dumps({k:v for k,v in result.items() if k!='old_two_axis_literal_words'},sort_keys=True)) diff --git a/research/two-full-central-obstruction/inputs/native/clifford_exact.py b/research/two-full-central-obstruction/inputs/native/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/two-full-central-obstruction/inputs/native/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<