diff --git a/research/chart595-factor-seven-audit/CREDITS.md b/research/chart595-factor-seven-audit/CREDITS.md new file mode 100644 index 0000000000..a50ffe99df --- /dev/null +++ b/research/chart595-factor-seven-audit/CREDITS.md @@ -0,0 +1,24 @@ +# Source credit + +Prepared by Ali Romman (@aliromman) with substantial OpenAI Codex assistance. +New audit code and prose are Apache-2.0. The copied graph and notice retain +the source credit. ORIGINS.json pins their exact bytes. + +Clear1nsight supplied the graph, reported minimum grids and physical argument +in [PR #7697](https://github.com/CrocSwap/integer-mult-bounds/pull/7697), +[pinned physical proof](https://github.com/Clear1nsight/integer-mult-bounds/blob/f55fc1434436ffa1c6d064a29fc56812044b3157/research/p104-banked-chart595-split/PHYSICAL.md) +and [pinned grid checker](https://github.com/Clear1nsight/integer-mult-bounds/blob/f55fc1434436ffa1c6d064a29fc56812044b3157/research/p104-banked-chart595-split/physical.py). +Those grid figures are confirmed, not newly discovered. The source notice +credits Ali Romman's helper bases and banked pivots, SYLforge's signed caller, +DreamingOfClouds and Rohan Arun's native/caller lineage, and Jerry Chen's +selected framework application. No further individual identity is inferred. + +Ali Romman's [PR #7680](https://github.com/CrocSwap/integer-mult-bounds/pull/7680), +[pinned proof](https://github.com/aliromman/integer-mult-bounds/blob/533cdca9225d1c0af1ae8d3b79cb527f59afaf0f/research/banked-native-minimum-grid/PROOF.md), +supplied the product-versus-snapshot grid distinction, gcd proof and separate +rational basis controls on the earlier graph. The present audit adapts that +method to the changed exact source. It is not blind review. No source verifier +is copied or imported. + +The new support census and its two-owner necessity witnesses are source-bound +audit evidence. They do not change another contributor's construction or claim. diff --git a/research/chart595-factor-seven-audit/LICENSE b/research/chart595-factor-seven-audit/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/chart595-factor-seven-audit/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/chart595-factor-seven-audit/ORIGINS.json b/research/chart595-factor-seven-audit/ORIGINS.json new file mode 100644 index 0000000000..5d5858242a --- /dev/null +++ b/research/chart595-factor-seven-audit/ORIGINS.json @@ -0,0 +1,16 @@ +{ + "inputs/CANDIDATE-GRAPH.json.gz": { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "f55fc1434436ffa1c6d064a29fc56812044b3157", + "path": "research/p104-banked-chart595-split/data/CANDIDATE-GRAPH.json.gz", + "git_blob": "8c23cc1422da15d1fd23b1194642a9c541afea09", + "sha256": "789c51223158f816b4046321e28449e1db540d20b75ce57e0699a20706bc3510" + }, + "inputs/SOURCE-NOTICE": { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "f55fc1434436ffa1c6d064a29fc56812044b3157", + "path": "research/p104-banked-chart595-split/NOTICE", + "git_blob": "94054844262e921d306ae2aff4a023bb5dc8e62f", + "sha256": "5b6226956ac93b15d88b95aaabb40d80f912f97a52ffea2a7068fd3c7074b179" + } +} diff --git a/research/chart595-factor-seven-audit/PROOF.md b/research/chart595-factor-seven-audit/PROOF.md new file mode 100644 index 0000000000..1354f2766e --- /dev/null +++ b/research/chart595-factor-seven-audit/PROOF.md @@ -0,0 +1,86 @@ +# The two-factor-seven obligation on the fixed chart-595 word + +This is an independent scalar audit of PR #7697 at +`f55fc1434436ffa1c6d064a29fc56812044b3157`. The normalized graph has decoded +SHA-256 `d5dab11bb773bf5beb8ae2998be1282b243e2d1606c5257896a037c9b52c5c3b`. +The result confirms its reported grid values. It also identifies every input +column that needs two factors of seven in a literal scalar product. + +## Contract and result + +Each of the 1502 entrances is an independent scalar. For a row v, use the +literal donor order in the graph and compute each product q times donor value +before its addition. Paid chart operations preserve the normalized coefficient +vector; their physical Clifford factors are outside this audit. Use one integer +scale G for entrance coefficients, products, addition prefixes and stored rows. + +The least positive scale is `G = 45158400 = 2^12 * 3^2 * 5^2 * 7^2`. +The least scale for complete stored rows alone is +`S = 161280 = 2^9 * 3^2 * 5 * 7`. These are prior figures from the source. +There are 8738317 nonzero products in the independent-input expansion. +Exactly 630 products have a reduced denominator divisible by 49. They occur +in 40 rows: 60 in input column 281, and 570 in input column 1501. No other +input column needs 49. RESULT.json lists all 40 rows and their counts. + +Thus both split owners are necessary to test the new two-factor obligation. +A check that uses only other basis inputs cannot see it. This is a scalar +support statement; it is not an assertion about a physical rank or a new +paid/target invoice. + +## Sufficiency and minimality + +Let a(v,i) be the rational coefficient of entrance i in row v. The graph is +acyclic in its literal schedule. Entrance donor `~i` has coefficient one in +column i and zero elsewhere. At each next row, the checker forms every +`q * a(donor,i)`, then adds the products in the stated order. It executes +integer multiplication and exact division at G. Every division has zero +remainder. Therefore every product and every addition prefix is on the grid. +The complete vector is retained for the next row. + +For any finite rational coefficient set A and an integer G that clears A, +the least common denominator is +`G / gcd(G, {G*a : a in A})`. Apply this once to all products and once to all +complete stored coefficients. Integer addition introduces no new denominator. +The two gcds give G and S as stated. Necessity follows by setting one entrance +to one and all others to zero. Arbitrary integer entrance values are covered +by linearity. Multiplication by an external common dyadic input grid preserves +this scalar conclusion. + +Separate Fraction replays compute one input column at a time. They do not +consume the integer replay vectors or its gcd state. These replays give the +following product witnesses for each maximal prime exponent: + +| Prime power | Row | Donor | Input | Scalar | Donor value | Product | +| --- | ---: | ---: | ---: | --- | --- | --- | +| 4096 | 103161 | 88788 | 265 | 1/8 | 3/512 | 3/4096 | +| 9 | 99762 | 92704 | 1296 | 94/3 | 41/384 | 1927/576 | +| 25 | 96681 | 90728 | 1226 | -4/5 | 1/5 | -4/25 | +| 49 | 93859 | 87424 | 281 | -2/7 | -40/21 | 80/147 | + +The last product explains why a row grid with only one factor of seven fails. +It is an actual pair of literal operations, not an estimate from path +length. The receipt also gives a separate first witness for fresh input 1501. +The checker rejects G divided by each of 2, 3, 5 and 7, using the respective +basis inputs. It also rejects S on each of the two split-owner inputs. +All six controls stop at their first nonzero division remainder. + +## Interpretation and limits + +This confirms the scalar precision sub-obligation requested in the chart-595 +handoff. It does not establish the physical chart maps, root divisibility at +all column multiplicities, arbitrary dirty state, the early public return, +complete tape work, compiler funding or outer inequalities. It does not +reduce the source's conservative path grid or replace a provider. The complete +kappa is unchanged. All five selected assumptions remain. + +The source's reported minimum values and its gcd method are credited. This +checker is separately written and imports no source verifier. The graph is +copied without change. Independent human review and formal-kernel acceptance +are not claimed. + +## Open next questions + +Can one accumulate integer row numerators and divide only after the complete +row? That contract can avoid off-grid temporary products, but it needs a +numerator-width bound, an exact division proof and a complete physical bill. +The present literal-product result does not prove that changed implementation. diff --git a/research/chart595-factor-seven-audit/README.md b/research/chart595-factor-seven-audit/README.md new file mode 100644 index 0000000000..325b2e0cb6 --- /dev/null +++ b/research/chart595-factor-seven-audit/README.md @@ -0,0 +1,32 @@ +# Independent chart-595 factor-seven audit + +The fixed PR #7697 graph needs scale 45158400 for its literal products and +161280 for its complete stored rows. This audit confirms those reported +values without importing the source verifier. All 630 products that need a +factor of 49 occur in only two independent input columns, the split owners +281 and 1501. The first old-owner witness is `(-2/7)*(-40/21) = 80/147`. + +Read [the proof](PROOF.md), [the receipt](RESULT.json), +[the checker](verify.py) and [source credit](CREDITS.md). + +With CPython 3.12 and its standard library, from the repository root: + +```sh +python3.12 -I -W error -B research/chart595-factor-seven-audit/verify.py +python3.12 -B scripts/research_package.py --package research/chart595-factor-seven-audit +``` + +Expected: `PASS_CHART595_FACTOR_SEVEN_AUDIT`, then +`PASS_REGISTERED_RESEARCH_PACKAGE` for the registered command. + +The complete 8738317-product replay, separate rational basis witnesses and +six under-grid controls check the normalized scalar contract. This is an +independent numerical audit, not complete supplier admission. No new kappa +or selected-assumption discharge is claimed. Full candidate and selected +replays, physical Clifford/root checks, Lean and Docker were not run. + +## Open next questions + +Check a row-atomic integer accumulator at the stored-row scale, with all +numerator widths and physical costs included. This changes the operation +contract and is not established by the present audit. diff --git a/research/chart595-factor-seven-audit/RESULT.json b/research/chart595-factor-seven-audit/RESULT.json new file mode 100644 index 0000000000..5a4b182336 --- /dev/null +++ b/research/chart595-factor-seven-audit/RESULT.json @@ -0,0 +1,291 @@ +{ + "products": 8738317, + "minimum_product_grid": 45158400, + "minimum_snapshot_grid": 161280, + "prime_witnesses": { + "3": { + "row": 99762, + "donor": 92704, + "column": 1296, + "scalar": "94/3", + "donor_value": "41/384", + "product": "1927/576", + "exponent": 2 + }, + "2": { + "row": 103161, + "donor": 88788, + "column": 265, + "scalar": "1/8", + "donor_value": "3/512", + "product": "3/4096", + "exponent": 12 + }, + "7": { + "row": 93859, + "donor": 87424, + "column": 281, + "scalar": "-2/7", + "donor_value": "-40/21", + "product": "80/147", + "exponent": 2 + }, + "5": { + "row": 96681, + "donor": 90728, + "column": 1226, + "scalar": "-4/5", + "donor_value": "1/5", + "product": "-4/25", + "exponent": 2 + } + }, + "seven_squared_columns": [ + [ + 281, + 60 + ], + [ + 1501, + 570 + ] + ], + "seven_squared_rows": [ + [ + 93859, + 6 + ], + [ + 96158, + 6 + ], + [ + 96162, + 6 + ], + [ + 96302, + 6 + ], + [ + 96335, + 6 + ], + [ + 97328, + 6 + ], + [ + 97329, + 6 + ], + [ + 98085, + 6 + ], + [ + 98090, + 6 + ], + [ + 102698, + 6 + ], + [ + 150918, + 19 + ], + [ + 150919, + 19 + ], + [ + 150939, + 19 + ], + [ + 150941, + 19 + ], + [ + 150952, + 19 + ], + [ + 150964, + 19 + ], + [ + 151001, + 19 + ], + [ + 151100, + 19 + ], + [ + 151102, + 19 + ], + [ + 151103, + 19 + ], + [ + 151194, + 19 + ], + [ + 151201, + 19 + ], + [ + 151202, + 19 + ], + [ + 151529, + 19 + ], + [ + 151561, + 19 + ], + [ + 151617, + 19 + ], + [ + 151697, + 19 + ], + [ + 151698, + 19 + ], + [ + 151703, + 19 + ], + [ + 151738, + 19 + ], + [ + 151756, + 19 + ], + [ + 151765, + 19 + ], + [ + 151767, + 19 + ], + [ + 151785, + 19 + ], + [ + 151795, + 19 + ], + [ + 151828, + 19 + ], + [ + 151839, + 19 + ], + [ + 151865, + 19 + ], + [ + 151971, + 19 + ], + [ + 151995, + 19 + ] + ], + "seven_witnesses": { + "281": { + "row": 93859, + "donor": 87424, + "column": 281, + "scalar": "-2/7", + "donor_value": "-40/21", + "product": "80/147" + }, + "1501": { + "row": 150918, + "donor": 97328, + "column": 1501, + "scalar": "1/7", + "donor_value": "-40/21", + "product": "-40/147" + } + }, + "row_trace_sha256": "b3000ecf8e1eb408010289bbe8708cb93706ac7b2ba14a86edfb319f2c61e60a", + "under_grid_controls": [ + { + "row": 99762, + "donor": 92704, + "column": 1296, + "grid": 15052800, + "scalar": "94/3", + "divisor": 3, + "remainder": 1 + }, + { + "row": 103161, + "donor": 88788, + "column": 265, + "grid": 22579200, + "scalar": "1/8", + "divisor": 8, + "remainder": 4 + }, + { + "row": 93859, + "donor": 87424, + "column": 281, + "grid": 6451200, + "scalar": "-2/7", + "divisor": 7, + "remainder": 1 + }, + { + "row": 96681, + "donor": 90728, + "column": 1226, + "grid": 9031680, + "scalar": "-4/5", + "divisor": 5, + "remainder": 1 + }, + { + "row": 93859, + "donor": 87424, + "column": 281, + "grid": 161280, + "scalar": "-2/7", + "divisor": 7, + "remainder": 3 + }, + { + "row": 150918, + "donor": 97328, + "column": 1501, + "grid": 161280, + "scalar": "1/7", + "divisor": 7, + "remainder": 2 + } + ], + "scope": "Normalized scalar products and complete snapshots of the fixed graph only." +} diff --git a/research/chart595-factor-seven-audit/SOURCES.json b/research/chart595-factor-seven-audit/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/chart595-factor-seven-audit/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/chart595-factor-seven-audit/TASK.json b/research/chart595-factor-seven-audit/TASK.json new file mode 100644 index 0000000000..3361e9dc42 --- /dev/null +++ b/research/chart595-factor-seven-audit/TASK.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Independently certify the fixed PR7697 normalized scalar grid and localize every product that requires two factors of seven.", + "scope_change_reason": "The live chart-595 handoff asks for an independent check of its new divisions. This checks that finite sub-obligation; it is not an all-size assumption discharge.", + "bottleneck_link": "A stored-row grid can conceal illegal literal divisions. A source-bound product witness isolates that failure before a physical/root substitution.", + "budget_minutes": 60, + "stop_rule": "Stop after the exact scalar replay and separate rational witnesses. Do not change the split, its invoice or selected frontier.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; independent complete scalar replay; six separate rational witnesses and six under-grid controls.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance. The exact graph is reused and attributed; the audit does not import its verifier.", + "open_questions": [ + { + "question": "Can a row-atomic integer accumulator use the stored-row grid while it defers division?", + "why_it_matters": "This changes the literal product contract and can remove the extra factor of seven from stored precision.", + "first_step": "Bound all row numerators and check every exact final division on the same graph.", + "blocked_by": "A physical implementation, accumulator width and complete ordinary charge must be supplied." + } + ] +} diff --git a/research/chart595-factor-seven-audit/VERIFY.json b/research/chart595-factor-seven-audit/VERIFY.json new file mode 100644 index 0000000000..1086feb57e --- /dev/null +++ b/research/chart595-factor-seven-audit/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Authenticate the fixed graph; replay all scalar coefficients; check sharp grid witnesses with separate rational arithmetic and reject six under-grid inputs." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Authenticate the fixed graph; replay all scalar coefficients; check sharp grid witnesses with separate rational arithmetic and reject six under-grid inputs." + } + ] +} diff --git a/research/chart595-factor-seven-audit/inputs/CANDIDATE-GRAPH.json.gz b/research/chart595-factor-seven-audit/inputs/CANDIDATE-GRAPH.json.gz new file mode 100644 index 0000000000..8c23cc1422 Binary files /dev/null and b/research/chart595-factor-seven-audit/inputs/CANDIDATE-GRAPH.json.gz differ diff --git a/research/chart595-factor-seven-audit/inputs/SOURCE-NOTICE b/research/chart595-factor-seven-audit/inputs/SOURCE-NOTICE new file mode 100644 index 0000000000..9405484426 --- /dev/null +++ b/research/chart595-factor-seven-audit/inputs/SOURCE-NOTICE @@ -0,0 +1,7 @@ +Apache License 2.0. Research prepared for Clear1nsight with substantial OpenAI Codex and ChatGPT Pro assistance. + +The chart-595 cut, arbitrary-helper encoder and decoder, exact changed graph and matched application are the contribution. Ali Romman supplied the joint helper-basis mechanism and the fifteen banked transfer pivots of PR #7674. Clear1nsight supplied the role-230 rechart and its paired chart graph in PR #7682. SYLforge supplied the signed sixteen-call caller and the preceding exact native source in PR #7669. DreamingOfClouds and Rohan Arun supplied retained native and signed-caller lineage. Jerry Chen (CubeJerry) supplied the selected #7000 and #7001 framework applications. Douglas Colkitt and the credited authors supplied the inherited operator engines, power evaluator, compiler and package infrastructure. + +The exact predecessor notices and inherited source attributions are in `credits/`. `ASSETS.json` binds the borrowed bytes and the reconstructed inputs. Direct reuse is identified against its exact published path when the bytes are present at that head. The physical guide and exact-grid approach also draw on Ali Romman's #7663, #7666, #7670 and #7674. The selected applications and earlier #5599 helper split remain separately credited in the proof. + +The branch carries ToikY's existing workflow bridge at `0eabc624a9bc9ed2847719efd63390db4d297df4` above canonical `e54523517d0f03e58352e647c403a5af3e525a57`. Its five changed blobs are Clear1nsight's #7257 guide and historical source repair and preserve the earlier published credit. The workflow commit is separate from the scientific package. diff --git a/research/chart595-factor-seven-audit/verify.py b/research/chart595-factor-seven-audit/verify.py new file mode 100644 index 0000000000..09bc0de0fe --- /dev/null +++ b/research/chart595-factor-seven-audit/verify.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Check the fixed chart-595 scalar grid and its factor-seven witnesses.""" + +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +import gzip +import json +from math import gcd +from pathlib import Path + +HERE = Path(__file__).resolve().parent +GRAPH_HASH = 'd5dab11bb773bf5beb8ae2998be1282b243e2d1606c5257896a037c9b52c5c3b' +GRID = 45158400 + + +def require(test, message): + if not test: + raise ValueError(message) + + +def load(): + for name, pin in json.loads((HERE / 'ORIGINS.json').read_text()).items(): + require(sha256((HERE / name).read_bytes()).hexdigest() == pin['sha256'], name) + raw = gzip.decompress((HERE / 'inputs/CANDIDATE-GRAPH.json.gz').read_bytes()) + require(sha256(raw).hexdigest() == GRAPH_HASH, 'decoded graph') + graph = json.loads(raw) + rows = {k: [(d, Fraction(q)) for d, q in terms] for k, terms in graph['forms']} + require(len(rows) == len(graph['forms']) == len(graph['schedule']) == 7644, + 'complete row inventory') + require(set(rows) == set(graph['schedule']), 'unique schedule') + require(len(graph['initial']) == len(graph['final']) == 1502, 'public owners') + require(len(graph['moves']) == 6142, 'paid moves') + return graph, rows + + +def valuation(number, prime): + power = 0 + while number % prime == 0: + number //= prime + power += 1 + return power + + +def basis_replay(graph, rows): + values = {~i: {i: GRID} for i in range(1502)} + product_gcd = row_gcd = GRID + products = 0 + prime_witnesses = {} + seven_columns = Counter() + seven_rows = Counter() + seven_witnesses = {} + trace = sha256() + for key in graph['schedule']: + total = {} + for donor, q in rows[key]: + require(donor in values, 'future read') + for column, value in values[donor].items(): + product, remainder = divmod(value * q.numerator, q.denominator) + require(remainder == 0, 'nonintegral literal product') + products += 1 + product_gcd = gcd(product_gcd, product) + denominator = GRID // gcd(GRID, product) + witness = None + for prime in (2, 3, 5, 7): + exponent = valuation(denominator, prime) + if exponent > prime_witnesses.get(prime, {}).get('exponent', 0): + witness = {'row': key, 'donor': donor, 'column': column, + 'scalar': str(q), 'donor_value': str(Fraction(value, GRID)), + 'product': str(Fraction(product, GRID))} + prime_witnesses[prime] = dict(witness, exponent=exponent) + if prime == 7 and exponent == 2: + seven_columns[column] += 1 + seven_rows[key] += 1 + if column not in seven_witnesses: + seven_witnesses[column] = witness or { + 'row': key, 'donor': donor, 'column': column, + 'scalar': str(q), 'donor_value': str(Fraction(value, GRID)), + 'product': str(Fraction(product, GRID))} + total[column] = total.get(column, 0) + product + total = {i: v for i, v in total.items() if v} + for value in total.values(): + row_gcd = gcd(row_gcd, value) + values[key] = total + trace.update(json.dumps([key, sorted(total.items())], separators=(',', ':')).encode()) + require(products == 8738317, 'complete nonzero product count') + require(GRID // product_gcd == GRID and GRID // row_gcd == 161280, 'grid minima') + require(seven_columns == {281: 60, 1501: 570} and len(seven_rows) == 40, + 'factor-seven support') + return {'products': products, 'minimum_product_grid': GRID, + 'minimum_snapshot_grid': GRID // row_gcd, + 'prime_witnesses': prime_witnesses, + 'seven_squared_columns': sorted(seven_columns.items()), + 'seven_squared_rows': sorted(seven_rows.items()), + 'seven_witnesses': seven_witnesses, 'row_trace_sha256': trace.hexdigest()} + + +def rational_column(graph, rows, witness): + """Use rational arithmetic on one input, without the integer basis trace.""" + values = {~i: Fraction(i == witness['column']) for i in range(1502)} + for key in graph['schedule']: + total = Fraction() + for donor, q in rows[key]: + product = values[donor] * q + if (key, donor) == (witness['row'], witness['donor']): + require(str(q) == witness['scalar'], 'witness scalar') + require(str(values[donor]) == witness['donor_value'], 'rational donor') + require(str(product) == witness['product'], 'rational product') + return product + total += product + values[key] = total + raise ValueError('missing witness') + + +def first_failure(graph, rows, column, grid): + values = {~i: grid * (i == column) for i in range(1502)} + for key in graph['schedule']: + total = 0 + for donor, q in rows[key]: + product, remainder = divmod(values[donor] * q.numerator, q.denominator) + if remainder: + return {'row': key, 'donor': donor, 'column': column, 'grid': grid, + 'scalar': str(q), 'divisor': q.denominator, 'remainder': remainder} + total += product + values[key] = total + raise ValueError('under-grid control did not fail') + + +def main(): + graph, rows = load() + result = basis_replay(graph, rows) + controls = [] + for prime, witness in result['prime_witnesses'].items(): + product = rational_column(graph, rows, witness) + require(valuation(product.denominator, prime) == witness['exponent'], 'prime sharpness') + controls.append(first_failure(graph, rows, witness['column'], GRID // prime)) + for column, witness in result['seven_witnesses'].items(): + product = rational_column(graph, rows, witness) + require(product.denominator % 49 == 0, 'two independent input witnesses') + controls.append(first_failure(graph, rows, column, 161280)) + result['under_grid_controls'] = controls + result['scope'] = 'Normalized scalar products and complete snapshots of the fixed graph only.' + result = json.loads(json.dumps(result)) + require(result == json.loads((HERE / 'RESULT.json').read_text()), 'receipt mismatch') + print('PASS_CHART595_FACTOR_SEVEN_AUDIT') + + +if __name__ == '__main__': + main()