diff --git a/research/chart595-row-atomic-arithmetic/CREDITS.md b/research/chart595-row-atomic-arithmetic/CREDITS.md new file mode 100644 index 0000000000..0dacd5fd6c --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/CREDITS.md @@ -0,0 +1,34 @@ +# Source credit + +Prepared by Ali Romman (@aliromman) with substantial OpenAI Codex assistance. +New code and prose are Apache-2.0. ORIGINS.json pins all retained input bytes. + +Clear1nsight's [PR #7697](https://github.com/CrocSwap/integer-mult-bounds/pull/7697) +supplies the fixed graph, grid figures and physical model: +[pinned proof](https://github.com/Clear1nsight/integer-mult-bounds/blob/f55fc1434436ffa1c6d064a29fc56812044b3157/research/p104-banked-chart595-split/PHYSICAL.md). +Its notice is retained and preserves Ali Romman's helper bases and banked +pivots, SYLforge's caller, DreamingOfClouds and Rohan Arun's native/caller +lineage, and Jerry Chen's selected framework application. + +Ali Romman's [PR #7701](https://github.com/CrocSwap/integer-mult-bounds/pull/7701), +[pinned proof](https://github.com/aliromman/integer-mult-bounds/blob/cd3819c70c6417bc1d3cc138294d973c58735229/research/chart595-factor-seven-audit/PROOF.md), +supplies the complete literal-product trace and independent grid audit. Its +receipt is retained for a byte-bound row-vector comparison. The predecessor +[PR #7680](https://github.com/CrocSwap/integer-mult-bounds/pull/7680) supplied +the earlier product/snapshot method. No source verifier is imported. + +Common-denominator accumulation, shift/add multiplication and long division +are classical. Nick Petalas (@petalas) used them for once-rounded Gaussian +gates in [PR #6429](https://github.com/CrocSwap/integer-mult-bounds/pull/6429), +[pinned proof](https://github.com/petalas/integer-mult-bounds/blob/08f0609cc997da02944cf5517eba1aa954665050/research/integer-rounded-gate/PROOF.md). +That proof was read. Its kernel is not copied, and its rounding and width +contract is not transferred to this graph. + +Wentao Li (@VictorLiwentao), with credit to Wronskode, supplied integer-row +verification work in [PR #2409](https://github.com/CrocSwap/integer-mult-bounds/pull/2409). +That is related verifier engineering, not this exact row provider. No +performance result from that work is claimed here. + +The contribution is the source-specific exact row contract, coefficient +census, W+20 proof, runtime kernel and complete scalar comparison. It is not +an independent human review or formal-kernel proof. diff --git a/research/chart595-row-atomic-arithmetic/LICENSE b/research/chart595-row-atomic-arithmetic/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/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-row-atomic-arithmetic/ORIGINS.json b/research/chart595-row-atomic-arithmetic/ORIGINS.json new file mode 100644 index 0000000000..13df77585c --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/ORIGINS.json @@ -0,0 +1,23 @@ +{ + "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" + }, + "inputs/GRID-RESULT.json": { + "repository": "aliromman/integer-mult-bounds", + "commit": "cd3819c70c6417bc1d3cc138294d973c58735229", + "path": "research/chart595-factor-seven-audit/RESULT.json", + "git_blob": "5a4b1823368205b34820fc721fbfc6d7033c29da", + "sha256": "4cbb65b0938bd3ede8082c0508d9cf831ba39e8c2d716aab2df77f617be1a82f" + } +} diff --git a/research/chart595-row-atomic-arithmetic/PROOF.md b/research/chart595-row-atomic-arithmetic/PROOF.md new file mode 100644 index 0000000000..807c4b7775 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/PROOF.md @@ -0,0 +1,121 @@ +# Exact row accumulation at the stored-row grid + +This construction changes the normalized scalar evaluation contract of the +fixed PR #7697 graph. It preserves every completed row and every paid chart +operation. It does not change the physical provider or its complete price. + +## Row program + +Let the fixed row be `sum(q_j * x_j)`. Compute its positive common denominator +`D = lcm(den(q_j))` and integer coefficients `a_j = D*q_j` once from the +source graph. The runtime program reads immutable integer donor values X_j, +forms `A = sum(a_j * X_j)` in their literal order, then performs one exact +integer division `A/D`. Reject a nonzero remainder. There is no intermediate +rounding or division. D and the a_j are fixed row constants. + +The common stored scale is `S = 161280`. The complete independent-input +replay starts with S times each standard basis vector. Every final division +has remainder zero. Each completed vector agrees, after multiplication by +280, with the complete literal-product trace at scale 45158400 from PR #7701. +All 7644 rows and 8738317 nonzero basis products are covered. This includes +both split-owner columns and the early output row. + +The proof of exactness is induction on the literal acyclic schedule. If all +donors equal S times their exact normalized values, then A/D equals S times +the exact next row. The full coefficient check proves that value is integral +for every independent integer entrance. Linearity extends the basis result +to arbitrary integer entrance vectors. The same scalar statement applies +componentwise and after an external common dyadic input scale. + +The gcd of all stored coefficients is one at S. Thus no smaller positive +common integer scale can represent all stored values of this fixed graph +for arbitrary independent entrances. The new contract attains this minimum. +The literal-product lower bound 45158400 remains correct: A is an integer +numerator with a pending row divisor, not a stored logical scalar product. +A smaller grid requires this changed arithmetic representation. + +## All-width arithmetic bound + +For signed W-bit donors, W at least two, `|X_j| <= 2^(W-1)`. The exact +source census gives these maxima, all attained at row 151738: + +| Quantity | Maximum | +| --- | ---: | +| D | 6720 | +| absolute integer coefficient | 84840 | +| B = sum(abs(a_j)) | 683350 | + +In particular, B is below `2^20`. Every term, partial numerator and complete +numerator has magnitude at most `B * 2^(W-1)`, strictly below `2^(W+19)`. +Therefore a signed word of width W+20 holds all such values, including their +positive magnitudes. This proof includes the most negative W-bit donor. + +The kernel multiplies a donor magnitude by abs(a_j) with binary shifts and +additions. Every shifted multiplicand and intermediate product sum is at +most the full product magnitude. It then adds the signed result to A. +The same W+20 bound covers every value, independent of cancellation. + +Binary long division scans W+19 magnitude positions. Before each optional +subtraction, the remainder is below `2D <= 13440`. Each quotient prefix is +at most the complete magnitude quotient, which is at most abs(A). The +shifted quotient prefix is no larger than the next completed prefix. +Thus every remainder, quotient, sign conversion and constant also fits +W+20. A zero final remainder proves exact division. No multiplication or +division machine instruction is assumed by the runtime kernel. + +The output fits W+20; installation in a W-bit bank still needs the actual +row amplitude bound. The two full finite fixtures check that separate +condition at W=64. This does not prove a universal W-bit amplitude bound. + +The extra 20 bits are a sufficient uniform bound for this full-numerator +program. They cannot be replaced uniformly by 19: at row 151738, set each +donor to the sign of its a_j times the largest multiple of 6720 below +`2^31`. This is a legal W=32 input and makes A divisible by D. Its positive +numerator needs 52 signed bits. RESULT.json retains the exact value. +This is a lower control for this accumulator representation, not a lower +bound for every arithmetic algorithm or every reachable bank state. + +## Explicit arithmetic work + +The 170652 scalar terms have 903276 coefficient-bit loop iterations and +245747 conditional product additions. There is one accumulator addition +per term. Exactly 3607 rows have D greater than one; the other 4037 rows +need no division. For the nontrivial rows there are 3607 times (W+19) +long-division iterations per real component per full normalized graph. +Each iteration has two shifts, one input-bit read, a comparison, and at +most one subtraction and one quotient increment. These are word-operation +counts for this program, not measured speed or a bit-tape tariff. + +Each coefficient has at most 17 bits. Fixed-coefficient shift/add passes, +addition and fixed-denominator remainder scans admit linear work in W +when implemented as serial bit operations with bounded carry. The explicit +reference uses Python integers and checked word values. It is not a tape +emitter and does not charge bank selection, staging, dirty initialization, +layout, head returns or cleanup. The 20-bit arithmetic allowance is below +the source's 26-bit temporary allowance, but that comparison alone does +not prove a valid physical substitution or a lower full allocation. + +## Evidence and limits + +The full basis replay uses integer common numerators and checks every final +division. Its row-vector digest agrees with the pinned earlier product +trace. Two complete scalar runs execute the shift/add and long-division +kernel, preserve every donor, and agree at every row with an independent +Fraction oracle. Every row has exact signed boundary fixtures at widths +16 and 32. The largest row is also checked at widths 128, 2048 and 4096. +Five controls reject a narrower word, nonzero remainder, out-of-range +input, boolean input and excess coefficient mass. + +This is a local arithmetic construction and written all-width proof with +finite corroboration. It is not full supplier admission or a new kappa. +The graph, paid/target invoice and selected frontier are unchanged. All +five framework assumptions remain. Common-denominator accumulation and +binary arithmetic are prior methods, as recorded in CREDITS.md. + +## Open next questions + +Bind the new accumulator to the actual guarded streams and complete root +representation. Prove every physical row division and installation at its +actual width, and count all movement, head returns, dirty state and cleanup. +Only that substitution can justify an ordinary-cost or storage claim for +the complete native caller. diff --git a/research/chart595-row-atomic-arithmetic/README.md b/research/chart595-row-atomic-arithmetic/README.md new file mode 100644 index 0000000000..7bdf5cb362 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/README.md @@ -0,0 +1,33 @@ +# Row-atomic arithmetic for the fixed chart-595 graph + +Accumulate an integer common numerator, then divide once per completed row. +This evaluates the same normalized graph at stored scale 161280, instead +of the 45158400 needed for separately divided literal products. The full +basis trace agrees at all 7644 rows. The new arithmetic representation +needs W+20-bit temporaries for W-bit donors; a W+19 control fails on an +actual source row with exact division. + +Read [the proof](PROOF.md), [receipt](RESULT.json), [kernel](kernel.py), +[checker](verify.py) and [credit](CREDITS.md). + +With CPython 3.12 and its standard library, from the repository root: + +```sh +python3.12 -I -W error -B research/chart595-row-atomic-arithmetic/verify.py +python3.12 -B scripts/research_package.py --package research/chart595-row-atomic-arithmetic +``` + +Expected: `PASS_CHART595_ROW_ATOMIC_ARITHMETIC`, then +`PASS_REGISTERED_RESEARCH_PACKAGE` for the registered command. + +The kernel uses shifts, additions and binary exact division. Two full scalar +runs agree with a separate Fraction oracle. All rows have boundary checks; +large words and five rejection controls also pass. The construction is +normalized scalar arithmetic. It does not install a physical provider or +change kappa. Full candidate/selected replays, physical root/tape checks, +Lean and Docker were not run. All five selected assumptions remain. + +## Open next questions + +Supply the complete guarded-stream, root, movement and cleanup substitution +before claiming a lower physical allocation or ordinary bill. diff --git a/research/chart595-row-atomic-arithmetic/RESULT.json b/research/chart595-row-atomic-arithmetic/RESULT.json new file mode 100644 index 0000000000..6a6fdda021 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/RESULT.json @@ -0,0 +1,89 @@ +{ + "statistics": { + "rows": 7644, + "terms": 170652, + "max_denominator": { + "row": 151738, + "terms": 81, + "denominator": 6720, + "l1": 683350, + "max_coefficient": 84840, + "bits": 20, + "shift_add_iterations": 912, + "signed_adds": 438 + }, + "max_l1": { + "row": 151738, + "terms": 81, + "denominator": 6720, + "l1": 683350, + "max_coefficient": 84840, + "bits": 20, + "shift_add_iterations": 912, + "signed_adds": 438 + }, + "max_coefficient": { + "row": 151738, + "terms": 81, + "denominator": 6720, + "l1": 683350, + "max_coefficient": 84840, + "bits": 20, + "shift_add_iterations": 912, + "signed_adds": 438 + }, + "max_bits": 20, + "shift_add_iterations": 903276, + "signed_adds": 245747, + "nontrivial_divisions": 3607 + }, + "basis": { + "basis_products": 8738317, + "row_final_basis_divisions": 1558861, + "minimum_snapshot_grid": 161280, + "reference_row_trace_sha256": "b3000ecf8e1eb408010289bbe8708cb93706ac7b2ba14a86edfb319f2c61e60a" + }, + "full_scalar_runs": [ + { + "seed": 0, + "rows": 7644, + "maximum_stored_magnitude": 25441869600, + "trace_sha256": "d104222added4c7f1bf36956eea133f72007efac37a62d29303b9e2a429049f3" + }, + { + "seed": 4, + "rows": 7644, + "maximum_stored_magnitude": 6792030000, + "trace_sha256": "6cc8a313070ab4c78311e524e2d5f3279a625d77af657846ef3c1553faa7be8b" + } + ], + "kernel": { + "all_row_boundary_cases": 30576, + "large_rows": [ + { + "data_width": 32, + "output_bits": 39 + }, + { + "data_width": 128, + "output_bits": 135 + }, + { + "data_width": 2048, + "output_bits": 2055 + }, + { + "data_width": 4096, + "output_bits": 4103 + } + ], + "narrow_word_control": { + "row": 151738, + "data_width": 32, + "numerator": 1467482863392000, + "needed_signed_bits": 52 + }, + "rejection_controls": 5 + }, + "scope": "Exact normalized row arithmetic; no physical tape, root or supplier substitution." +} diff --git a/research/chart595-row-atomic-arithmetic/SOURCES.json b/research/chart595-row-atomic-arithmetic/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/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-row-atomic-arithmetic/TASK.json b/research/chart595-row-atomic-arithmetic/TASK.json new file mode 100644 index 0000000000..8f9cc80ad9 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/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": "Construct exact row-atomic integer accumulation for the fixed PR7697 graph at its minimum stored grid, with W+20-bit temporaries and explicit local operation counts.", + "scope_change_reason": "The preceding scalar audit separates product and snapshot grids. This changes the evaluation contract and proves its local width and exact-division properties; it does not discharge the full root or supplier assumptions.", + "bottleneck_link": "It removes the factor-280 gap between literal products and stored rows without changing paid recursive jobs; physical substitution remains open.", + "budget_minutes": 60, + "stop_rule": "Stop at the complete finite scalar trace, arithmetic kernel and all-width bound. Do not change the physical provider, invoice or selected frontier.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; all-row integer basis trace; two full shift/add/long-division runs; exact boundary fixtures; large widths and rejection controls.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance. The source graph, notice and predecessor receipt are retained and pinned. Classical common-denominator arithmetic is credited.", + "open_questions": [ + { + "question": "Can this exact row arithmetic replace the physical scalar service within the complete bank/root contract?", + "why_it_matters": "Only a complete substitution can establish an allocation or ordinary-work reduction.", + "first_step": "Bind the W+20 accumulator and every final division to the guarded streams, roots, width bounds, dirty initialization and head returns.", + "blocked_by": "No physical tape emitter, full root induction or complete invoice substitution is supplied here." + } + ] +} diff --git a/research/chart595-row-atomic-arithmetic/VERIFY.json b/research/chart595-row-atomic-arithmetic/VERIFY.json new file mode 100644 index 0000000000..b53d0c4e74 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/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 sources; check all row coefficients, complete normalized basis trace, two full integer-kernel executions, every row boundary, large widths and five rejection controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Authenticate sources; check all row coefficients, complete normalized basis trace, two full integer-kernel executions, every row boundary, large widths and five rejection controls." + } + ] +} diff --git a/research/chart595-row-atomic-arithmetic/inputs/CANDIDATE-GRAPH.json.gz b/research/chart595-row-atomic-arithmetic/inputs/CANDIDATE-GRAPH.json.gz new file mode 100644 index 0000000000..8c23cc1422 Binary files /dev/null and b/research/chart595-row-atomic-arithmetic/inputs/CANDIDATE-GRAPH.json.gz differ diff --git a/research/chart595-row-atomic-arithmetic/inputs/GRID-RESULT.json b/research/chart595-row-atomic-arithmetic/inputs/GRID-RESULT.json new file mode 100644 index 0000000000..5a4b182336 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/inputs/GRID-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-row-atomic-arithmetic/inputs/SOURCE-NOTICE b/research/chart595-row-atomic-arithmetic/inputs/SOURCE-NOTICE new file mode 100644 index 0000000000..9405484426 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/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-row-atomic-arithmetic/kernel.py b/research/chart595-row-atomic-arithmetic/kernel.py new file mode 100644 index 0000000000..7e73167ec0 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/kernel.py @@ -0,0 +1,60 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Evaluate one integer row with a checked arithmetic-word width.""" + + +def check(value, width): + if type(value) is not int or not -(1 << (width - 1)) <= value < 1 << (width - 1): + raise ValueError('signed arithmetic width') + return value + + +def multiply(value, coefficient, width): + """Use shifts and additions; preserve the input value.""" + magnitude = check(abs(value), width) + factor = abs(coefficient) + total = 0 + position = 0 + while factor: + shifted = check(magnitude << position, width) + if factor & 1: + total = check(total + shifted, width) + position += 1 + factor >>= 1 + return check(-total if (value < 0) != (coefficient < 0) else total, width) + + +def divide_exact(value, denominator, width): + """Use binary long division and reject a nonzero final remainder.""" + magnitude = check(abs(value), width) + quotient = remainder = 0 + for position in range(width - 2, -1, -1): + remainder = check((remainder << 1) + ((magnitude >> position) & 1), width) + quotient = check(quotient << 1, width) + if remainder >= denominator: + remainder = check(remainder - denominator, width) + quotient = check(quotient + 1, width) + if remainder: + raise ValueError('nonzero exact-division remainder') + return check(-quotient if value < 0 else quotient, width) + + +def row(values, coefficients, denominator, data_width): + if type(data_width) is not int or data_width < 2: + raise ValueError('data width must be at least two') + if type(denominator) is not int or not 1 <= denominator <= 6720: + raise ValueError('row denominator') + if len(values) != len(coefficients) or not coefficients: + raise ValueError('row arity') + if any(type(c) is not int or c == 0 for c in coefficients): + raise ValueError('integer row coefficients') + if sum(map(abs, coefficients)) > 683350: + raise ValueError('row coefficient mass') + width = data_width + 20 + check(denominator, width) + total = 0 + for value, coefficient in zip(values, coefficients, strict=True): + check(value, data_width) + total = check(total + multiply(value, coefficient, width), width) + if denominator == 1: + return total + return divide_exact(total, denominator, width) diff --git a/research/chart595-row-atomic-arithmetic/verify.py b/research/chart595-row-atomic-arithmetic/verify.py new file mode 100644 index 0000000000..45664fd514 --- /dev/null +++ b/research/chart595-row-atomic-arithmetic/verify.py @@ -0,0 +1,175 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Check exact row accumulation on the fixed chart-595 graph.""" + +from fractions import Fraction +from hashlib import sha256 +import gzip +import importlib.util +import json +from math import gcd, lcm +from pathlib import Path + +HERE = Path(__file__).resolve().parent +SCALE = 161280 +spec = importlib.util.spec_from_file_location('row_kernel', HERE / 'kernel.py') +kernel = importlib.util.module_from_spec(spec) +spec.loader.exec_module(kernel) + + +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() == 'd5dab11bb773bf5beb8ae2998be1282b243e2d1606c5257896a037c9b52c5c3b', 'graph') + graph = json.loads(raw) + rows = {} + for key, terms in graph['forms']: + factors = [Fraction(q) for _, q in terms] + denominator = lcm(*(q.denominator for q in factors)) + coefficients = [q.numerator * (denominator // q.denominator) for q in factors] + rows[key] = ([d for d, _ in terms], coefficients, denominator) + return graph, rows + + +def statistics(rows): + details = [] + for key, (donors, coefficients, denominator) in rows.items(): + mass = sum(map(abs, coefficients)) + details.append({'row': key, 'terms': len(donors), 'denominator': denominator, + 'l1': mass, 'max_coefficient': max(map(abs, coefficients)), + 'bits': max(mass.bit_length(), denominator.bit_length()), + 'shift_add_iterations': sum(abs(c).bit_length() for c in coefficients), + 'signed_adds': sum(abs(c).bit_count() for c in coefficients)}) + result = {'rows': len(rows), 'terms': sum(x['terms'] for x in details), + 'max_denominator': max(details, key=lambda x: x['denominator']), + 'max_l1': max(details, key=lambda x: x['l1']), + 'max_coefficient': max(details, key=lambda x: x['max_coefficient']), + 'max_bits': max(x['bits'] for x in details), + 'shift_add_iterations': sum(x['shift_add_iterations'] for x in details), + 'signed_adds': sum(x['signed_adds'] for x in details), + 'nontrivial_divisions': sum(x['denominator'] != 1 for x in details)} + require(result['rows'] == 7644 and result['terms'] == 170652, 'full row count') + require(result['max_l1']['l1'] == 683350 and result['max_denominator']['denominator'] == 6720, + 'all-row width constants') + return result + + +def basis_trace(graph, rows): + values = {~i: {i: SCALE} for i in range(1502)} + trace = sha256() + stored_gcd = SCALE + products = 0 + quotients = 0 + for key in graph['schedule']: + donors, coefficients, denominator = rows[key] + total = {} + for donor, coefficient in zip(donors, coefficients, strict=True): + for column, value in values[donor].items(): + products += 1 + total[column] = total.get(column, 0) + coefficient * value + output = {} + for column, value in total.items(): + quotient, remainder = divmod(value, denominator) + require(remainder == 0, 'row-final basis division') + quotients += 1 + if quotient: + output[column] = quotient + stored_gcd = gcd(stored_gcd, quotient) + values[key] = output + trace.update(json.dumps([key, sorted((i, v * 280) for i, v in output.items())], + separators=(',', ':')).encode()) + prior = json.loads((HERE / 'inputs/GRID-RESULT.json').read_text()) + require(trace.hexdigest() == prior['row_trace_sha256'], 'complete literal-product reference') + require(stored_gcd == 1 and products == 8738317, 'minimal stored grid') + return {'basis_products': products, 'row_final_basis_divisions': quotients, + 'minimum_snapshot_grid': SCALE, 'reference_row_trace_sha256': trace.hexdigest()} + + +def complete_execution(graph, rows, seed): + source = {~i: SCALE * (((i * (719 + seed) + 29) % 127) - 63) for i in range(1502)} + actual = dict(source) + oracle = dict(source) + maximum = 0 + trace = sha256() + for key in graph['schedule']: + donors, coefficients, denominator = rows[key] + before = tuple(actual[d] for d in donors) + value = kernel.row(before, coefficients, denominator, 64) + reference = sum((Fraction(c, denominator) * oracle[d] + for d, c in zip(donors, coefficients, strict=True)), Fraction()) + require(reference.denominator == 1 and value == reference, 'full scalar execution') + require(before == tuple(actual[d] for d in donors), 'immutable donor values') + kernel.check(value, 64) + actual[key] = value + oracle[key] = reference + maximum = max(maximum, abs(value)) + trace.update(f'{key}:{value};'.encode()) + return {'seed': seed, 'rows': len(graph['schedule']), 'maximum_stored_magnitude': maximum, + 'trace_sha256': trace.hexdigest()} + + +def expect_failure(action, token): + try: + action() + except ValueError as error: + require(token in str(error), 'wrong rejection') + return + raise ValueError('negative control passed') + + +def kernel_controls(rows): + cases = 0 + for donors, coefficients, denominator in rows.values(): + for width in (16, 32): + for sign in (-1, 1): + # Multiples of D give exact rows for all donor signs. + value = sign * denominator * (((1 << (width - 1)) - 1) // denominator) + inputs = [value if c > 0 else -value for c in coefficients] + actual = kernel.row(inputs, coefficients, denominator, width) + expected = sum(c * x for c, x in zip(coefficients, inputs, strict=True)) // denominator + require(actual == expected, 'row boundary fixture') + cases += 1 + _, coefficients, denominator = rows[151738] + large = [] + for width in (32, 128, 2048, 4096): + value = denominator * (((1 << (width - 1)) - 1) // denominator) + inputs = [value if c > 0 else -value for c in coefficients] + expected = sum(c * x for c, x in zip(coefficients, inputs, strict=True)) // denominator + require(kernel.row(inputs, coefficients, denominator, width) == expected, 'large exact row') + large.append({'data_width': width, 'output_bits': abs(expected).bit_length() + 1}) + value = denominator * (((1 << 31) - 1) // denominator) + numerator = 683350 * value + expect_failure(lambda: kernel.check(numerator, 32 + 19), 'signed arithmetic width') + require(numerator % denominator == 0, 'accepted-domain narrow-word control') + expect_failure(lambda: kernel.row([1], [1], 7, 2), 'nonzero exact-division remainder') + expect_failure(lambda: kernel.row([2], [1], 1, 2), 'signed arithmetic width') + expect_failure(lambda: kernel.row([True], [1], 1, 2), 'signed arithmetic width') + expect_failure(lambda: kernel.row([1], [683351], 1, 2), 'row coefficient mass') + return {'all_row_boundary_cases': cases, 'large_rows': large, + 'narrow_word_control': {'row': 151738, 'data_width': 32, + 'numerator': numerator, 'needed_signed_bits': numerator.bit_length() + 1}, + 'rejection_controls': 5} + + +def result(): + graph, rows = load() + return {'statistics': statistics(rows), 'basis': basis_trace(graph, rows), + 'full_scalar_runs': [complete_execution(graph, rows, seed) for seed in (0, 4)], + 'kernel': kernel_controls(rows), + 'scope': 'Exact normalized row arithmetic; no physical tape, root or supplier substitution.'} + + +def main(): + receipt = result() + require(receipt == json.loads((HERE / 'RESULT.json').read_text()), 'receipt mismatch') + print('PASS_CHART595_ROW_ATOMIC_ARITHMETIC') + + +if __name__ == '__main__': + main()