From f6fa6d1930069ef52fce431250129819a3931767 Mon Sep 17 00:00:00 2001 From: thu-nmrc Date: Fri, 23 Oct 2026 20:29:24 +0800 Subject: [PATCH 1/3] research: stabilize two-FULL obstruction under dirty identity workspace --- .../INDEPENDENT-REVIEW.md | 100 ++++++ .../INDEPENDENT-SOURCE-READS.json | 44 +++ .../INDEPENDENT-SYMBOLIC.json | 181 ++++++++++ research/two-full-dirty-stability/LICENSE | 201 +++++++++++ .../two-full-dirty-stability/OVERLAP.json | 27 ++ research/two-full-dirty-stability/PROOF.md | 193 +++++++++++ research/two-full-dirty-stability/README.md | 75 ++++ research/two-full-dirty-stability/RESULT.json | 208 +++++++++++ .../two-full-dirty-stability/SOURCES.json | 54 +++ research/two-full-dirty-stability/TASK.json | 66 ++++ .../two-full-dirty-stability/VALIDATION.json | 81 +++++ research/two-full-dirty-stability/VERIFY.json | 63 ++++ .../independent_symbolic.py | 191 +++++++++++ research/two-full-dirty-stability/verify.py | 323 ++++++++++++++++++ 14 files changed, 1807 insertions(+) create mode 100644 research/two-full-dirty-stability/INDEPENDENT-REVIEW.md create mode 100644 research/two-full-dirty-stability/INDEPENDENT-SOURCE-READS.json create mode 100644 research/two-full-dirty-stability/INDEPENDENT-SYMBOLIC.json create mode 100644 research/two-full-dirty-stability/LICENSE create mode 100644 research/two-full-dirty-stability/OVERLAP.json create mode 100644 research/two-full-dirty-stability/PROOF.md create mode 100644 research/two-full-dirty-stability/README.md create mode 100644 research/two-full-dirty-stability/RESULT.json create mode 100644 research/two-full-dirty-stability/SOURCES.json create mode 100644 research/two-full-dirty-stability/TASK.json create mode 100644 research/two-full-dirty-stability/VALIDATION.json create mode 100644 research/two-full-dirty-stability/VERIFY.json create mode 100644 research/two-full-dirty-stability/independent_symbolic.py create mode 100644 research/two-full-dirty-stability/verify.py diff --git a/research/two-full-dirty-stability/INDEPENDENT-REVIEW.md b/research/two-full-dirty-stability/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..2d1aaf2bf8 --- /dev/null +++ b/research/two-full-dirty-stability/INDEPENDENT-REVIEW.md @@ -0,0 +1,100 @@ +# Independent agent review: full-monomial two-FULL stability under dirty identity work + +Status: **PASS for the stated written theorem**, subject to the source and scope premises below. This is a separate OpenAI Codex agent review with substantial AI assistance. It is not independent human review, proof-kernel acceptance, native scientific admission, a new multiplication exponent, or a physical consumer. + +## Sources actually read and pinned + +I read the complete #4920 proof, its separate full-routing grade proof, and its source manifest; the complete #4928 retained-helper proof, the independent review and its source manifests; and the current two-FULL contract map. The repository ref read was `a5df48c55ea806d7952b65acc9c76d878ff09b13`. `INDEPENDENT-SOURCE-READS.json` records exact Git blobs and SHA256 values of the seven proof/manifest inputs actually read. + +- #4920: `research/two-full-central-obstruction/PROOF.md`, exact PR head `7eb4ef5251f7ba96c7e5d78c42fc98e66b7be4ba`, SHA256 `9babe77410543665f197cd1846d71d775d306c97716aedefc6f25f4256f5a699`. The main bytes read equal that PR-head proof byte-for-byte. Its separate `grade/PROOF.md` has SHA256 `8fd775a9903eca0f53b186d7fb684d9f5f74afc9c105082b3d4981bd950fca33`. +- #4928: `research/two-full-retained-helper-ceiling/science/PROOF.md`, exact PR head `6df6ed294614423836cbde182fb4368c9c346fe7`, SHA256 `63ec5034fb526dc9243de487f97477e51221773f4b7cae21b38df719ba1362c7`. The main bytes read equal that PR-head proof byte-for-byte. Its science source manifest has SHA256 `95e03830d931e2ac6843457a832a6f75c6227f85cae85d95095c65df7049c490`. + +These sources bind the actual native source at `20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`, and the dirty-helper protocol source #4712 at `b75a27bf07f1584b20babfddf887493981cd5949`. In particular the declared actual-word compressed SHA256 is `7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05`, Git blob `46d929df83817b85a5387bcdb9745e0627d6366e`. I read these pin declarations; this review does **not** claim to have rerun all eight native source checks or the full 632-field program. The predecessor native/main normalization is an inherited written premise here. + +#4920's full-routing proof covered exactly two main owners. #4928 covered retained productive helpers under a separated address algebra. The proposed result is an extension of the former to restored dirty identity workspace. It does not combine the latter's transformed-helper permission with full routing. + +## Statement reviewed + +At a fixed sufficiently large tensor width, use the finite central-character twisted Clifford group algebra A over K, and its full monomial subgroup algebra B. All one-column matrices retain absolute phases. Let d=dim_K B. There are two main owners and s arbitrary dirty workspace owners, and each native call is `Tj=diag(Aj,I_s)`, where `Aj=diag(Djx,Djy) Ej`; each D has Fourier rank eight, and E is either triangular elementary shear with one pure central Clifford letter. The letters and D factors need not commute and may differ between calls. Arbitrary owner controls `L,W,R` lie in `GL_(s+2)(B)`. + +The claimed target is `diag(g1,g2,I_s)` with each gj a single rank-seventeen Clifford word up to admitted monomial boundaries. No transformed helper output is supplied as identity workspace. + +## Grade projection and arbitrary outer boundaries + +Fourier rank is invariant under multiplication on either side by a monomial Clifford word. Consequently both projections + +- rho: retain grades 1 through 16; +- Pi: retain grades 0 through 16 + +are B-bimodule maps, including in the phase-character twisted quotient. Neither is asserted to be an algebra homomorphism. Since rho kills both the rank-seventeen main targets and the grade-zero identity workspace, the target equation implies + + L rho(T2 W T1) R = 0. + +Multiplying by the actual inverses of L and R is legitimate, even with arbitrary main/workspace mixing and zero divisors in B. Thus rho(T2 W T1)=0. This does not use a false assumption that L or R preserve the main/workspace block decomposition. + +## Hand derivation for all four orientations + +Use main indices 0,1. Let c be the input column untouched by E1, r the output row untouched by E2, and let j=1-c, i=1-r. + +| E1 | E2 | c | r | j | i | +|---|---|---:|---:|---:|---:| +| upper | upper | 0 | 1 | 1 | 0 | +| upper | lower | 0 | 0 | 1 | 1 | +| lower | upper | 1 | 1 | 0 | 0 | +| lower | lower | 1 | 0 | 0 | 1 | + +Write a for the first shear letter and b for the second; signs and orientations can be incorporated in those actual letters. For each scratch output/input index z, direct matrix multiplication, with no commutation, gives + + M_rz = D2r W_rz, + M_iz = D2i W_iz + D2i b W_rz, + M_zc = W_zc D1c, + M_zj = W_zj D1j + W_zc D1c a. + +The first and third expressions are supported purely in grade eight: each W entry is a sum of monomial words. Rho therefore retains them exactly. Their vanishing and the group-unit D factors imply `W_rz=W_zc=0`. The other two expressions then simplify to pure grade-eight terms, forcing `W_iz=W_zj=0`. This kills both cross blocks for every s and every orientation pair. It does not divide by a general B coefficient. + +Hence W is block diagonal. Since W is invertible in the full matrix ring, both diagonal blocks Wmm and Wss are units: the corresponding diagonal blocks of an inverse give two-sided inverses. This step is valid over a noncommutative ring with zero divisors. + +## Rank-domain audit and alternative proof + +Before the intermediate-grade step, low-grade main entries need not lie in B. The final author proof now first establishes rho(M)=0 and explicitly concludes Pi(M)=pi_0(M), so its B-valued endomorphism rank argument is justified. The following more general K-linear formulation is an alternative proof, not a required correction to that final version: view the projected matrix as a map + + B^(s+2) -> A^(s+2), + +not as a B-valued endomorphism of B^(s+2). This is sufficient. Right multiplication by R is an invertible map on the domain; left multiplication by L is an invertible map on the A-valued codomain, with its inverse still given by L^-1 over B. Both preserve K-linear rank. + +After the cross blocks vanish, + + Pi(M) = diag(Pi(A2 Wmm A1), Wss). + +The projected target has K-linear rank exactly s*d. The Wss block already has rank s*d on B^s. Its image and the main image occupy disjoint output coordinates, so additivity of rank forces the main projected block to have rank zero. Evaluating it on the two vectors with the unit of B in one coordinate shows that every main-low entry is zero. No semisimplicity, domain assumption, positivity or division by a zero divisor is needed. + +The main-only #4920 contradiction now applies to Wmm. Its untouched corner is + + (A2 Wmm A1)_rc = D2r W_rc D1c. + +Every word has grade at most 8+0+8=16, so Pi retains this corner and forces W_rc=0. The other entry in the same main input column becomes `D2i W_ic D1c`; it too is retained by Pi and vanishes. An entire column of Wmm is zero, contradicting that Wmm is a unit. + +## Independent finite corroboration completed + +`independent_symbolic.py` was written separately and imports neither another checker nor a Clifford implementation. It uses exact integer-coefficient noncommutative free words. Its default invocation is read-only and prints JSON to stdout. I ran + + python3.11 -I -B independent_symbolic.py + python3.11 -I -O -B independent_symbolic.py + +from this directory, retaining the externally redirected outputs as `INDEPENDENT-SYMBOLIC.json` and `INDEPENDENT-SYMBOLIC-OPTIMIZED.json`; they compare byte-for-byte. The twelve fixtures cover all four orientation pairs and s=1,2,3. They check 72 cross-row identities, 72 cross-column identities, scratch-block preservation, exact block-diagonal reduction, and 36 untouched-main-column formulas/zero substitutions. Noncommuting-order and incomplete-cross-zero controls discriminate the key algebraic shortcuts. + +These fixtures corroborate symbolic matrix expansion only. They do not compute actual Clifford grades, exhaust arbitrary s, prove the B-bimodule assertion, prove tensor faithfulness, authenticate every native source, or establish scientific acceptance. Universal quantifiers come from the written argument above. + +## Scope limits and unresolved obligations + +- Dirty workspace must represent independent arbitrary inputs returned as the stated identity jobs, and all free global controls are invertible over B. A construction correct only at owned-zero entrances, rectangular COPY/DROP, noninvertible CLEAR, main-dependent garbage, or a nonidentity transformed workspace target requires another argument. +- Actual native helper targets, including already transformed helper states and copied producer-prefix observations, are not I_s. This theorem does not rule out a correctly charged changed producer/consumer using them. +- The same finite columnwise Clifford alphabet and its full monomial subgroup are retained. The separating tensor-power argument of #4920 supplies faithfulness for every sufficiently large width after the correct scalar-phase specialization. Arbitrary s, even depending on width, does not enlarge the address alphabet. A growing or noncolumnwise width-specific address grammar is outside that premise. +- The target main jobs must be pure rank-seventeen Clifford words. An approximate target, a sum-valued endpoint, a changed target invoice, extra interleaved nonmonomial work, or a different paid native source is outside the statement. +- No complete native caller, compiler reserve, precision propagation, outer transfer, BIT assembly, Lean kernel check, or new kappa was run or claimed. + +The review finds no remaining mathematical blocker for the stated dirty-identity stabilization. It does not promote this scoped negative result to an obstruction for every intended research direction. + +## Final author-proof addendum + +I read the complete final author `PROOF.md` with SHA256 `99b3b4233891519fd741ea20cfe985c09bef576a94154e6b146db87f9b857200`. Its rank section explicitly uses rho(M)=0 to obtain Pi(Mm)=pi_0(Mm), and also derives Pi(M)=L^-1 P R^-1 in Mat(B). Therefore its regular-module endomorphism rank comparison on B^(s+2) is legitimate. This version resolves the rank-domain concern noted during the earlier draft review; there is no outstanding correction requested on that point. The B-domain to A-codomain argument above is retained as an independent alternative formulation. The final proof also preserves the actual noncommutative factor order, all four shear orientations, full outer mixing, and the stated identity-scratch scope. No new blocker was found on this final read. diff --git a/research/two-full-dirty-stability/INDEPENDENT-SOURCE-READS.json b/research/two-full-dirty-stability/INDEPENDENT-SOURCE-READS.json new file mode 100644 index 0000000000..8503bfdec0 --- /dev/null +++ b/research/two-full-dirty-stability/INDEPENDENT-SOURCE-READS.json @@ -0,0 +1,44 @@ +[ + { + "ref": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "path": "research/two-full-central-obstruction/PROOF.md", + "git_blob": "66df36c04d0f88018fd640aa095bb55eeacb17e1", + "sha256": "9babe77410543665f197cd1846d71d775d306c97716aedefc6f25f4256f5a699" + }, + { + "ref": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "path": "research/two-full-central-obstruction/grade/PROOF.md", + "git_blob": "4cdf1e1a29b2113e88513f7a7d983f1e52adb6db", + "sha256": "8fd775a9903eca0f53b186d7fb684d9f5f74afc9c105082b3d4981bd950fca33" + }, + { + "ref": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "path": "research/two-full-central-obstruction/SOURCES.json", + "git_blob": "028238ee4a45ccba296ff103cb27a4f9a9902c31", + "sha256": "f8c183475fbd29f248f7d4b73440b2e4fc19a07cd2f9f34ef308e1b6f02629fe" + }, + { + "ref": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "path": "research/two-full-retained-helper-ceiling/science/PROOF.md", + "git_blob": "85eb3ade566aecd21b681085543eff617fc0f5db", + "sha256": "63ec5034fb526dc9243de487f97477e51221773f4b7cae21b38df719ba1362c7" + }, + { + "ref": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "path": "research/two-full-retained-helper-ceiling/independent/REVIEW.md", + "git_blob": "52c0b0a827d154c7f6542c6ea87704620a015a63", + "sha256": "010c22b8d745e54783ce4d5f220bf16dbd906e5dbc1db62a3cad81101fd168a7" + }, + { + "ref": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "path": "research/two-full-retained-helper-ceiling/science/SOURCES.json", + "git_blob": "86b25a71fd69202c8d4674ee44ca354839f3cc61", + "sha256": "95e03830d931e2ac6843457a832a6f75c6227f85cae85d95095c65df7049c490" + }, + { + "ref": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "path": "research/two-full-retained-helper-ceiling/SOURCES.json", + "git_blob": "cf471c637b3f187dff2bb456e509adb0b4775e81", + "sha256": "3f83fad2c35232609756ac1498ce2900017b8a191b18724d56c8f5e40eb1f68f" + } +] diff --git a/research/two-full-dirty-stability/INDEPENDENT-SYMBOLIC.json b/research/two-full-dirty-stability/INDEPENDENT-SYMBOLIC.json new file mode 100644 index 0000000000..53fb44cf21 --- /dev/null +++ b/research/two-full-dirty-stability/INDEPENDENT-SYMBOLIC.json @@ -0,0 +1,181 @@ +{ + "arithmetic": "Exact integer-coefficient noncommutative free words", + "cross_column_identities": 72, + "cross_row_identities": 72, + "fixture_count": 12, + "fixtures": [ + { + "block_diagonal_reduction": true, + "cross_column_identities": 3, + "cross_row_identities": 3, + "first_orientation": "upper", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 1, + "second_orientation": "upper", + "untouched_first_column": 0, + "untouched_main_column_identities": 3, + "untouched_second_row": 1 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 6, + "cross_row_identities": 6, + "first_orientation": "upper", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 2, + "second_orientation": "upper", + "untouched_first_column": 0, + "untouched_main_column_identities": 3, + "untouched_second_row": 1 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 9, + "cross_row_identities": 9, + "first_orientation": "upper", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 3, + "second_orientation": "upper", + "untouched_first_column": 0, + "untouched_main_column_identities": 3, + "untouched_second_row": 1 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 3, + "cross_row_identities": 3, + "first_orientation": "upper", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 1, + "second_orientation": "lower", + "untouched_first_column": 0, + "untouched_main_column_identities": 3, + "untouched_second_row": 0 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 6, + "cross_row_identities": 6, + "first_orientation": "upper", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 2, + "second_orientation": "lower", + "untouched_first_column": 0, + "untouched_main_column_identities": 3, + "untouched_second_row": 0 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 9, + "cross_row_identities": 9, + "first_orientation": "upper", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 3, + "second_orientation": "lower", + "untouched_first_column": 0, + "untouched_main_column_identities": 3, + "untouched_second_row": 0 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 3, + "cross_row_identities": 3, + "first_orientation": "lower", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 1, + "second_orientation": "upper", + "untouched_first_column": 1, + "untouched_main_column_identities": 3, + "untouched_second_row": 1 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 6, + "cross_row_identities": 6, + "first_orientation": "lower", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 2, + "second_orientation": "upper", + "untouched_first_column": 1, + "untouched_main_column_identities": 3, + "untouched_second_row": 1 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 9, + "cross_row_identities": 9, + "first_orientation": "lower", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 3, + "second_orientation": "upper", + "untouched_first_column": 1, + "untouched_main_column_identities": 3, + "untouched_second_row": 1 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 3, + "cross_row_identities": 3, + "first_orientation": "lower", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 1, + "second_orientation": "lower", + "untouched_first_column": 1, + "untouched_main_column_identities": 3, + "untouched_second_row": 0 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 6, + "cross_row_identities": 6, + "first_orientation": "lower", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 2, + "second_orientation": "lower", + "untouched_first_column": 1, + "untouched_main_column_identities": 3, + "untouched_second_row": 0 + }, + { + "block_diagonal_reduction": true, + "cross_column_identities": 9, + "cross_row_identities": 9, + "first_orientation": "lower", + "incomplete_cross_zero_control": true, + "noncommuting_order_control": true, + "scratch_block_preserved_exactly": true, + "scratch_owners": 3, + "second_orientation": "lower", + "untouched_first_column": 1, + "untouched_main_column_identities": 3, + "untouched_second_row": 0 + } + ], + "imports_other_checkers": false, + "runtime_file_writes": 0, + "scope": "Finite corroboration of block expansion and zero substitutions. The universal grade projection, B-to-A rank argument and all-width faithfulness are written proof obligations, not established by this fixture.", + "status": "PASS_INDEPENDENT_FREEWORD_DIRTY_IDENTITY_BLOCK_EXPANSION", + "untouched_main_column_identities": 36 +} diff --git a/research/two-full-dirty-stability/LICENSE b/research/two-full-dirty-stability/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/two-full-dirty-stability/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-dirty-stability/OVERLAP.json b/research/two-full-dirty-stability/OVERLAP.json new file mode 100644 index 0000000000..0edb966fb5 --- /dev/null +++ b/research/two-full-dirty-stability/OVERLAP.json @@ -0,0 +1,27 @@ +{ + "base_commit": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "checked_at_utc": "2026-10-23T12:20:00Z", + "source_handoff": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4902#discussioncomment-19144315", + "prior_result_4920": "7eb4ef5251f7ba96c7e5d78c42fc98e66b7be4ba", + "prior_result_4928": "6df6ed294614423836cbde182fb4368c9c346fe7", + "bounded_public_checks": [ + { + "query": "repo:CrocSwap/integer-mult-bounds scratch", + "returned": 30 + }, + { + "query": "repo:CrocSwap/integer-mult-bounds two FULL", + "returned": 30 + }, + { + "read": "Discussion4902 last12 comments", + "returned": 2 + }, + { + "read": "PR5160 body/files", + "head": "7800589ce99d932bdb063aafca1f501f1a38626d", + "distinction": "Released coded control/intersection equations and conditional paid-shear allowance; not dirty-identity stabilization." + } + ], + "novelty_scope": "New intermediate-grade decoupling closes the explicit released full-routing identity-scratch question. Bounded primary-source search, not an exhaustive literature or unpublished-work priority guarantee." +} diff --git a/research/two-full-dirty-stability/PROOF.md b/research/two-full-dirty-stability/PROOF.md new file mode 100644 index 0000000000..7d9014022a --- /dev/null +++ b/research/two-full-dirty-stability/PROOF.md @@ -0,0 +1,193 @@ +# Restored identity scratch does not rescue two native FULLs + +This is a scoped obstruction, not a new multiplier, native caller, or kappa +improvement. It extends the full-monomial **two-owner** Fourier-grade theorem +of [PR4920](https://github.com/CrocSwap/integer-mult-bounds/pull/4920) to +arbitrarily many independent dirty scratch owners returned unchanged. The +additional argument uses the intermediate grades, then regular-module rank. +It answers the identity-scratch question released in +[Discussion4902 comment19144315](https://github.com/CrocSwap/integer-mult-bounds/discussions/4902#discussioncomment-19144315). + +The source interface, grade facts, and all-width separation lemma are inherited +from PR4920. The finite regular-module method and the warning against silently +combining different resource scopes are credited to +[PR4928](https://github.com/CrocSwap/integer-mult-bounds/pull/4928). +Native operators and raw phase conventions are credited to the upstream +contributors. The new argument is the forced main/scratch decoupling below. + +## Exact algebra and endpoint + +Let G be a fixed finite-phase, one-column Clifford group on 17 address axes, +Z its scalar subgroup, and H its **full monomial subgroup**, containing Z. +In particular, H includes monomial central/fresh coordinate mixing and +controlled quadratic phases; it is not the separated subgroup in PR4928. +At column width f, let A_f be the central-character twisted group algebra +on G/Z, specializing z=ζI to ζ^f over a characteristic-zero splitting field K. +Let B_f be its subgroup algebra on H/Z. No domain assumption is made. + +Fourier grade is unchanged by left or right monomial multiplication. Thus +projection onto any chosen set of grades is a B_f-bimodule map. Products of +pure words satisfy grade(uv) <= grade(u)+grade(v). These are exactly the grade +facts used by PR4920; scalar cocycles change coefficients, not grades. + +There are two main owners and s>=0 further independent arbitrary dirty +scratch owners. The real native helper jobs remain autonomous, unchanged, +and unavailable for mixing. On these 2+s owners the two calls have form + + T1 = diag(A1,A2,I_s) E_{u,v}(q1), + T2 = diag(B1,B2,I_s) E_{x,y}(q2), + E_{i,j}(q) = I + e_i q e_j^T, + +where {u,v}={x,y}={1,2}. Products act on columns from right to left. +Each Ai and Bi is a pure Clifford group unit of Fourier grade eight, +including the role-dependent raw translations and phases. The query letters +q1,q2 may differ and need not commute with each other or any diagonal factor. +Their signs and inverses are retained. This is the source factor order +`diag(D) E`; no D factor is absorbed into a free control. + +Allow arbitrary L,W,R in GL_{2+s}(B_f). They may mix main and scratch owners, +and their entries may be sums of monomial words, not just pure words or +owner permutations. Suppose + + L T2 W T1 R = J = diag(g1,g2,I_s), + +where each gi is one pure Clifford group word of grade 17, up to arbitrary +monomial boundaries and with its actual phase. We prove this impossible. + +## Intermediate grades force the interstage control to decouple + +Put rho=pi_{1,...,16}. Since rho(J)=0, the bimodule property and invertibility +of L,R imply + + rho(M)=0, where M=T2 W T1. (1) + +This retains the grade-zero scratch endpoint. It does **not** make the +incorrect inference pi_{<=16}(M)=0 while scratch is present. + +Write c=u for the main input column untouched by the first shear, c'=v for +the other main column; write r=y for the main output row untouched by the +second shear, r'=x for the other main row. The four orientations are: + +| First shear | Second shear | Untouched column c | Untouched row r | +| --- | --- | --- | --- | +| E12 | E12 | 1 | 2 | +| E12 | E21 | 1 | 1 | +| E21 | E12 | 2 | 2 | +| E21 | E21 | 2 | 1 | + +For every scratch index a, direct multiplication in the declared order gives + + M[a,c] = W[a,c] A_c, + M[r,a] = B_r W[r,a]. (2) + +Each entry is supported wholly in grade eight: W entries lie in B_f and +monomial multiplication preserves grade. Consequently rho is the identity +on these entries. By (1) they vanish. Ai,Bi are group units, so + + W[a,c]=W[r,a]=0. (3) + +Before using (3), the other two entries are exactly + + M[a,c'] = W[a,c'] A_c' + W[a,c] A_c q1, + M[r',a] = B_r' (W[r',a] + q2 W[r,a]). (4) + +The query terms vanish by (3), without moving a query through any D factor. +The remaining terms are again entirely grade eight, so (1) implies + + W[a,c']=W[r',a]=0. (5) + +Equations (3),(5), for all a, say + + W=diag(Wm,Ws), M=diag(Mm,Ws), + Mm=T2_main Wm T1_main. (6) + +Both Wm and Ws are invertible over B_f. Indeed, multiplying a two-sided +inverse of the block diagonal W on either side gives a two-sided inverse +for each diagonal block. This works for every finite s, including s=0. + +## The scratch block already uses the entire projected rank + +Let Pi=pi_{0,...,16} and P=diag(0,0,I_s). The endpoint equation gives + + Pi(M) = L^-1 P R^-1. (7) + +The right side lies in Mat_{2+s}(B_f). Independently, (1) implies +Pi(Mm)=pi_0(Mm), so the left side of (7) also lies in that matrix algebra. +Thus the following rank comparison is on B_f^{2+s}, rather than an +unjustified restriction of an A_f-valued map to B_f. + +Put d=dim_K(B_f). Act by left multiplication on columns in the right regular +module B_f^{2+s}; its K-dimension is (2+s)d. L and R are invertible on that +space. The right side of (7) therefore has K-rank sd. By (6), its left side is + + diag(Pi(Mm), Ws). + +The invertible Ws block already has rank sd. Rank additivity for this block +diagonal K-linear map forces Pi(Mm) to have rank zero on B_f^2. Left regular +multiplication is faithful: a nonzero entry acts nontrivially on the column +having 1 in its input position. Consequently + + Pi(Mm)=0 (8) + +as an algebra element. This is not an accidental small-width operator +identity, and it does not use an integral-domain or division-ring property. + +## Apply the two-owner zero-column implication + +Use the same c,r as above. Directly, + + Mm[r,c] = B_r Wm[r,c] A_c. + +Every word here has grade at most 8+0+8=16. Hence it is its own Pi projection; +(8) makes it zero and the group-unit factors give Wm[r,c]=0. The other entry +of the same input column is + + Mm[r',c] = B_r' (Wm[r',c] + q2 Wm[r,c]) A_c + = B_r' Wm[r',c] A_c. + +The same grade bound and (8) give Wm[r',c]=0. Thus Wm has a zero column, +contradicting invertibility. This is precisely PR4920's direct zero-column +step. It needs no reduced outer main-only L/R, and presumes no such reduced +matrices invertible. All four shear orientation pairs were retained. + +## Why this is an all-width obstruction + +The argument above holds in A_f for every central character. To pass from +literal tensor operators to A_f, use PR4920/PR4928's separating-polynomial +lemma, recalled here to make the hypothesis explicit. Choose one matrix +representative v_t per projective class G/Z, and put m=|G/Z|. For each t and +u!=t, choose a linear functional that vanishes on v_u and not on v_t. Their +product isolates v_t in degree m-1. Multiplication by powers of a functional +nonzero on v_t extends this to every degree f>=m-1. Applied to tensor powers, +these functionals prove the v_t^{tensor f} linearly independent for every +such f. The central-character tensor representation of A_f is then injective. + +Therefore a literal endpoint at every positive column width would give the +forbidden algebra identity at every sufficiently large width. Coefficients, +controls, query choices, and the finite scratch count may depend on f within +the same fixed finite one-column alphabet. The argument is applied separately +at each sufficiently large f, so width-dependent coefficients do not help. +The finite checker corroborates formulas and grade supports; it does not +replace this all-width proof by a width-one matrix experiment. + +## Exact advance and remaining boundary + +PR4920's full-monomial grade theorem had exactly two owners and explicitly +excluded scratch mixing. PR4928 allowed identity scratch and simultaneously +transformed helper jobs, but only in a separated central/transverse algebra. +Neither result alone establishes this full-monomial identity-scratch extension. +The new ingredient is (2)-(5), forcing decoupling via grades 1 through 16, +followed by the rank budget (7)-(8). + +The theorem includes arbitrary main/scratch owner mixing by L,W,R, all full +monomial central/fresh routes, all shear orientations, role-dependent rank-eight +raw factors, and arbitrary restored identity scratch. It excludes mixing the +productive native helper operations, native prefixes, altered FULLs, additional +paid nonmonomial calls, discarded main-dependent garbage, noninvertible global +owner controls without a reversible restored extension, and non-columnwise or +arbitrary width-specific address operations outside the fixed finite alphabet. +Already transformed helper input/output contracts cannot be replaced by the +identity-scratch contract without justification. + +No new endpoint, invoice improvement, kappa, complete compiler replay, formal +proof-kernel verification, or independent human review is claimed. diff --git a/research/two-full-dirty-stability/README.md b/research/two-full-dirty-stability/README.md new file mode 100644 index 0000000000..1b6bc83713 --- /dev/null +++ b/research/two-full-dirty-stability/README.md @@ -0,0 +1,75 @@ +# Two FULLs remain insufficient with restored dirty identity workspace + +**Scoped written theorem with exact finite corroboration; no new kappa.** +The full-monomial two-owner obstruction in [PR #4920](https://github.com/CrocSwap/integer-mult-bounds/pull/4920) +survives arbitrary finite dirty identity workspace. This answers the explicit +[released stabilization question](https://github.com/CrocSwap/integer-mult-bounds/discussions/4902#discussioncomment-19144315). +It does not improve a paid profile or supply a new multiplier. + +Each of two actual ordered FULL main maps retains its rank-eight diagonal +factors and one triangular query shear. Arbitrary invertible owner controls +over the full monomial Clifford subgroup algebra may mix the main fields and +the workspace, including central/fresh address mixing. Nevertheless the word +cannot return two pure rank-seventeen main jobs and every independent dirty +workspace input unchanged. All four shear orientation pairs are covered; +diagonal factors and query letters need not commute. + +The new step projects onto Fourier grades **1 through 16**, leaving both the +rank-seventeen targets and the grade-zero workspace outside that band. The +untouched row and column force every interstage main/workspace coupling to +vanish. The restored workspace then occupies the full available low-grade +rank, reducing the main block to #4920's zero-column contradiction. +[PROOF.md](PROOF.md) gives the all-width argument and its exact quantifiers. + +The theorem grants arbitrary complex scalar controls, even depending on +width, inside a fixed finite columnwise Clifford alphabet. Source helpers +remain autonomous and unavailable as workspace. Owned-zero COPY/CLEAR +protocols, native prefix observations, changed helpers, additional paid +operations, approximate endpoints and a growing/noncolumnwise address +alphabet require different arguments. Dirty identity workspace must not be +silently substituted for any of those resources. + +## Reproduce + +Use Python 3.12 with its standard library, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/two-full-dirty-stability +``` + +`VERIFY.json` registers normal and optimized scientific commands. Replay is +read-only. The primary checker authenticates its inherited inputs and checks +finite twisted-algebra fixtures; a separately implemented free-word checker +corroborates the noncommutative block formulas for all four orientations and +one, two and three scratch owners. Neither finite suite machine-checks the +universal written proof. `INDEPENDENT-REVIEW.md` is a separate agent review, +not independent human or proof-kernel acceptance. + +The native source/interface and tensor-faithfulness premises are inherited +from the pinned #4920 proof. No native 632-field, compiler, precision, tape, +BIT or outer replay is claimed. Selected conditional kappa remains +0.00302015 at base `a5df48c55ea806d7952b65acc9c76d878ff09b13`. + +## Open next questions + +A useful construction must change the resource: identify one actual saved +nonfree observation, owned-zero protocol, altered native word or different +target invoice, prove its arbitrary-input endpoint and cleanup, then price +every child and independent helper. The present result closes returned +dirty identity scratch in this routing model; it supplies no such changed +construction. `TASK.json` records this stop rule and the remaining gate. + +## Credit + +Chris R / Clear1nsight and the #4920 authors retain the two-owner full-routing +theorem, finite-phase algebra, source interface and tensor-separation argument. +The #4928 authors retain the distinct separated-control retained-helper result +and regular-module rank method. JoyboyBrian's released #4902 handoff states the +stabilization gap. Credit Cinna Davis / 1337isnot1337, Cao Yifan / intqwq, zxv, +Jacob Alan Sussman, Dugongue and the retained native/Clifford/compiler lineage. + +The new intermediate-grade decoupling and stability argument were prepared for +THU New Media Research Center / @thu-nmrc with substantial OpenAI Codex +assistance, including separate algebra and review agents. Apache-2.0. No +general literature-priority, scientific adoption or core-contributor status +is asserted. diff --git a/research/two-full-dirty-stability/RESULT.json b/research/two-full-dirty-stability/RESULT.json new file mode 100644 index 0000000000..2c6393ffbe --- /dev/null +++ b/research/two-full-dirty-stability/RESULT.json @@ -0,0 +1,208 @@ +{ + "actual17_axis_grades": { + "first_raw": 8, + "raw_product": 16, + "second_raw": 8, + "target": 17 + }, + "all_orientation_scratch_cases": [ + { + "first": [ + 1, + 2 + ], + "scratch": 1, + "second": [ + 1, + 2 + ], + "untouched_column": 1, + "untouched_row": 2 + }, + { + "first": [ + 1, + 2 + ], + "scratch": 1, + "second": [ + 2, + 1 + ], + "untouched_column": 1, + "untouched_row": 1 + }, + { + "first": [ + 2, + 1 + ], + "scratch": 1, + "second": [ + 1, + 2 + ], + "untouched_column": 2, + "untouched_row": 2 + }, + { + "first": [ + 2, + 1 + ], + "scratch": 1, + "second": [ + 2, + 1 + ], + "untouched_column": 2, + "untouched_row": 1 + }, + { + "first": [ + 1, + 2 + ], + "scratch": 2, + "second": [ + 1, + 2 + ], + "untouched_column": 1, + "untouched_row": 2 + }, + { + "first": [ + 1, + 2 + ], + "scratch": 2, + "second": [ + 2, + 1 + ], + "untouched_column": 1, + "untouched_row": 1 + }, + { + "first": [ + 2, + 1 + ], + "scratch": 2, + "second": [ + 1, + 2 + ], + "untouched_column": 2, + "untouched_row": 2 + }, + { + "first": [ + 2, + 1 + ], + "scratch": 2, + "second": [ + 2, + 1 + ], + "untouched_column": 2, + "untouched_row": 1 + }, + { + "first": [ + 1, + 2 + ], + "scratch": 3, + "second": [ + 1, + 2 + ], + "untouched_column": 1, + "untouched_row": 2 + }, + { + "first": [ + 1, + 2 + ], + "scratch": 3, + "second": [ + 2, + 1 + ], + "untouched_column": 1, + "untouched_row": 1 + }, + { + "first": [ + 2, + 1 + ], + "scratch": 3, + "second": [ + 1, + 2 + ], + "untouched_column": 2, + "untouched_row": 2 + }, + { + "first": [ + 2, + 1 + ], + "scratch": 3, + "second": [ + 2, + 1 + ], + "untouched_column": 2, + "untouched_row": 1 + } + ], + "all_width_theorem_source": "PROOF.md plus inherited PR4920 tensor-separation lemma", + "arbitrary_s_proved_in_written_argument": true, + "exact_algebra": "sparse projective Clifford group algebra, central character f=1", + "exact_cross_entry_formula_checks": 96, + "finite_fixture_axes": 3, + "finite_fixture_is_universal_proof": false, + "grade_bimodule_fixture_cases": 972, + "independent_checker_sha256": "71f6c9a5d465225b69ced7856fc7d9f7604118a0af38cdae5744f58f881c61b2", + "intermediate_band": [ + 1, + 2 + ], + "matrix_sum_cancellations_used": false, + "native_theorem_band": [ + 1, + 16 + ], + "new_kappa": false, + "new_native_endpoint": false, + "noncommuting_queries": true, + "proof_sha256": "99b3b4233891519fd741ea20cfe985c09bef576a94154e6b146db87f9b857200", + "role_dependent_raw_factors": true, + "source_inputs": [ + { + "commit": "7eb4ef5251f7ba96c7e5d78c42fc98e66b7be4ba", + "path": "research/two-full-central-obstruction/grade/PROOF.md", + "sha256": "8fd775a9903eca0f53b186d7fb684d9f5f74afc9c105082b3d4981bd950fca33" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/two-full-central-obstruction/inputs/native/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } + ], + "source_manifest_sha256": "3af0a739c2335376b977f09e539574fcfcb4fda4702d8451e7c6b6fdb1f672aa", + "status": "PASS_SCOPED_ALGEBRAIC_CORROBORATION", + "transformed_scratch_boundary": { + "cross_grade": 3, + "intermediate_projection_zero": true, + "interstage_cross_nonzero": true, + "scope": "this is a failed proof hypothesis, not a positive endpoint" + } +} diff --git a/research/two-full-dirty-stability/SOURCES.json b/research/two-full-dirty-stability/SOURCES.json new file mode 100644 index 0000000000..2d28e92a57 --- /dev/null +++ b/research/two-full-dirty-stability/SOURCES.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "base_commit": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "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": "research/two-full-central-obstruction/PROOF.md", + "usage": "input", + "git_blob": "66df36c04d0f88018fd640aa095bb55eeacb17e1", + "sha256": "9babe77410543665f197cd1846d71d775d306c97716aedefc6f25f4256f5a699" + }, + { + "path": "research/two-full-central-obstruction/README.md", + "usage": "provenance", + "git_blob": "0b74451d2501318e3c4d1e5d3b4b0de96830d89f", + "sha256": "52663560c13b18547752af243b47693a9c7e76cd3cb7bb86328e609533c5a4e1" + }, + { + "path": "research/two-full-retained-helper-ceiling/README.md", + "usage": "provenance", + "git_blob": "dc4353d52e32cd327ef4cce7152a28a1ada1388e", + "sha256": "9540363e1fba2379ec8ac89216b8865aa838e992d5e2806ead3c4ac398107efa" + }, + { + "path": "research/two-full-central-obstruction/inputs/native/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/two-full-central-obstruction/grade/PROOF.md", + "usage": "input", + "git_blob": "4cdf1e1a29b2113e88513f7a7d983f1e52adb6db", + "sha256": "8fd775a9903eca0f53b186d7fb684d9f5f74afc9c105082b3d4981bd950fca33" + }, + { + "path": "research/two-full-central-obstruction/independent/algebra-REVIEW.md", + "usage": "provenance", + "git_blob": "44ec10ae2587927515cf027c04b6cc5064446e72", + "sha256": "500acba75f4550d5cf393868e14a64657ec602ef14ac008dca54c26cc5b11d96" + } + ] +} diff --git a/research/two-full-dirty-stability/TASK.json b/research/two-full-dirty-stability/TASK.json new file mode 100644 index 0000000000..205ffa6b1b --- /dev/null +++ b/research/two-full-dirty-stability/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "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": "Stabilize the two-FULL full-monomial main-only endpoint obstruction under arbitrarily many returned dirty identity workspace fields.", + "scope_change_reason": "The public Discussion4902 handoff isolates the missing full-monomial plus dirty-workspace case. A middle-Fourier-grade projection forces workspace decoupling and closes that exact case.", + "bottleneck_link": "An optimistic two-FULL main-only invoice passes its raw moment gate; this result rejects its proposed dirty-workspace endpoint before compiler or outer expansion.", + "budget_minutes": 60, + "stop_rule": "Verify the written all-width proof, every shear orientation, source pins and independent finite formulas; stop this dirty-identity free-routing model. Do not classify owned-zero or transformed-helper resources.", + "outcome": "negative-result", + "evidence": "PROOF.md, finite noncommutative block expansion checks, independent agent review and normal/optimized registered replay. No native632, precision/compiler/outer or proof-kernel run.", + "author": "THU New Media Research Center (@thu-nmrc)", + "ai_assistance": "Substantial OpenAI Codex assistance by a lead, algebra agent and a separate reviewer. This is not independent human or proof-kernel review.", + "open_questions": [ + { + "question": "Can a changed producer, a genuinely nonfree saved native observation, or a clean-owned interface complete a profitable main endpoint?", + "why_it_matters": "The proof excludes only invertible free routing with arbitrary returned dirty identity scratch; dependent saved observations and owned-zero protocols are distinct resources.", + "first_step": "Specify one actual arbitrary-input operator and its cleanup, then price every native child and independent helper before widening a search.", + "blocked_by": "No complete profitable changed-resource construction has been established in this package." + } + ] +} diff --git a/research/two-full-dirty-stability/VALIDATION.json b/research/two-full-dirty-stability/VALIDATION.json new file mode 100644 index 0000000000..0cdf1f1142 --- /dev/null +++ b/research/two-full-dirty-stability/VALIDATION.json @@ -0,0 +1,81 @@ +{ + "status": "PASS_PRIVATE_PORTABLE_AND_CORRUPTION_CHECKS", + "python": "3.12.13", + "baseline": [ + { + "entry": "verify.py", + "optimized": false, + "status": "PASS" + }, + { + "entry": "independent_symbolic.py", + "optimized": false, + "status": "PASS" + }, + { + "entry": "verify.py", + "optimized": true, + "status": "PASS" + }, + { + "entry": "independent_symbolic.py", + "optimized": true, + "status": "PASS" + } + ], + "read_only_payload_count": 16, + "no_git_or_path_tools": true, + "controls": [ + { + "fault": "inherited-proof", + "optimized": false, + "status": "REJECTED" + }, + { + "fault": "inherited-proof", + "optimized": true, + "status": "REJECTED" + }, + { + "fault": "inherited-engine", + "optimized": false, + "status": "REJECTED" + }, + { + "fault": "inherited-engine", + "optimized": true, + "status": "REJECTED" + }, + { + "fault": "local-proof", + "optimized": false, + "status": "REJECTED" + }, + { + "fault": "local-proof", + "optimized": true, + "status": "REJECTED" + }, + { + "fault": "primary-receipt", + "optimized": false, + "status": "REJECTED" + }, + { + "fault": "primary-receipt", + "optimized": true, + "status": "REJECTED" + }, + { + "fault": "independent-receipt", + "optimized": false, + "status": "REJECTED" + }, + { + "fault": "independent-receipt", + "optimized": true, + "status": "REJECTED" + } + ], + "scope": "Integrity and finite scientific replay; proof hashes do not machine-check mathematical claims. Four registered commands also passed in the repository. Source-history ancestry unavailable in the shallow clone; no full native/compiler/outer/Lean run." +} diff --git a/research/two-full-dirty-stability/VERIFY.json b/research/two-full-dirty-stability/VERIFY.json new file mode 100644 index 0000000000..b1dfdd789e --- /dev/null +++ b/research/two-full-dirty-stability/VERIFY.json @@ -0,0 +1,63 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/two-full-central-obstruction/PROOF.md", + "research/two-full-central-obstruction/inputs/native/clifford_exact.py", + "research/two-full-central-obstruction/grade/PROOF.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 90, + "checks": "Authenticates inherited full-monomial Clifford/proof inputs and regenerates exact phase-correct sparse group-algebra fixtures, all four shear orientations, workspace-boundary controls and actual17-axis grades. Universal quantifiers remain in the written proof." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 90, + "checks": "Authenticates inherited full-monomial Clifford/proof inputs and regenerates exact phase-correct sparse group-algebra fixtures, all four shear orientations, workspace-boundary controls and actual17-axis grades. Universal quantifiers remain in the written proof." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/independent_symbolic.py" + ], + "timeout_seconds": 90, + "checks": "Separately implemented exact noncommutative free-word block expansion for all four orientations and s=1,2,3; compares the committed independent receipt. Finite corroboration, not an all-width machine proof." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/independent_symbolic.py" + ], + "timeout_seconds": 90, + "checks": "Separately implemented exact noncommutative free-word block expansion for all four orientations and s=1,2,3; compares the committed independent receipt. Finite corroboration, not an all-width machine proof." + } + ] +} diff --git a/research/two-full-dirty-stability/independent_symbolic.py b/research/two-full-dirty-stability/independent_symbolic.py new file mode 100644 index 0000000000..f1775ebf25 --- /dev/null +++ b/research/two-full-dirty-stability/independent_symbolic.py @@ -0,0 +1,191 @@ +#!/usr/bin/env python3 +"""Independent exact free-word expansion for dirty-identity stabilization. + +Standard library only. The default command writes no files and prints a +JSON receipt. This checks polynomial identities, not the all-width theorem, +actual Clifford grades, a physical native caller, or scientific acceptance. +Prepared with substantial OpenAI Codex assistance; Apache-2.0. +""" +import json +from pathlib import Path + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def one(): + return {(): 1} + + +def letter(name): + return {(name,): 1} + + +def plus(*polynomials): + result = {} + for polynomial in polynomials: + for word, coefficient in polynomial.items(): + result[word] = result.get(word, 0) + coefficient + if not result[word]: + del result[word] + return result + + +def times(*polynomials): + result = one() + for polynomial in polynomials: + new = {} + for left, a in result.items(): + for right, b in polynomial.items(): + word = left + right + new[word] = new.get(word, 0) + a*b + result = {word: a for word, a in new.items() if a} + return result + + +def zeros(n): + return [[{} for _ in range(n)] for _ in range(n)] + + +def identity(n): + result = zeros(n) + for i in range(n): + result[i][i] = one() + return result + + +def multiply(a, b): + n = len(a) + return [[plus(*(times(a[i][k], b[k][j]) for k in range(n))) + for j in range(n)] for i in range(n)] + + +def remove_symbols(polynomial, removed): + return {word: a for word, a in polynomial.items() + if not any(symbol in removed for symbol in word)} + + +def remove_from_matrix(matrix, removed): + return [[remove_symbols(p, removed) for p in row] for row in matrix] + + +def native(stage, direction, n): + diagonal = identity(n) + for i in range(2): + diagonal[i][i] = letter(f'D{stage}_{i}') + shear = identity(n) + destination, source = (0, 1) if direction == 'upper' else (1, 0) + shear[destination][source] = letter('a' if stage == 1 else 'b') + return multiply(diagonal, shear) + + +def fixture(first, second, scratch): + n = scratch + 2 + w = [[letter(f'w_{i}_{j}') for j in range(n)] for i in range(n)] + t1 = native(1, first, n) + t2 = native(2, second, n) + body = multiply(multiply(t2, w), t1) + # Untouched column of the first shear; untouched row of the second. + c = 0 if first == 'upper' else 1 + r = 1 if second == 'upper' else 0 + j = 1-c + i = 1-r + row_checks = column_checks = 0 + for z in range(2, n): + first_row = times(letter(f'D2_{r}'), letter(f'w_{r}_{z}')) + need(body[r][z] == first_row, 'Untouched main-to-scratch row') + second_row = plus( + times(letter(f'D2_{i}'), letter(f'w_{i}_{z}')), + times(letter(f'D2_{i}'), letter('b'), letter(f'w_{r}_{z}'))) + need(body[i][z] == second_row, 'Other main-to-scratch row') + need(remove_symbols(body[i][z], {f'w_{r}_{z}'}) == + times(letter(f'D2_{i}'), letter(f'w_{i}_{z}')), + 'First cross-row zero makes second row pure') + first_column = times(letter(f'w_{z}_{c}'), letter(f'D1_{c}')) + need(body[z][c] == first_column, 'Untouched scratch-to-main column') + second_column = plus( + times(letter(f'w_{z}_{j}'), letter(f'D1_{j}')), + times(letter(f'w_{z}_{c}'), letter(f'D1_{c}'), letter('a'))) + need(body[z][j] == second_column, 'Other scratch-to-main column') + need(remove_symbols(body[z][j], {f'w_{z}_{c}'}) == + times(letter(f'w_{z}_{j}'), letter(f'D1_{j}')), + 'First cross-column zero makes second column pure') + row_checks += 3 + column_checks += 3 + removed = {f'w_{i}_{j}' for i in range(n) for j in range(n) + if (i < 2) != (j < 2)} + reduced = remove_from_matrix(body, removed) + for z in range(2, n): + for h in range(2): + need(not reduced[h][z] and not reduced[z][h], + 'All body cross blocks vanish') + for z2 in range(2, n): + need(reduced[z][z2] == w[z][z2], 'Scratch block exactly Wss') + mm = [row[:2] for row in w[:2]] + expected_main = multiply(multiply(native(2, second, 2), mm), + native(1, first, 2)) + need([row[:2] for row in reduced[:2]] == expected_main, + 'Main block is the original two-owner body') + corner = times(letter(f'D2_{r}'), letter(f'w_{r}_{c}'), + letter(f'D1_{c}')) + need(reduced[r][c] == corner, 'Pure untouched main corner') + other = remove_symbols(reduced[i][c], {f'w_{r}_{c}'}) + need(other == times(letter(f'D2_{i}'), letter(f'w_{i}_{c}'), + letter(f'D1_{c}')), + 'Zero first corner makes other entry of input column pure') + zero_column = remove_from_matrix(reduced, {f'w_{r}_{c}', f'w_{i}_{c}'}) + need(not zero_column[0][c] and not zero_column[1][c], + 'Both inferred W zeros remove whole main input column') + # A checker must not silently commute a query past a transverse factor. + wrong_order = times(letter('b'), letter(f'D2_{i}'), + letter(f'w_{r}_2')) + actual_order = times(letter(f'D2_{i}'), letter('b'), + letter(f'w_{r}_2')) + need(wrong_order != actual_order, 'Noncommuting order control') + need(bool(remove_symbols(body[i][2], {f'w_{r}_2'})), + 'Killing only first cross row leaves another nonzero cross entry') + return { + 'first_orientation': first, + 'second_orientation': second, + 'scratch_owners': scratch, + 'untouched_first_column': c, + 'untouched_second_row': r, + 'cross_row_identities': row_checks, + 'cross_column_identities': column_checks, + 'block_diagonal_reduction': True, + 'scratch_block_preserved_exactly': True, + 'untouched_main_column_identities': 3, + 'noncommuting_order_control': True, + 'incomplete_cross_zero_control': True, + } + + +def main(): + fixtures = [fixture(first, second, s) + for first in ('upper', 'lower') + for second in ('upper', 'lower') + for s in (1, 2, 3)] + receipt = { + 'status': 'PASS_INDEPENDENT_FREEWORD_DIRTY_IDENTITY_BLOCK_EXPANSION', + 'arithmetic': 'Exact integer-coefficient noncommutative free words', + 'fixtures': fixtures, + 'fixture_count': len(fixtures), + 'cross_row_identities': sum(x['cross_row_identities'] for x in fixtures), + 'cross_column_identities': sum(x['cross_column_identities'] for x in fixtures), + 'untouched_main_column_identities': 36, + 'runtime_file_writes': 0, + 'imports_other_checkers': False, + 'scope': ('Finite corroboration of block expansion and zero substitutions. ' + 'The universal grade projection, B-to-A rank argument and all-width ' + 'faithfulness are written proof obligations, not established by this fixture.'), + } + # Publication adapter: compare the unchanged independent mathematical receipt. + expected=json.loads(Path(__file__).with_name("INDEPENDENT-SYMBOLIC.json").read_text()) + need(receipt == expected, "Committed independent receipt equality") + print(json.dumps(receipt, indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/two-full-dirty-stability/verify.py b/research/two-full-dirty-stability/verify.py new file mode 100644 index 0000000000..4ab6d5015b --- /dev/null +++ b/research/two-full-dirty-stability/verify.py @@ -0,0 +1,323 @@ +#!/usr/bin/env python3 +"""Exact finite corroboration of the dirty-scratch stability argument. + +Apache-2.0; substantial OpenAI Codex assistance. Default operation is read-only. +The all-width theorem is the written proof, not this three-axis fixture. +""" +from pathlib import Path +from hashlib import sha256 +import argparse +import json +import sys +import types + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCES = ( + ('7eb4ef5251f7ba96c7e5d78c42fc98e66b7be4ba', + 'research/two-full-central-obstruction/grade/PROOF.md', + '8fd775a9903eca0f53b186d7fb684d9f5f74afc9c105082b3d4981bd950fca33'), + ('20bb93cd990d2ff683e4d0fc56b87a42cd5d3296', + 'research/two-full-central-obstruction/inputs/native/clifford_exact.py', + '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962'), +) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def load_sources(): + raw = [] + for commit, path, digest in SOURCES: + data = (ROOT / path).read_bytes() + need(sha256(data).hexdigest() == digest, 'source byte mismatch: ' + path) + raw.append(data) + ce = types.ModuleType('dirty_stability_exact') + sys.modules[ce.__name__] = ce + exec(compile(raw[1], SOURCES[1][1], 'exec'), ce.__dict__) + return ce + + +def ga_add(a, b): + return (a[0] + b[0], a[1] + b[1]) + + +def ga_mul(a, b): + return (a[0]*b[0] - a[1]*b[1], a[0]*b[1] + a[1]*b[0]) + + +class Algebra: + """Sparse projective Clifford group algebra at central character f=1. + + Distinct signed tableaus remain distinct FORMAL basis elements, even if + their one-column matrices are linearly dependent. Exact state vectors + are used only to recover the scalar cocycle between identical tableaus. + Thus a matrix-sum cancellation cannot masquerade as an algebra identity. + """ + def __init__(self, ce, n): + self.ce, self.n = ce, n + self.refs, self.products, self.grades = {}, {}, {} + self.one = self.word(ce.ident(n)) + + def intern(self, op): + key = op.tab + if key not in self.refs: + self.refs[key] = op + self.grades[key] = self.ce.rank([x for x, z, p in op.tab[op.n:]]) + return key, (1, 0) + av, ad = op.zero_state() + bv, bd = self.refs[key].zero_state() + for power, scalar in enumerate(((1, 0), (0, 1), (-1, 0), (0, -1))): + if all((a[0]*(1 << bd), a[1]*(1 << bd)) == + tuple(x*(1 << ad) for x in self.ce.mul_i(b, power)) + for a, b in zip(av, bv)): + return key, scalar + raise ValueError('same tableau had an unexpected absolute phase') + + def word(self, op): + key, phase = self.intern(op) + return {key: phase} + + def add(self, *args): + out = {} + for arg in args: + for key, value in arg.items(): + value = ga_add(out.get(key, (0, 0)), value) + if value == (0, 0): + out.pop(key, None) + else: + out[key] = value + return out + + def scale(self, arg, scalar): + if scalar == (0, 0): + return {} + return {key: ga_mul(value, scalar) for key, value in arg.items()} + + def mul(self, *args): + out = self.one + for arg in args: + nxt = {} + for left, lv in out.items(): + for right, rv in arg.items(): + pair = (left, right) + if pair not in self.products: + # Op.then is chronological: right.then(left) = left*right. + self.products[pair] = self.intern( + self.refs[right].then(self.refs[left])) + key, phase = self.products[pair] + value = ga_mul(ga_mul(lv, rv), phase) + value = ga_add(nxt.get(key, (0, 0)), value) + if value == (0, 0): + nxt.pop(key, None) + else: + nxt[key] = value + out = nxt + return out + + def project(self, arg, lo, hi): + return {key: value for key, value in arg.items() + if lo <= self.grades[key] <= hi} + + def matrix(self, n): + return [[{} for _ in range(n)] for _ in range(n)] + + def ident(self, n): + out = self.matrix(n) + for i in range(n): + out[i][i] = self.one + return out + + def mm(self, *args): + out = args[0] + for arg in args[1:]: + n = len(out) + out = [[self.add(*(self.mul(out[i][k], arg[k][j]) + for k in range(n))) for j in range(n)] + for i in range(n)] + return out + + def call(self, diagonal, dest, src, q): + n = len(diagonal) + shear, diag = self.ident(n), self.matrix(n) + shear[dest][src] = q + for i, entry in enumerate(diagonal): + diag[i][i] = entry + return self.mm(diag, shear) + + +def generate(): + source_manifest = json.loads((HERE / 'SOURCES.json').read_text()) + for row in source_manifest['files']: + if row['usage'] == 'input': + need(sha256((ROOT / row['path']).read_bytes()).hexdigest() == row['sha256'], + 'declared live input byte mismatch: ' + row['path']) + ce = load_sources() + alg = Algebra(ce, 3) + identity = ce.ident(3) + ca, cb, cq = (ce.cgate(3, 1 << i) for i in (1, 2, 0)) + za = ce.diag(3, (2, 1, 0)) # CZ(q,a), actual absolute phase +1 at zero. + zb = ce.diag(3, (4, 0, 1)) # CZ(q,b). + swap = ce.perm(3, (2, 1, 4)) # Full-monomial central/fresh routing. + sq = ce.diag(3, (1, 0, 0)) + xq = ce.xgate(3, 1) + mon_ops = [identity, za, zb, swap, sq, xq] + monos = [alg.word(op) for op in mon_ops] + need(all(alg.project(m, 0, 0) == m for m in monos), 'monomial grades') + + # Keep signs, noncommutation, and role-dependent raw monomial corrections. + aa = [alg.word(ca), alg.word(ca.then(xq))] + bb = [alg.word(cb), alg.word(zb.then(cb))] + q1 = alg.word(za.then(cq).then(za)) + q2 = alg.scale(alg.word(zb.then(cq.adjoint()).then(zb)), (-1, 0)) + need(alg.mul(q1, aa[0]) != alg.mul(aa[0], q1), 'noncommuting first query') + need(alg.mul(q2, bb[0]) != alg.mul(bb[0], q2), 'noncommuting second query') + need(aa[0] != aa[1] and bb[0] != bb[1], 'role-dependent factors') + for entry in aa + bb: + need(alg.project(entry, 1, 1) == entry, 'rank-one raw fixture factor') + + # Corroborate the grade-band bimodule identity on actual mixed words. + samples = [alg.one, *aa, *bb, q1, q2, + alg.mul(bb[0], q2, monos[1], aa[0], q1), + alg.add(alg.one, aa[0], alg.mul(alg.word(cq), aa[0], bb[0]))] + bimodule_cases = 0 + for left in monos: + for right in monos: + for sample in samples: + for lo, hi in ((0, 0), (1, 2), (0, 2)): + need(alg.project(alg.mul(left, sample, right), lo, hi) == + alg.mul(left, alg.project(sample, lo, hi), right), + 'grade-band bimodule fixture') + bimodule_cases += 1 + + orientation_rows = [] + scratch_cross_entries = 0 + for s in (1, 2, 3): + n = 2 + s + for u, v in ((0, 1), (1, 0)): + for x, y in ((0, 1), (1, 0)): + c, cp, r, rp = u, v, y, x + t1 = alg.call(aa + [alg.one]*s, u, v, q1) + t2 = alg.call(bb + [alg.one]*s, x, y, q2) + w = [[alg.add(monos[(i+2*j) % len(monos)], + alg.scale(monos[(2*i+j+1) % len(monos)], (2, 0))) + for j in range(n)] for i in range(n)] + m = alg.mm(t2, w, t1) + for a in range(2, n): + first_col = alg.mul(w[a][c], aa[c]) + first_row = alg.mul(bb[r], w[r][a]) + need(m[a][c] == first_col and m[r][a] == first_row, + 'untouched row/column exact actual-order identity') + for entry in (first_col, first_row): + need(bool(entry) and alg.project(entry, 1, 2) == entry, + 'first cross entries retained by intermediate grades') + need(m[a][cp] == alg.add(alg.mul(w[a][cp], aa[cp]), + alg.mul(w[a][c], aa[c], q1)), 'other input query order') + need(m[rp][a] == alg.mul(bb[rp], alg.add(w[rp][a], + alg.mul(q2, w[r][a]))), 'other output query order') + scratch_cross_entries += 4 + # Apply only the first forced zeros, then check the second step. + wfirst = [[dict(entry) for entry in row] for row in w] + for a in range(2, n): + wfirst[a][c], wfirst[r][a] = {}, {} + mfirst = alg.mm(t2, wfirst, t1) + for a in range(2, n): + left = alg.mul(wfirst[a][cp], aa[cp]) + right = alg.mul(bb[rp], wfirst[rp][a]) + need(mfirst[a][cp] == left and mfirst[rp][a] == right, + 'second cross identities after first zeros') + need(alg.project(left, 1, 2) == left and + alg.project(right, 1, 2) == right, + 'second cross entries retained by intermediate grades') + # Invertible Wm is a product of elementary B-valued shears. + wm1, wm2 = alg.ident(2), alg.ident(2) + wm1[0][1] = alg.add(monos[1], monos[3]) + wm2[1][0] = alg.add(monos[2], alg.scale(monos[4], (0, 1))) + wm = alg.mm(wm1, wm2) + ws = alg.ident(s) + if s > 1: + ws[0][s-1] = alg.add(monos[1], monos[4]) + wblock = alg.matrix(n) + for i in range(2): + for j in range(2): + wblock[i][j] = wm[i][j] + for i in range(s): + for j in range(s): + wblock[i+2][j+2] = ws[i][j] + mblock = alg.mm(t2, wblock, t1) + need(all(not mblock[a][b] and not mblock[b][a] + for a in range(2, n) for b in range(2)), 'block decoupling') + need([row[2:] for row in mblock[2:]] == ws, 'scratch block retained') + need(any(alg.project(mblock[i][j], 0, 2) + for i in range(2) for j in range(2)), + 'invertible main fixture cannot have zero lower-grade block') + orientation_rows.append(dict(scratch=s, first=[u+1, v+1], + second=[x+1, y+1], untouched_column=c+1, untouched_row=r+1)) + + # Discriminating boundary: a productively transformed scratch owner is + # not an identity spectator. The cross entry can have maximal grade and + # be invisible to rho although W[a,c] is nonzero. + t1 = alg.call(aa + [alg.one], 0, 1, q1) + transformed = alg.word(cq.then(cb)) + t2 = alg.call(bb + [transformed], 1, 0, q2) + w = alg.ident(3) + w[2][0] = alg.one + m = alg.mm(t2, w, t1) + need(bool(w[2][0]) and bool(m[2][0]), 'productive scratch boundary nonzero') + need(alg.project(m[2][0], 3, 3) == m[2][0] and + not alg.project(m[2][0], 1, 2), 'productive scratch breaks grade-eight gate') + + # Keep the actual 17-axis thresholds visible, without constructing a + # 2^17 matrix or pretending a three-axis fixture proves the theorem. + def grade(op): + return ce.rank([x for x, z, p in op.tab[op.n:]]) + a17 = ce.fourier(17, range(1, 9)) + b17 = ce.fourier(17, range(9, 17)) + full17 = ce.fourier(17) + need(grade(a17) == grade(b17) == 8 and grade(a17.then(b17)) == 16 + and grade(full17) == 17, 'actual 17-axis threshold fixture') + + return dict(status='PASS_SCOPED_ALGEBRAIC_CORROBORATION', + proof_sha256=sha256((HERE / 'PROOF.md').read_bytes()).hexdigest(), + source_manifest_sha256=sha256((HERE / 'SOURCES.json').read_bytes()).hexdigest(), + independent_checker_sha256=sha256((HERE / 'independent_symbolic.py').read_bytes()).hexdigest(), + source_inputs=[dict(commit=c, path=p, sha256=h) for c, p, h in SOURCES], + exact_algebra='sparse projective Clifford group algebra, central character f=1', + matrix_sum_cancellations_used=False, finite_fixture_axes=3, + intermediate_band=[1, 2], native_theorem_band=[1, 16], + grade_bimodule_fixture_cases=bimodule_cases, + all_orientation_scratch_cases=orientation_rows, + exact_cross_entry_formula_checks=scratch_cross_entries, + noncommuting_queries=True, role_dependent_raw_factors=True, + arbitrary_s_proved_in_written_argument=True, + transformed_scratch_boundary=dict(cross_grade=3, + intermediate_projection_zero=True, interstage_cross_nonzero=True, + scope='this is a failed proof hypothesis, not a positive endpoint'), + actual17_axis_grades=dict(first_raw=8, second_raw=8, + raw_product=16, target=17), + all_width_theorem_source='PROOF.md plus inherited PR4920 tensor-separation lemma', + finite_fixture_is_universal_proof=False, + new_native_endpoint=False, new_kappa=False) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true', help='authoring: replace RESULT.json') + args = parser.parse_args() + result = generate() + path = HERE / 'RESULT.json' + if args.write: + path.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + else: + need(path.exists(), 'RESULT.json missing; author with --write') + need(json.loads(path.read_text()) == result, 'RESULT.json differs from exact replay') + print(json.dumps(dict(status=result['status'], read_only=not args.write, + orientation_scratch_cases=len(result['all_orientation_scratch_cases']), + cross_entry_formula_checks=result['exact_cross_entry_formula_checks'], + new_kappa=False), sort_keys=True)) + + +if __name__ == '__main__': + main() From c5a75152105119a91887a90aad6ed41e191d1d2f Mon Sep 17 00:00:00 2001 From: thu-nmrc Date: Fri, 23 Oct 2026 20:43:41 +0800 Subject: [PATCH 2/3] research: cover joint routing of every native main pair --- .../INDEPENDENT-REVIEW.md | 20 + .../two-full-dirty-stability/MULTIPAIR.json | 586 ++++++++++++++++++ research/two-full-dirty-stability/PROOF.md | 129 ++-- research/two-full-dirty-stability/README.md | 27 +- research/two-full-dirty-stability/RESULT.json | 121 +++- .../two-full-dirty-stability/SOURCES.json | 6 + research/two-full-dirty-stability/TASK.json | 8 +- .../two-full-dirty-stability/VALIDATION.json | 24 +- research/two-full-dirty-stability/VERIFY.json | 25 + .../independent_multipair.py | 234 +++++++ research/two-full-dirty-stability/verify.py | 117 ++++ 11 files changed, 1227 insertions(+), 70 deletions(-) create mode 100644 research/two-full-dirty-stability/MULTIPAIR.json create mode 100644 research/two-full-dirty-stability/independent_multipair.py diff --git a/research/two-full-dirty-stability/INDEPENDENT-REVIEW.md b/research/two-full-dirty-stability/INDEPENDENT-REVIEW.md index 2d1aaf2bf8..fa6693bd9c 100644 --- a/research/two-full-dirty-stability/INDEPENDENT-REVIEW.md +++ b/research/two-full-dirty-stability/INDEPENDENT-REVIEW.md @@ -98,3 +98,23 @@ The review finds no remaining mathematical blocker for the stated dirty-identity ## Final author-proof addendum I read the complete final author `PROOF.md` with SHA256 `99b3b4233891519fd741ea20cfe985c09bef576a94154e6b146db87f9b857200`. Its rank section explicitly uses rho(M)=0 to obtain Pi(Mm)=pi_0(Mm), and also derives Pi(M)=L^-1 P R^-1 in Mat(B). Therefore its regular-module endomorphism rank comparison on B^(s+2) is legitimate. This version resolves the rank-domain concern noted during the earlier draft review; there is no outstanding correction requested on that point. The B-domain to A-codomain argument above is retained as an independent alternative formulation. The final proof also preserves the actual noncommutative factor order, all four shear orientations, full outer mixing, and the stated identity-scratch scope. No new blocker was found on this final read. + +## Final simultaneous-main-bank addendum + +I read the complete repository proof at `/tmp/imb-frontier-20261023/research/two-full-dirty-stability/PROOF.md`, SHA256 `5c9331d51246ec9f3c6aabcb11b25eb6e438a3db4aee15cb61a9d24f55bfdf2f`. This is the final all-m version reviewed here, superseding the earlier two-owner-only author draft pin for the scope of this addendum. **PASS within its stated model:** no new mathematical blocker was found. + +The same proof extends to every m>=1. Let C be the first stage's m untouched main input columns and U the second stage's m untouched main output rows; their complements contain the other m columns/rows. For each scratch index z, the U-to-scratch and scratch-to-C entries are pure grade eight, forcing `W[U,z]=W[z,C]=0`. The remaining cross entries are sums involving exactly those zeros plus a pure grade-eight term, so both complete cross blocks vanish. The prior rank argument then gives `Pi(Mmain)=0`. Its U-by-C corner is entrywise `B_r W[r,c] A_c`, entirely grade at most sixteen, forcing that corner of W to vanish. All other rows in the same C columns then become pure grade-at-most-sixteen terms, so those entire m columns vanish. This contradicts invertibility for any m>=1. + +This direct argument allows different first/second partitions and pairings; it does not require a common port ordering, matching orientation, or commuting query entries. Each stage's disjoint directed pair shears can separately be relabelled by a free owner permutation. The two permutations are absorbed in the already arbitrary L/W/R; diagonal D factors are merely relabelled and retain rank eight. The author proof states the more general arbitrary partitions directly. + +The arbitrary dense `Q1,Q2` blocks over A are a valid relaxation. No decoder or physically realizable query primitive is needed to prove this exclusion: the argument never evaluates the query entries, never commutes them past D, and removes every term containing them by a previously established W zero. Their square-zero off-diagonal block support alone ensures the relaxed shear factors remain units. Granting this larger query class strengthens the exclusion without introducing a positive supplier claim. + +`independent_multipair.py` is a separate standard-library checker that imports no other checker. Its 36 exact noncommutative-freeword fixtures use m=1,2,3, scratch=0,1,2, all four global upper/lower orientation pairs, and genuinely dense independent query-letter matrices. They verify strict zero substitutions, whole cross-block reduction, unchanged Ws, pure untouched m-by-m corners, and whole m-column vanishing. Default execution only reads/compares `MULTIPAIR.json`; explicit `--write` is authoring. Normal and optimized runs pass with byte-identical reported output. The checker source SHA256 is `11a9bbf47358d14754fc48624bccb8a013a0c29212dfd7c16de81d5085c6076b`. The finite fixtures do not establish the universal quantifiers or independently prove actual Clifford grade invariance. + +### Actual 112-port application and retained limits + +The m=112 application is conditional on the inherited, already normalized actual source main interface: a simultaneous bank of 112 disjoint triangular main-pair maps with rank-eight pure Clifford diagonal factors, all represented in the same fixed 17-axis columnwise alphabet. It covers arbitrary joint L/W/R mixing of the full 224 original main owners and any identity dirty workspace. It is not a theorem about arbitrary access to all 632 native fields. + +I additionally inspected the exact pinned predecessor `research/two-full-central-obstruction/independent/native-WRAPPERS.json` from main, Git blob `7d8ae034a093ddf590bd97e43aa548d7d744f18c`, SHA256 `bd3d02645c2bfc1fdb6c44a2484abf7269c26d5514c248168a0fa792c99d30ca`. It contains 112 port records and explicitly states that the 632-field source's helper outputs are autonomous, with its owned centers initialized, erased and uncredited inside each native invocation. Its records retain the per-port raw-D0 translation warning and exact shared-axis phase wrapper scope; no false commutation of raw D0 with central phase is needed in this proof. + +These source records are inherited pins, not a new 632-column native replay. The source wrappers and all nonrecursive costs would still need to be implemented and charged by an actual caller. This obstruction neither consumes nor returns any productive helper as a freely usable state: helper operations remain external, autonomous and unavailable for mixing. A helper-prefix observation, changed producer, changed main target invoice, extra paid nonmonomial operation, noninvertible COPY/DROP/CLEAR controller, or a noncolumnwise/growing address grammar is outside the all-m theorem exactly as it was outside the identity-scratch theorem. No frontier value, selected result, or scientific acceptance is changed by this review. diff --git a/research/two-full-dirty-stability/MULTIPAIR.json b/research/two-full-dirty-stability/MULTIPAIR.json new file mode 100644 index 0000000000..a33135fd8e --- /dev/null +++ b/research/two-full-dirty-stability/MULTIPAIR.json @@ -0,0 +1,586 @@ +{ + "arithmetic": "Exact integer-coefficient noncommutative free words", + "checker_sha256": "11a9bbf47358d14754fc48624bccb8a013a0c29212dfd7c16de81d5085c6076b", + "fixture_count": 36, + "fixtures": [ + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 1, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 1, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 1, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 1, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 4, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 2, + "remaining_main_column_formulas": 1, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 4, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 2, + "remaining_main_column_formulas": 1, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 4, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 2, + "remaining_main_column_formulas": 1, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 4, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 2, + "remaining_main_column_formulas": 1, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 8, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 4, + "remaining_main_column_formulas": 1, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 8, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 4, + "remaining_main_column_formulas": 1, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 8, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 4, + "remaining_main_column_formulas": 1, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 2, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 8, + "noncommuting_order_control": true, + "pairs": 1, + "reduced_cross_formulas": 4, + "remaining_main_column_formulas": 1, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 1, + "whole_W_columns_forced_zero": 1 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 4, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 4, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 4, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 4, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 8, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 4, + "remaining_main_column_formulas": 4, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 8, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 4, + "remaining_main_column_formulas": 4, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 8, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 4, + "remaining_main_column_formulas": 4, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 8, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 4, + "remaining_main_column_formulas": 4, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 16, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 8, + "remaining_main_column_formulas": 4, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 16, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 8, + "remaining_main_column_formulas": 4, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 16, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 8, + "remaining_main_column_formulas": 4, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 8, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 16, + "noncommuting_order_control": true, + "pairs": 2, + "reduced_cross_formulas": 8, + "remaining_main_column_formulas": 4, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 4, + "whole_W_columns_forced_zero": 2 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 9, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 9, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 9, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 0, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 0, + "remaining_main_column_formulas": 9, + "scratch": 0, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 12, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 6, + "remaining_main_column_formulas": 9, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 12, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 6, + "remaining_main_column_formulas": 9, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 12, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 6, + "remaining_main_column_formulas": 9, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 12, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 6, + "remaining_main_column_formulas": 9, + "scratch": 1, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 24, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 12, + "remaining_main_column_formulas": 9, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "upper", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 24, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 12, + "remaining_main_column_formulas": 9, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 24, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 12, + "remaining_main_column_formulas": 9, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "upper", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + }, + { + "dense_query_letters": 18, + "exact_block_diagonal_reduction": true, + "first_orientation": "lower", + "incomplete_corner_zero_control": true, + "initial_cross_formulas": 24, + "noncommuting_order_control": true, + "pairs": 3, + "reduced_cross_formulas": 12, + "remaining_main_column_formulas": 9, + "scratch": 2, + "scratch_block_unchanged": true, + "second_orientation": "lower", + "untouched_main_corner_formulas": 9, + "whole_W_columns_forced_zero": 3 + } + ], + "imports_other_checker": false, + "scope": "Finite polynomial corroboration for m=1,2,3 and s=0,1,2. The written proof supplies arbitrary-m/s quantifiers, Clifford grade invariance, subgroup rank and all-width faithfulness. No physical native endpoint, retained-helper theorem or kappa is established.", + "status": "PASS_INDEPENDENT_DENSE_MULTIPAIR_FREEWORD_EXPANSION" +} diff --git a/research/two-full-dirty-stability/PROOF.md b/research/two-full-dirty-stability/PROOF.md index 7d9014022a..fc8bbd4cfc 100644 --- a/research/two-full-dirty-stability/PROOF.md +++ b/research/two-full-dirty-stability/PROOF.md @@ -1,10 +1,13 @@ -# Restored identity scratch does not rescue two native FULLs +# Identity scratch and joint main-owner routing do not rescue two native FULLs This is a scoped obstruction, not a new multiplier, native caller, or kappa improvement. It extends the full-monomial **two-owner** Fourier-grade theorem of [PR4920](https://github.com/CrocSwap/integer-mult-bounds/pull/4920) to -arbitrarily many independent dirty scratch owners returned unchanged. The -additional argument uses the intermediate grades, then regular-module rank. +arbitrarily many simultaneous main pairs under joint owner control, together +with arbitrarily many independent dirty scratch owners returned unchanged. +In particular, the declared main interface permits joint control of all +224 original main owners in a native 112-pair bank. The additional argument +uses the intermediate grades, regular-module rank, and a zero-column block. It answers the identity-scratch question released in [Discussion4902 comment19144315](https://github.com/CrocSwap/integer-mult-bounds/discussions/4902#discussioncomment-19144315). @@ -13,7 +16,8 @@ from PR4920. The finite regular-module method and the warning against silently combining different resource scopes are credited to [PR4928](https://github.com/CrocSwap/integer-mult-bounds/pull/4928). Native operators and raw phase conventions are credited to the upstream -contributors. The new argument is the forced main/scratch decoupling below. +contributors. The new argument is the forced main/scratch decoupling and its +simultaneous block extension below. ## Exact algebra and endpoint @@ -30,29 +34,46 @@ projection onto any chosen set of grades is a B_f-bimodule map. Products of pure words satisfy grade(uv) <= grade(u)+grade(v). These are exactly the grade facts used by PR4920; scalar cocycles change coefficients, not grades. -There are two main owners and s>=0 further independent arbitrary dirty +There are 2m main owners, m>=1, and s>=0 further independent arbitrary dirty scratch owners. The real native helper jobs remain autonomous, unchanged, -and unavailable for mixing. On these 2+s owners the two calls have form +and unavailable for mixing. On the main index set, choose two partitions - T1 = diag(A1,A2,I_s) E_{u,v}(q1), - T2 = diag(B1,B2,I_s) E_{x,y}(q2), - E_{i,j}(q) = I + e_i q e_j^T, + C disjoint-union Cbar = {1,...,2m}, |C|=|Cbar|=m, + U disjoint-union Ubar = {1,...,2m}, |U|=|Ubar|=m. -where {u,v}={x,y}={1,2}. Products act on columns from right to left. -Each Ai and Bi is a pure Clifford group unit of Fourier grade eight, -including the role-dependent raw translations and phases. The query letters -q1,q2 may differ and need not commute with each other or any diagonal factor. -Their signs and inverses are retained. This is the source factor order -`diag(D) E`; no D factor is absorbed into a free control. +The first stage's query block has destination rows C and source columns Cbar; +the second stage's query block has destination rows Ubar and source columns U. +These two partitions and the pairings within them need not agree. Write -Allow arbitrary L,W,R in GL_{2+s}(B_f). They may mix main and scratch owners, -and their entries may be sums of monomial words, not just pure words or -owner permutations. Suppose + T1 = diag(A1,...,A_(2m),I_s) E1, + T2 = diag(B1,...,B_(2m),I_s) E2, + E1 = I + N1, support(N1) contained in C x Cbar, + E2 = I + N2, support(N2) contained in Ubar x U. - L T2 W T1 R = J = diag(g1,g2,I_s), +Products act on columns from right to left. Each Ai and Bi is a pure Clifford +group unit of Fourier grade eight, including role-dependent raw translations +and phases. The actual disjoint native shears have one query per paired +destination/source. We grant the stronger relaxation in which + + Q1 = (N1)_(C,Cbar), Q2 = (N2)_(Ubar,U) + +are arbitrary m-by-m matrices over A_f. Their entries may differ and need not +commute with each other or any Ai/Bi; signs and inverses are retained. Since +N1^2=N2^2=0, these relaxed shear blocks are still invertible. This is the source +factor order `diag(D) E`; no rank-eight factor is absorbed into a free control. + +Allow arbitrary L,W,R in GL_{2m+s}(B_f). They may jointly mix every main and +scratch owner, including different original ports. Their entries may be sums +of monomial words, not just pure words, pairwise controls, or owner permutations. +Suppose + + L T2 W T1 R = J = diag(g1,...,g_(2m),I_s), where each gi is one pure Clifford group word of grade 17, up to arbitrary -monomial boundaries and with its actual phase. We prove this impossible. +monomial boundaries and with its actual phase. We prove this impossible for +every m>=1 and s>=0. Disjoint native pair shears, with arbitrary orientations +and free port permutations at either stage, satisfy these hypotheses without +having to align their destination/source halves across stages. ## Intermediate grades force the interstage control to decouple @@ -64,9 +85,8 @@ of L,R imply This retains the grade-zero scratch endpoint. It does **not** make the incorrect inference pi_{<=16}(M)=0 while scratch is present. -Write c=u for the main input column untouched by the first shear, c'=v for -the other main column; write r=y for the main output row untouched by the -second shear, r'=x for the other main row. The four orientations are: +The first shear leaves all input columns c in C untouched; the second leaves +all output rows r in U untouched. For m=1 these are exactly the four orientations: | First shear | Second shear | Untouched column c | Untouched row r | | --- | --- | --- | --- | @@ -75,7 +95,7 @@ second shear, r'=x for the other main row. The four orientations are: | E21 | E12 | 2 | 2 | | E21 | E21 | 2 | 1 | -For every scratch index a, direct multiplication in the declared order gives +For every scratch index a, c in C, and r in U, direct multiplication gives M[a,c] = W[a,c] A_c, M[r,a] = B_r W[r,a]. (2) @@ -84,17 +104,17 @@ Each entry is supported wholly in grade eight: W entries lie in B_f and monomial multiplication preserves grade. Consequently rho is the identity on these entries. By (1) they vanish. Ai,Bi are group units, so - W[a,c]=W[r,a]=0. (3) + W[a,C]=0, W[U,a]=0. (3) -Before using (3), the other two entries are exactly +Before using (3), the remaining cross entries, for j in Cbar and i in Ubar, are - M[a,c'] = W[a,c'] A_c' + W[a,c] A_c q1, - M[r',a] = B_r' (W[r',a] + q2 W[r,a]). (4) + M[a,j] = W[a,j] A_j + sum_(c in C) W[a,c] A_c Q1[c,j], + M[i,a] = B_i (W[i,a] + sum_(r in U) Q2[i,r] W[r,a]). (4) The query terms vanish by (3), without moving a query through any D factor. The remaining terms are again entirely grade eight, so (1) implies - W[a,c']=W[r',a]=0. (5) + W[a,Cbar]=0, W[Ubar,a]=0. (5) Equations (3),(5), for all a, say @@ -107,23 +127,23 @@ for each diagonal block. This works for every finite s, including s=0. ## The scratch block already uses the entire projected rank -Let Pi=pi_{0,...,16} and P=diag(0,0,I_s). The endpoint equation gives +Let Pi=pi_{0,...,16} and P=diag(0_(2m),I_s). The endpoint equation gives Pi(M) = L^-1 P R^-1. (7) -The right side lies in Mat_{2+s}(B_f). Independently, (1) implies +The right side lies in Mat_{2m+s}(B_f). Independently, (1) implies Pi(Mm)=pi_0(Mm), so the left side of (7) also lies in that matrix algebra. -Thus the following rank comparison is on B_f^{2+s}, rather than an +Thus the following rank comparison is on B_f^{2m+s}, rather than an unjustified restriction of an A_f-valued map to B_f. Put d=dim_K(B_f). Act by left multiplication on columns in the right regular -module B_f^{2+s}; its K-dimension is (2+s)d. L and R are invertible on that +module B_f^{2m+s}; its K-dimension is (2m+s)d. L and R are invertible on that space. The right side of (7) therefore has K-rank sd. By (6), its left side is diag(Pi(Mm), Ws). The invertible Ws block already has rank sd. Rank additivity for this block -diagonal K-linear map forces Pi(Mm) to have rank zero on B_f^2. Left regular +diagonal K-linear map forces Pi(Mm) to have rank zero on B_f^{2m}. Left regular multiplication is faithful: a nonzero entry acts nontrivially on the column having 1 in its input position. Consequently @@ -132,39 +152,40 @@ having 1 in its input position. Consequently as an algebra element. This is not an accidental small-width operator identity, and it does not use an integral-domain or division-ring property. -## Apply the two-owner zero-column implication +## A whole block of untouched main columns must vanish -Use the same c,r as above. Directly, +For every r in U and c in C, directly, Mm[r,c] = B_r Wm[r,c] A_c. Every word here has grade at most 8+0+8=16. Hence it is its own Pi projection; -(8) makes it zero and the group-unit factors give Wm[r,c]=0. The other entry -of the same input column is +(8) makes it zero and the group-unit factors give Wm[U,C]=0. For i in Ubar, +the other entries of these same input columns are - Mm[r',c] = B_r' (Wm[r',c] + q2 Wm[r,c]) A_c - = B_r' Wm[r',c] A_c. + Mm[i,c] = B_i (Wm[i,c] + sum_(r in U) Q2[i,r] Wm[r,c]) A_c + = B_i Wm[i,c] A_c. -The same grade bound and (8) give Wm[r',c]=0. Thus Wm has a zero column, -contradicting invertibility. This is precisely PR4920's direct zero-column -step. It needs no reduced outer main-only L/R, and presumes no such reduced -matrices invertible. All four shear orientation pairs were retained. +The same grade bound and (8) give Wm[Ubar,C]=0. Thus all m columns indexed +by C vanish in Wm, contradicting invertibility because m>=1. This is the block +extension of PR4920's direct zero-column step. It needs no reduced outer +main-only L/R, presumes no such reduced matrices invertible, and does not +assume matching orientation or pairing between the stages. ## Why this is an all-width obstruction The argument above holds in A_f for every central character. To pass from literal tensor operators to A_f, use PR4920/PR4928's separating-polynomial lemma, recalled here to make the hypothesis explicit. Choose one matrix -representative v_t per projective class G/Z, and put m=|G/Z|. For each t and +representative v_t per projective class G/Z, and put h=|G/Z|. For each t and u!=t, choose a linear functional that vanishes on v_u and not on v_t. Their -product isolates v_t in degree m-1. Multiplication by powers of a functional -nonzero on v_t extends this to every degree f>=m-1. Applied to tensor powers, +product isolates v_t in degree h-1. Multiplication by powers of a functional +nonzero on v_t extends this to every degree f>=h-1. Applied to tensor powers, these functionals prove the v_t^{tensor f} linearly independent for every such f. The central-character tensor representation of A_f is then injective. Therefore a literal endpoint at every positive column width would give the forbidden algebra identity at every sufficiently large width. Coefficients, -controls, query choices, and the finite scratch count may depend on f within +controls, query blocks, and the finite owner counts m,s may depend on f within the same fixed finite one-column alphabet. The argument is applied separately at each sufficiently large f, so width-dependent coefficients do not help. The finite checker corroborates formulas and grade supports; it does not @@ -175,13 +196,17 @@ replace this all-width proof by a width-one matrix experiment. PR4920's full-monomial grade theorem had exactly two owners and explicitly excluded scratch mixing. PR4928 allowed identity scratch and simultaneously transformed helper jobs, but only in a separated central/transverse algebra. -Neither result alone establishes this full-monomial identity-scratch extension. +Neither result alone establishes this full-monomial joint-main-bank and +identity-scratch extension. The new ingredient is (2)-(5), forcing decoupling via grades 1 through 16, -followed by the rank budget (7)-(8). +followed by the rank budget (7)-(8) and the simultaneous zero-column block. The theorem includes arbitrary main/scratch owner mixing by L,W,R, all full -monomial central/fresh routes, all shear orientations, role-dependent rank-eight -raw factors, and arbitrary restored identity scratch. It excludes mixing the +monomial central/fresh routes, all disjoint native shear orientations and +pairings, arbitrary joint mixing of all 2m original main owners, role-dependent +rank-eight raw factors, and arbitrary restored identity scratch. In particular, +m=112 permits joint control of the full 224-main-owner bank under the declared +native main interface. It excludes mixing the productive native helper operations, native prefixes, altered FULLs, additional paid nonmonomial calls, discarded main-dependent garbage, noninvertible global owner controls without a reversible restored extension, and non-columnwise or diff --git a/research/two-full-dirty-stability/README.md b/research/two-full-dirty-stability/README.md index 1b6bc83713..f70a6473c4 100644 --- a/research/two-full-dirty-stability/README.md +++ b/research/two-full-dirty-stability/README.md @@ -2,7 +2,9 @@ **Scoped written theorem with exact finite corroboration; no new kappa.** The full-monomial two-owner obstruction in [PR #4920](https://github.com/CrocSwap/integer-mult-bounds/pull/4920) -survives arbitrary finite dirty identity workspace. This answers the explicit +extends to arbitrarily many jointly routed main pairs and arbitrary finite +dirty identity workspace. In particular it permits all 224 native main owners +to mix across the 112 original ports. This answers the explicit [released stabilization question](https://github.com/CrocSwap/integer-mult-bounds/discussions/4902#discussioncomment-19144315). It does not improve a paid profile or supply a new multiplier. @@ -10,15 +12,18 @@ Each of two actual ordered FULL main maps retains its rank-eight diagonal factors and one triangular query shear. Arbitrary invertible owner controls over the full monomial Clifford subgroup algebra may mix the main fields and the workspace, including central/fresh address mixing. Nevertheless the word -cannot return two pure rank-seventeen main jobs and every independent dirty -workspace input unchanged. All four shear orientation pairs are covered; -diagonal factors and query letters need not commute. +cannot return a pure rank-seventeen job on every main owner and return every +independent dirty workspace input unchanged. The stages may use different +pairings and orientations. The theorem even grants arbitrary noncommuting +query matrices between each stage's two main halves; diagonal factors and +query letters need not commute. The new step projects onto Fourier grades **1 through 16**, leaving both the rank-seventeen targets and the grade-zero workspace outside that band. The untouched row and column force every interstage main/workspace coupling to vanish. The restored workspace then occupies the full available low-grade -rank, reducing the main block to #4920's zero-column contradiction. +rank. A whole half-bank of interstage columns must then vanish, extending +#4920's two-owner zero-column contradiction to joint routing of the full bank. [PROOF.md](PROOF.md) gives the all-width argument and its exact quantifiers. The theorem grants arbitrary complex scalar controls, even depending on @@ -39,10 +44,12 @@ python3.12 -B scripts/research_package.py --package research/two-full-dirty-stab `VERIFY.json` registers normal and optimized scientific commands. Replay is read-only. The primary checker authenticates its inherited inputs and checks -finite twisted-algebra fixtures; a separately implemented free-word checker -corroborates the noncommutative block formulas for all four orientations and -one, two and three scratch owners. Neither finite suite machine-checks the -universal written proof. `INDEPENDENT-REVIEW.md` is a separate agent review, +finite twisted-algebra fixtures, including six joint-bank cases. Two separately +implemented free-word checkers corroborate the noncommutative block formulas, +including 36 cases with one, two or three pairs, zero through two scratch +owners, all four block orientations and dense query matrices. These finite +suites do not machine-check the universal written proof. +`INDEPENDENT-REVIEW.md` is a separate agent review, not independent human or proof-kernel acceptance. The native source/interface and tensor-faithfulness premises are inherited @@ -68,7 +75,7 @@ and regular-module rank method. JoyboyBrian's released #4902 handoff states the stabilization gap. Credit Cinna Davis / 1337isnot1337, Cao Yifan / intqwq, zxv, Jacob Alan Sussman, Dugongue and the retained native/Clifford/compiler lineage. -The new intermediate-grade decoupling and stability argument were prepared for +The new intermediate-grade decoupling, stability and joint-bank argument were prepared for THU New Media Research Center / @thu-nmrc with substantial OpenAI Codex assistance, including separate algebra and review agents. Apache-2.0. No general literature-priority, scientific adoption or core-contributor status diff --git a/research/two-full-dirty-stability/RESULT.json b/research/two-full-dirty-stability/RESULT.json index 2c6393ffbe..125b0787ae 100644 --- a/research/two-full-dirty-stability/RESULT.json +++ b/research/two-full-dirty-stability/RESULT.json @@ -164,6 +164,7 @@ } ], "all_width_theorem_source": "PROOF.md plus inherited PR4920 tensor-separation lemma", + "arbitrary_m_proved_in_written_argument": true, "arbitrary_s_proved_in_written_argument": true, "exact_algebra": "sparse projective Clifford group algebra, central character f=1", "exact_cross_entry_formula_checks": 96, @@ -175,6 +176,122 @@ 1, 2 ], + "joint_main_block_cases": [ + { + "dense_noncommuting_query_blocks": true, + "exact_cross_entry_formulas": 0, + "first_destination_columns": [ + 0, + 1 + ], + "independently_partitioned_stages": true, + "main_owners": 4, + "main_pairs": 2, + "resulting_zero_columns": 2, + "scratch_owners": 0, + "second_source_rows": [ + 0, + 2 + ], + "untouched_corner_entries": 4 + }, + { + "dense_noncommuting_query_blocks": true, + "exact_cross_entry_formulas": 8, + "first_destination_columns": [ + 0, + 1 + ], + "independently_partitioned_stages": true, + "main_owners": 4, + "main_pairs": 2, + "resulting_zero_columns": 2, + "scratch_owners": 1, + "second_source_rows": [ + 0, + 2 + ], + "untouched_corner_entries": 4 + }, + { + "dense_noncommuting_query_blocks": true, + "exact_cross_entry_formulas": 16, + "first_destination_columns": [ + 0, + 1 + ], + "independently_partitioned_stages": true, + "main_owners": 4, + "main_pairs": 2, + "resulting_zero_columns": 2, + "scratch_owners": 2, + "second_source_rows": [ + 0, + 2 + ], + "untouched_corner_entries": 4 + }, + { + "dense_noncommuting_query_blocks": true, + "exact_cross_entry_formulas": 0, + "first_destination_columns": [ + 0, + 1, + 2 + ], + "independently_partitioned_stages": true, + "main_owners": 6, + "main_pairs": 3, + "resulting_zero_columns": 3, + "scratch_owners": 0, + "second_source_rows": [ + 0, + 2, + 4 + ], + "untouched_corner_entries": 9 + }, + { + "dense_noncommuting_query_blocks": true, + "exact_cross_entry_formulas": 12, + "first_destination_columns": [ + 0, + 1, + 2 + ], + "independently_partitioned_stages": true, + "main_owners": 6, + "main_pairs": 3, + "resulting_zero_columns": 3, + "scratch_owners": 1, + "second_source_rows": [ + 0, + 2, + 4 + ], + "untouched_corner_entries": 9 + }, + { + "dense_noncommuting_query_blocks": true, + "exact_cross_entry_formulas": 24, + "first_destination_columns": [ + 0, + 1, + 2 + ], + "independently_partitioned_stages": true, + "main_owners": 6, + "main_pairs": 3, + "resulting_zero_columns": 3, + "scratch_owners": 2, + "second_source_rows": [ + 0, + 2, + 4 + ], + "untouched_corner_entries": 9 + } + ], "matrix_sum_cancellations_used": false, "native_theorem_band": [ 1, @@ -183,7 +300,7 @@ "new_kappa": false, "new_native_endpoint": false, "noncommuting_queries": true, - "proof_sha256": "99b3b4233891519fd741ea20cfe985c09bef576a94154e6b146db87f9b857200", + "proof_sha256": "5c9331d51246ec9f3c6aabcb11b25eb6e438a3db4aee15cb61a9d24f55bfdf2f", "role_dependent_raw_factors": true, "source_inputs": [ { @@ -197,7 +314,7 @@ "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" } ], - "source_manifest_sha256": "3af0a739c2335376b977f09e539574fcfcb4fda4702d8451e7c6b6fdb1f672aa", + "source_manifest_sha256": "ceda04f0fa0f092c6bb045671abb54f75377358cea1c87a95b5155e5b5992676", "status": "PASS_SCOPED_ALGEBRAIC_CORROBORATION", "transformed_scratch_boundary": { "cross_grade": 3, diff --git a/research/two-full-dirty-stability/SOURCES.json b/research/two-full-dirty-stability/SOURCES.json index 2d28e92a57..f219dcd469 100644 --- a/research/two-full-dirty-stability/SOURCES.json +++ b/research/two-full-dirty-stability/SOURCES.json @@ -49,6 +49,12 @@ "usage": "provenance", "git_blob": "44ec10ae2587927515cf027c04b6cc5064446e72", "sha256": "500acba75f4550d5cf393868e14a64657ec602ef14ac008dca54c26cc5b11d96" + }, + { + "path": "research/two-full-central-obstruction/independent/native-WRAPPERS.json", + "usage": "provenance", + "git_blob": "7d8ae034a093ddf590bd97e43aa548d7d744f18c", + "sha256": "bd3d02645c2bfc1fdb6c44a2484abf7269c26d5514c248168a0fa792c99d30ca" } ] } diff --git a/research/two-full-dirty-stability/TASK.json b/research/two-full-dirty-stability/TASK.json index 205ffa6b1b..62ed166007 100644 --- a/research/two-full-dirty-stability/TASK.json +++ b/research/two-full-dirty-stability/TASK.json @@ -46,13 +46,13 @@ ] }, "scope_status": "changed", - "actual_scope": "Stabilize the two-FULL full-monomial main-only endpoint obstruction under arbitrarily many returned dirty identity workspace fields.", - "scope_change_reason": "The public Discussion4902 handoff isolates the missing full-monomial plus dirty-workspace case. A middle-Fourier-grade projection forces workspace decoupling and closes that exact case.", + "actual_scope": "Prove the full-monomial two-FULL endpoint obstruction for arbitrarily many jointly routed native main pairs and arbitrary returned dirty identity workspace, including the whole224-main interface.", + "scope_change_reason": "The released identity-scratch handoff led to an intermediate-grade decoupling theorem. A block version also removes the separate two-main-owner restriction, permitting all112 source pairs to mix jointly while helpers remain autonomous.", "bottleneck_link": "An optimistic two-FULL main-only invoice passes its raw moment gate; this result rejects its proposed dirty-workspace endpoint before compiler or outer expansion.", "budget_minutes": 60, - "stop_rule": "Verify the written all-width proof, every shear orientation, source pins and independent finite formulas; stop this dirty-identity free-routing model. Do not classify owned-zero or transformed-helper resources.", + "stop_rule": "Verify the joint-pair/dirty-identity written theorem, every block orientation, exact input/receipt pins and two independent finite checks. Stop free routing of this main-only two-FULL model; transformed helpers and owned-zero protocols are distinct resources.", "outcome": "negative-result", - "evidence": "PROOF.md, finite noncommutative block expansion checks, independent agent review and normal/optimized registered replay. No native632, precision/compiler/outer or proof-kernel run.", + "evidence": "PROOF.md, phase-correct sparse Clifford-algebra fixtures, separate multipair free-word expansion checks, independent agent review and normal/optimized registered replay. Native632 and compiler/outer/kernel runs remain inherited or unrun.", "author": "THU New Media Research Center (@thu-nmrc)", "ai_assistance": "Substantial OpenAI Codex assistance by a lead, algebra agent and a separate reviewer. This is not independent human or proof-kernel review.", "open_questions": [ diff --git a/research/two-full-dirty-stability/VALIDATION.json b/research/two-full-dirty-stability/VALIDATION.json index 0cdf1f1142..73c3bacefe 100644 --- a/research/two-full-dirty-stability/VALIDATION.json +++ b/research/two-full-dirty-stability/VALIDATION.json @@ -12,6 +12,11 @@ "optimized": false, "status": "PASS" }, + { + "entry": "independent_multipair.py", + "optimized": false, + "status": "PASS" + }, { "entry": "verify.py", "optimized": true, @@ -21,9 +26,14 @@ "entry": "independent_symbolic.py", "optimized": true, "status": "PASS" + }, + { + "entry": "independent_multipair.py", + "optimized": true, + "status": "PASS" } ], - "read_only_payload_count": 16, + "read_only_payload_count": 19, "no_git_or_path_tools": true, "controls": [ { @@ -75,7 +85,17 @@ "fault": "independent-receipt", "optimized": true, "status": "REJECTED" + }, + { + "fault": "multipair-receipt", + "optimized": false, + "status": "REJECTED" + }, + { + "fault": "multipair-receipt", + "optimized": true, + "status": "REJECTED" } ], - "scope": "Integrity and finite scientific replay; proof hashes do not machine-check mathematical claims. Four registered commands also passed in the repository. Source-history ancestry unavailable in the shallow clone; no full native/compiler/outer/Lean run." + "scope": "Final joint-main theorem integrity and finite replay. Proof hashes do not machine-check mathematics. Six registered commands also pass in the repository; source-history ancestry unavailable in shallow clone. No native/compiler/outer/Lean run." } diff --git a/research/two-full-dirty-stability/VERIFY.json b/research/two-full-dirty-stability/VERIFY.json index b1dfdd789e..84560a68ac 100644 --- a/research/two-full-dirty-stability/VERIFY.json +++ b/research/two-full-dirty-stability/VERIFY.json @@ -58,6 +58,31 @@ ], "timeout_seconds": 90, "checks": "Separately implemented exact noncommutative free-word block expansion for all four orientations and s=1,2,3; compares the committed independent receipt. Finite corroboration, not an all-width machine proof." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/independent_multipair.py" + ], + "timeout_seconds": 90, + "checks": "Independent exact dense-query block expansion for m=1,2,3, s=0,1,2 and all four block orientations (36 cases), including whole main-column-block elimination. Compares frozen multipair receipt; no imported checker." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/independent_multipair.py" + ], + "timeout_seconds": 90, + "checks": "Independent exact dense-query block expansion for m=1,2,3, s=0,1,2 and all four block orientations (36 cases), including whole main-column-block elimination. Compares frozen multipair receipt; no imported checker." } ] } diff --git a/research/two-full-dirty-stability/independent_multipair.py b/research/two-full-dirty-stability/independent_multipair.py new file mode 100644 index 0000000000..eee6dd3ef0 --- /dev/null +++ b/research/two-full-dirty-stability/independent_multipair.py @@ -0,0 +1,234 @@ +#!/usr/bin/env python3 +"""Independent dense-query multipair free-word corroboration. + +Default execution is read-only and compares the mathematical receipt with +MULTIPAIR.json. --write is the explicit authoring path. Standard library +only; imports no other checker. This finite polynomial check does not prove +Clifford grade facts, tensor faithfulness, native admission or a new kappa. +Prepared with substantial OpenAI Codex assistance; Apache-2.0. +""" +import argparse +from hashlib import sha256 +import json +from pathlib import Path + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def unit(): + return {(): 1} + + +def atom(name): + return {(name,): 1} + + +def add(*polys): + out = {} + for p in polys: + for w, v in p.items(): + out[w] = out.get(w, 0) + v + if not out[w]: + del out[w] + return out + + +def product(*polys): + out = unit() + for p in polys: + nxt = {} + for a, x in out.items(): + for b, y in p.items(): + w = a+b + nxt[w] = nxt.get(w, 0)+x*y + out = {w: v for w, v in nxt.items() if v} + return out + + +def empty(n): + return [[{} for _ in range(n)] for _ in range(n)] + + +def eye(n): + out = empty(n) + for i in range(n): + out[i][i] = unit() + return out + + +def matmul(a, b): + n = len(a) + return [[add(*(product(a[i][k], b[k][j]) for k in range(n))) + for j in range(n)] for i in range(n)] + + +def without(p, removed): + return {w: a for w, a in p.items() if not any(v in removed for v in w)} + + +def substitute_zero(a, removed): + return [[without(p, removed) for p in row] for row in a] + + +def sets(m, orientation): + low = tuple(range(m)) + high = tuple(range(m, 2*m)) + return (low, high) if orientation == 'upper' else (high, low) + + +def full(stage, m, scratch, orientation): + n = 2*m+scratch + d = eye(n) + for i in range(2*m): + d[i][i] = atom(f'D{stage}_{i}') + e = eye(n) + dest, source = sets(m, orientation) + for i in dest: + for j in source: + e[i][j] = atom(f'Q{stage}_{i}_{j}') + return matmul(d, e) + + +def fixture(m, scratch, first, second): + n = 2*m+scratch + main = tuple(range(2*m)) + work = tuple(range(2*m, n)) + cset, jset = sets(m, first) # untouched input columns; other columns + iset, rset = sets(m, second) # affected output rows; untouched rows + w = [[atom(f'w_{i}_{j}') for j in range(n)] for i in range(n)] + t1 = full(1, m, scratch, first) + t2 = full(2, m, scratch, second) + body = matmul(matmul(t2, w), t1) + cross_initial = cross_reduced = 0 + for z in work: + for r in rset: + need(body[r][z] == product(atom(f'D2_{r}'), atom(f'w_{r}_{z}')), + 'Untouched multipair main-to-scratch row') + cross_initial += 1 + for i in iset: + expected = product(atom(f'D2_{i}'), add( + atom(f'w_{i}_{z}'), + *(product(atom(f'Q2_{i}_{r}'), atom(f'w_{r}_{z}')) for r in rset))) + need(body[i][z] == expected, 'Affected dense-query main-to-scratch row') + removed = {f'w_{r}_{z}' for r in rset} + need(without(body[i][z], removed) == + product(atom(f'D2_{i}'), atom(f'w_{i}_{z}')), + 'All untouched cross rows zero imply affected row pure') + cross_initial += 1 + cross_reduced += 1 + for c in cset: + need(body[z][c] == product(atom(f'w_{z}_{c}'), atom(f'D1_{c}')), + 'Untouched multipair scratch-to-main column') + cross_initial += 1 + for j in jset: + expected = add( + product(atom(f'w_{z}_{j}'), atom(f'D1_{j}')), + *(product(atom(f'w_{z}_{c}'), atom(f'D1_{c}'), + atom(f'Q1_{c}_{j}')) for c in cset)) + need(body[z][j] == expected, 'Affected dense-query scratch-to-main column') + removed = {f'w_{z}_{c}' for c in cset} + need(without(body[z][j], removed) == + product(atom(f'w_{z}_{j}'), atom(f'D1_{j}')), + 'All untouched cross columns zero imply other column pure') + cross_initial += 1 + cross_reduced += 1 + cross_zero = {f'w_{i}_{j}' for i in range(n) for j in range(n) + if (i in main) != (j in main)} + reduced = substitute_zero(body, cross_zero) + for z in work: + for i in main: + need(not reduced[i][z] and not reduced[z][i], 'Whole cross blocks zero') + for z2 in work: + need(reduced[z][z2] == w[z][z2], 'Exact unchanged Ws block') + expected_main = matmul(matmul(full(2, m, 0, second), + [row[:2*m] for row in w[:2*m]]), + full(1, m, 0, first)) + need([row[:2*m] for row in reduced[:2*m]] == expected_main, + 'Main block equals native multipair body') + for r in rset: + for c in cset: + pure = product(atom(f'D2_{r}'), atom(f'w_{r}_{c}'), atom(f'D1_{c}')) + need(reduced[r][c] == pure, 'Whole untouched m-by-m corner pure') + corner_zero = {f'w_{r}_{c}' for r in rset for c in cset} + corner_reduced = substitute_zero(reduced, corner_zero) + for i in iset: + for c in cset: + pure = product(atom(f'D2_{i}'), atom(f'w_{i}_{c}'), atom(f'D1_{c}')) + need(corner_reduced[i][c] == pure, + 'Other m rows in same m columns pure after corner zero') + full_column_zero = corner_zero | {f'w_{i}_{c}' for i in iset for c in cset} + final = substitute_zero(reduced, full_column_zero) + final_w = substitute_zero(w, cross_zero | full_column_zero) + for c in cset: + need(all(not final[i][c] for i in range(n)), 'Whole body m columns zero') + need(all(not final_w[i][c] for i in range(n)), 'Whole W m columns zero') + # Dense Q is genuine: every one of its m*m unrelated letters occurs. + q_letters = {symbol for row in t1+t2 for p in row for word in p for symbol in word + if symbol.startswith('Q')} + need(len(q_letters) == 2*m*m, 'All independent dense query letters present') + # Preserve order instead of commuting Q through rank-eight factors. + i, r, c = iset[0], rset[0], cset[0] + ordered = product(atom(f'D2_{i}'), atom(f'Q2_{i}_{r}'), + atom(f'w_{r}_{c}'), atom(f'D1_{c}')) + wrong = product(atom(f'Q2_{i}_{r}'), atom(f'D2_{i}'), + atom(f'w_{r}_{c}'), atom(f'D1_{c}')) + need(ordered != wrong, 'Noncommuting D/query order control') + # Leave exactly one untouched-corner entry nonzero: its query term remains. + almost = corner_zero - {f'w_{r}_{c}'} + need(next(iter(ordered)) in without(reduced[i][c], almost), + 'Incomplete corner-zero control') + return { + 'pairs': m, + 'scratch': scratch, + 'first_orientation': first, + 'second_orientation': second, + 'dense_query_letters': len(q_letters), + 'initial_cross_formulas': cross_initial, + 'reduced_cross_formulas': cross_reduced, + 'untouched_main_corner_formulas': m*m, + 'remaining_main_column_formulas': m*m, + 'whole_W_columns_forced_zero': m, + 'exact_block_diagonal_reduction': True, + 'scratch_block_unchanged': True, + 'noncommuting_order_control': True, + 'incomplete_corner_zero_control': True, + } + + +def report(): + fixtures = [fixture(m, s, a, b) for m in (1, 2, 3) for s in (0, 1, 2) + for a in ('upper', 'lower') for b in ('upper', 'lower')] + return { + 'status': 'PASS_INDEPENDENT_DENSE_MULTIPAIR_FREEWORD_EXPANSION', + 'checker_sha256': sha256(Path(__file__).read_bytes()).hexdigest(), + 'arithmetic': 'Exact integer-coefficient noncommutative free words', + 'imports_other_checker': False, + 'fixture_count': len(fixtures), + 'fixtures': fixtures, + 'scope': ('Finite polynomial corroboration for m=1,2,3 and s=0,1,2. ' + 'The written proof supplies arbitrary-m/s quantifiers, Clifford grade ' + 'invariance, subgroup rank and all-width faithfulness. No physical ' + 'native endpoint, retained-helper theorem or kappa is established.'), + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true', help='Author the frozen receipt') + args = parser.parse_args() + result = report() + path = Path(__file__).with_name('MULTIPAIR.json') + if args.write: + path.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: + need(path.is_file(), 'Missing frozen MULTIPAIR.json; use --write only for authoring') + need(json.loads(path.read_text()) == result, 'Frozen multipair receipt mismatch') + print(json.dumps({k: v for k, v in result.items() if k != 'fixtures'}, + indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/two-full-dirty-stability/verify.py b/research/two-full-dirty-stability/verify.py index 4ab6d5015b..8d9c416452 100644 --- a/research/two-full-dirty-stability/verify.py +++ b/research/two-full-dirty-stability/verify.py @@ -148,6 +148,118 @@ def call(self, diagonal, dest, src, q): return self.mm(diag, shear) +def block_pair_fixtures(alg, aa, bb, q1, q2, monos): + """Curated joint-owner cases; universal m is proved in PROOF.md. + + Dense noncommuting query blocks grant more than disjoint native pairs. + The two stages have deliberately different destination/source partitions. + """ + cases = [] + for pairs in (2, 3): + main = 2*pairs + cset, cbar = list(range(pairs)), list(range(pairs, main)) + uset, ubar = list(range(0, main, 2)), list(range(1, main, 2)) + av, bv = [aa[i % 2] for i in range(main)], [bb[i % 2] for i in range(main)] + for scratch in (0, 1, 2): + n = main + scratch + d1, d2 = alg.matrix(n), alg.matrix(n) + e1, e2 = alg.ident(n), alg.ident(n) + for i in range(n): + d1[i][i] = av[i] if i < main else alg.one + d2[i][i] = bv[i] if i < main else alg.one + for c in cset: + for j in cbar: + e1[c][j] = alg.mul(monos[(c+j) % len(monos)], q1) + for i in ubar: + for r in uset: + e2[i][r] = alg.mul(q2, monos[(i+2*r) % len(monos)]) + t1, t2 = alg.mm(d1, e1), alg.mm(d2, e2) + w = [[alg.add(monos[(i+2*j) % len(monos)], + alg.scale(monos[(2*i+j+1) % len(monos)], (2, 0))) + for j in range(n)] for i in range(n)] + body = alg.mm(t2, w, t1) + cross_checks = 0 + for a in range(main, n): + for c in cset: + pure = alg.mul(w[a][c], av[c]) + need(body[a][c] == pure and alg.project(pure, 1, 2) == pure, + 'joint-owner untouched input cross identity') + cross_checks += 1 + for r in uset: + pure = alg.mul(bv[r], w[r][a]) + need(body[r][a] == pure and alg.project(pure, 1, 2) == pure, + 'joint-owner untouched output cross identity') + cross_checks += 1 + for j in cbar: + expected = alg.add(alg.mul(w[a][j], av[j]), + *(alg.mul(w[a][c], av[c], e1[c][j]) for c in cset)) + need(body[a][j] == expected, 'joint-owner first dense query order') + cross_checks += 1 + for i in ubar: + expected = alg.mul(bv[i], alg.add(w[i][a], + *(alg.mul(e2[i][r], w[r][a]) for r in uset))) + need(body[i][a] == expected, 'joint-owner second dense query order') + cross_checks += 1 + wfirst = [[dict(entry) for entry in row] for row in w] + for a in range(main, n): + for c in cset: + wfirst[a][c] = {} + for r in uset: + wfirst[r][a] = {} + first = alg.mm(t2, wfirst, t1) + for a in range(main, n): + for j in cbar: + pure = alg.mul(wfirst[a][j], av[j]) + need(first[a][j] == pure and alg.project(pure, 1, 2) == pure, + 'joint-owner remaining input cross after forced zero') + for i in ubar: + pure = alg.mul(bv[i], wfirst[i][a]) + need(first[i][a] == pure and alg.project(pure, 1, 2) == pure, + 'joint-owner remaining output cross after forced zero') + # After both zero steps the scratch block is unchanged. + wblock = [[dict(entry) for entry in row] for row in w] + for a in range(main, n): + for i in range(main): + wblock[a][i], wblock[i][a] = {}, {} + block = alg.mm(t2, wblock, t1) + need(all(not block[a][i] and not block[i][a] + for a in range(main, n) for i in range(main)), + 'joint-owner block decoupling') + need([row[main:] for row in block[main:]] == + [row[main:] for row in wblock[main:]], 'joint-owner scratch block') + for r in uset: + for c in cset: + pure = alg.mul(bv[r], wblock[r][c], av[c]) + need(block[r][c] == pure and alg.project(pure, 0, 2) == pure, + 'joint-owner lower-grade untouched corner block') + # Algebraic consequence of Pi(main)=0: first remove W[U,C], + # then verify all remaining entries in these columns are pure. + wcorner = [[dict(entry) for entry in row] for row in wblock] + for r in uset: + for c in cset: + wcorner[r][c] = {} + corner = alg.mm(t2, wcorner, t1) + for i in ubar: + for c in cset: + pure = alg.mul(bv[i], wcorner[i][c], av[c]) + need(corner[i][c] == pure and alg.project(pure, 0, 2) == pure, + 'joint-owner remaining zero-column block after corner zero') + for i in range(main): + for c in cset: + wcorner[i][c] = {} + zero = alg.mm(t2, wcorner, t1) + need(all(not zero[i][c] for i in range(n) for c in cset), + 'joint-owner whole untouched column block vanishes') + cases.append(dict(main_pairs=pairs, main_owners=main, + scratch_owners=scratch, first_destination_columns=cset, + second_source_rows=uset, independently_partitioned_stages=True, + dense_noncommuting_query_blocks=True, + exact_cross_entry_formulas=cross_checks, + untouched_corner_entries=pairs*pairs, + resulting_zero_columns=pairs)) + return cases + + def generate(): source_manifest = json.loads((HERE / 'SOURCES.json').read_text()) for row in source_manifest['files']: @@ -279,6 +391,8 @@ def grade(op): need(grade(a17) == grade(b17) == 8 and grade(a17.then(b17)) == 16 and grade(full17) == 17, 'actual 17-axis threshold fixture') + joint_blocks = block_pair_fixtures(alg, aa, bb, q1, q2, monos) + return dict(status='PASS_SCOPED_ALGEBRAIC_CORROBORATION', proof_sha256=sha256((HERE / 'PROOF.md').read_bytes()).hexdigest(), source_manifest_sha256=sha256((HERE / 'SOURCES.json').read_bytes()).hexdigest(), @@ -289,6 +403,8 @@ def grade(op): intermediate_band=[1, 2], native_theorem_band=[1, 16], grade_bimodule_fixture_cases=bimodule_cases, all_orientation_scratch_cases=orientation_rows, + joint_main_block_cases=joint_blocks, + arbitrary_m_proved_in_written_argument=True, exact_cross_entry_formula_checks=scratch_cross_entries, noncommuting_queries=True, role_dependent_raw_factors=True, arbitrary_s_proved_in_written_argument=True, @@ -315,6 +431,7 @@ def main(): need(json.loads(path.read_text()) == result, 'RESULT.json differs from exact replay') print(json.dumps(dict(status=result['status'], read_only=not args.write, orientation_scratch_cases=len(result['all_orientation_scratch_cases']), + joint_main_block_cases=len(result['joint_main_block_cases']), cross_entry_formula_checks=result['exact_cross_entry_formula_checks'], new_kappa=False), sort_keys=True)) From 40bb94aebbf591a99e2f48533f16efe8914fb1e2 Mon Sep 17 00:00:00 2001 From: thu-nmrc Date: Fri, 23 Oct 2026 20:44:23 +0800 Subject: [PATCH 3/3] research: name the exact retained compiler provenance path --- research/two-full-dirty-stability/RESULT.json | 2 +- research/two-full-dirty-stability/verify.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/research/two-full-dirty-stability/RESULT.json b/research/two-full-dirty-stability/RESULT.json index 125b0787ae..ecf2d4cada 100644 --- a/research/two-full-dirty-stability/RESULT.json +++ b/research/two-full-dirty-stability/RESULT.json @@ -309,7 +309,7 @@ "sha256": "8fd775a9903eca0f53b186d7fb684d9f5f74afc9c105082b3d4981bd950fca33" }, { - "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "commit": "7eb4ef5251f7ba96c7e5d78c42fc98e66b7be4ba", "path": "research/two-full-central-obstruction/inputs/native/clifford_exact.py", "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" } diff --git a/research/two-full-dirty-stability/verify.py b/research/two-full-dirty-stability/verify.py index 8d9c416452..99efc23f94 100644 --- a/research/two-full-dirty-stability/verify.py +++ b/research/two-full-dirty-stability/verify.py @@ -17,7 +17,7 @@ ('7eb4ef5251f7ba96c7e5d78c42fc98e66b7be4ba', 'research/two-full-central-obstruction/grade/PROOF.md', '8fd775a9903eca0f53b186d7fb684d9f5f74afc9c105082b3d4981bd950fca33'), - ('20bb93cd990d2ff683e4d0fc56b87a42cd5d3296', + ('7eb4ef5251f7ba96c7e5d78c42fc98e66b7be4ba', 'research/two-full-central-obstruction/inputs/native/clifford_exact.py', '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962'), )