diff --git a/research/p104-rank1-zero-cache-bound/INDEPENDENT-REVIEW.md b/research/p104-rank1-zero-cache-bound/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..676142a235 --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/INDEPENDENT-REVIEW.md @@ -0,0 +1,37 @@ +# Independent completeness review + +The root reviewed the one-unit quotient proof, full source/rank methods, +original-target debit and final independent validator after requesting +explicit coframe and complete-latest-event checks. The final version derives +all18 rank-one helpers and the12/6 partition from the word, requires complete +unique helper/coframe case sets, and binds every unit-expression/provider to +its exact event, owner, physical frame and observation kind. + +For an independent chronological bank, quotienting by e_h creates at most +one dependency. If e_h is outside the final bank span, the quotient remains +independent. Otherwise the unique exact expression identifies its latest +nonzero arrival, and singleton support identifies a zero arrival. This +classifies every earlier cut without assuming that a live subset was +simultaneously available: all history storage is granted optimistically. +The independent validator derives that complete event set itself and rejects +omitted, duplicated or mislabelled hits, then checks the target identities. + +The modular argument is valid because each original rank equals its literal +row count. A modular augmented rank m+1 then forces the rational rank m+1; +a modular hit is accepted only after a directly checked exact-Q unit identity. +This avoids inferring rational nonmembership from a bare modular miss. The +second source implementation uses a distinct prime and ROW elimination; +it does not just rerun the author's column certificate. Actual wrong-frame, +wrong-latest, missing-case and other mutations exercise the validators. + +Every original helper target is its own arbitrary input coordinate, as checked +at the source endpoint. Losing h therefore debits one original rank-one +target. All18 singleton cases supply exactly one whole rank-one credit, so +nonnegative rank tariffs give no net gain. No result about jointly zeroed +nonneutral helpers or changed/new histories is inferred. + +The exact source and notices, complete scoped proof, and separate verification +methods are preserved. Registered normal/optimized and committed-byte export +execution is recorded in VALIDATION.json. This is substantial OpenAI-assisted +review for Jerry Chen / @CubeJerry, not independent human or formal-kernel +acceptance. All five foundational assumptions and the selected kappa remain. diff --git a/research/p104-rank1-zero-cache-bound/LICENSE b/research/p104-rank1-zero-cache-bound/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/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/p104-rank1-zero-cache-bound/NOTICE b/research/p104-rank1-zero-cache-bound/NOTICE new file mode 100644 index 0000000000..c241bbe1f5 --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/NOTICE @@ -0,0 +1,21 @@ +Complete rank-one singleton-zero cache bound +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +Copyright 2026. Apache License 2.0; see LICENSE. + +Retain the exact native source notice in inputs/PREDECESSOR-NOTICE. Credit +Clear1nsight's #7481 word, retained signed-caller and helper/frame/owned +predecessors, Jerry Chen / CubeJerry's helper-funding and original-history +work, and every author named by the native notice. + +The published all-history and neutral-subset theorem is cache commit +fdbb41450a98594bdf1f5fe4535e77d2466adb4f in CubeJerry/integer-mult-bounds, +research/p104-earlier-destination-cache-bound/ALL-HISTORY-PROOF.md. +This notice assigns no upstream PR number to that commit. Its twelve +rank-one singleton consequences are cross-checked from source here. + +The new contribution is the six nonneutral public-cache classifications, +their exact singleton funding closure, and independent source/coframe/ +latest-event completeness verification for all eighteen rank-one inputs. +Classical rank, quotient, kernel and chronological circuit facts are not new. +No full physical cache, foundation discharge, human/formal acceptance or +new kappa is claimed; all five selected assumptions remain explicit. diff --git a/research/p104-rank1-zero-cache-bound/PR-DESCRIPTION.md b/research/p104-rank1-zero-cache-bound/PR-DESCRIPTION.md new file mode 100644 index 0000000000..adc57726b1 --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/PR-DESCRIPTION.md @@ -0,0 +1,51 @@ +# Bound all eighteen original rank-one helper singleton-zero promises across public and owned MOVE histories by the lost target price + +An original helper zero promise can enable a nonzero public cache even when +it removes no zero MOVE. This package completes the singleton rank-one +class on exact #7481: each of eighteen helpers permits exactly one rank-one +credit, cancelling its one lost original rank-one target. Twelve cases are +neutral-subset consequences of published cache commit +[fdbb41450a98594bdf1f5fe4535e77d2466adb4f](https://github.com/CubeJerry/integer-mult-bounds/commit/fdbb41450a98594bdf1f5fe4535e77d2466adb4f); the six others are new exact +public-cache classifications. No upstream PR number is invented for that +cache commit, and no joint-helper extension is claimed. + +The source-only verifier freshly derives all eighteen helpers and the12/6 +partition, covers every original owned/public MOVE cut, checks exact-Q +chronological identities and full-size modular rank certificates, then runs +a separate fresh replay and distinct-prime ROW check. That checker binds +all observations to exact coframes and source labels and independently +derives complete latest-enabled/zero event sets. Nine actual mutations +reject wrong coframes, omitted/latest-mislabelled or duplicate hits, bad +signs, self-arrival, omitted helper and wrong partition. + +The small package bundles only the exact WORD/NOTICE and standard-library +code needed for portable replay, not the multi-megabyte author receipt. +It prints compact decisions and a deterministic full-certificate hash. +Registered normal and optimized commands are read-only and require no +network, foreign Git object or workspace path. Physical public retirement, +ordinary work, owned stock and all five foundations remain unresolved and +optimistically free. No changed native word or kappa is asserted. + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance; +source, history, funding, cache and neutral-subset predecessors retain credit. +Independent agent checking is not independent human or proof-kernel approval. + +## Exact pins and reproduction + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +Unselected source #7481: `89eaa9d8cae37c1540de98f2d29a3abaabb96a2b`. +Compressed WORD SHA256: +`acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9`. + +```sh +python3 -I -B research/p104-rank1-zero-cache-bound/verify.py +python3 -O -I -B research/p104-rank1-zero-cache-bound/verify.py +python3 -B scripts/research_package.py --package research/p104-rank1-zero-cache-bound +``` + +Expected status: `PASS_COMPLETE_RANK1_SINGLETON_ZERO_CACHE_BOUND`. +The complete regenerated certificate hash is +`b7f1215c6f5614adaf79f1cb7fc3f893fd39df4329953e5fc9c0ab3c37c9c40d`. +`VALIDATION.json` records the executed registered and standalone read-only +checks. No new kappa, selected-certificate change or upstream PR submission +is part of this package. Open next questions are in README.md. diff --git a/research/p104-rank1-zero-cache-bound/PROOF.md b/research/p104-rank1-zero-cache-bound/PROOF.md new file mode 100644 index 0000000000..91ab358ddd --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/PROOF.md @@ -0,0 +1,105 @@ +# The complete rank-one singleton-zero cache bound + +Fix exact #7481 compressed SHA256 +acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9. +The canonical base is e54523517d0f03e58352e647c403a5af3e525a57; this +unselected native word and its inherited assumptions are not newly admitted. + +## Model and claim + +Take one original helper h with rank-one entrance/final job. Impose only +X_h=0; retain every other original helper and all400 main inputs jointly +arbitrary. All original scalar operations, coframes and histories retain +their meanings on that domain. Permit deletion of whole original MOVEs +that become zero, or replacement of a whole target from strict original +destination history. Grant unlimited historical storage and deterministic +processing, all ordinary work and physical cleanup free. Retain original +coordinate targets only; h loses its complete rank-one productive credit. + +For every such h, total possible recursive credit is at most f(1), and +therefore net native saving is at most f(1)-f(1)=0. This is singleton-only. +The claim holds for any nonnegative tariff on the recorded whole rank-one +jobs; no transcendental price estimate or new recurrence is required. + +## Complete source and history certificate + +Fresh replay derives18 rank-one helpers: + + 450,451,556,647,746,748,750,769,1231,1254,1301,1443, + 1459,1480,1485,1486,1487,1500. + +Their normalized final rows are their original coordinate units. Thus a +zeroed helper supplies no arbitrary original target. Source opcodes, current +coframes, ownership, strict nesting, COPY and completed lifetimes are checked. + +At each coframe form the chronological family B of original public initials +and MOVE arrivals. All scalar same-coframe values stay in its span. There +are7,780 rows across979 coframes, including all6,279 arrivals. Every original +family is independent: a nonzero full-size modular minor reaches its exact +literal row-count upper bound. Rational denominators are invertible at the +verified prime, so this is a rational rank certificate, not bare modular +nonmembership. Every original chronological prefix is also independent. +No used nonidentical frame alias is silently identified. + +The all-history independence and stronger neutral-subset theorem are credited +to published cache commit fdbb41450a98594bdf1f5fe4535e77d2466adb4f at +research/p104-earlier-destination-cache-bound/ALL-HISTORY-PROOF.md. +No upstream PR number is claimed. The current package independently +regenerates the source data needed for this singleton corollary; it does +not claim another replay of all2^72 neutral subsets. + +## One unit relation classifies every cut + +Work modulo span(e_h). If e_h is outside the final span of B, its rows stay +independent in the quotient and no target changes status. If it belongs, +its exact expression in independent B is unique. The quotient has precisely +that one dependency. An arrival becomes recoverable from strict earlier +observations if and only if it is the latest nonzero member of the expression. +An individual row vanishes if and only if that expression is a singleton. + +Every membership receives a directly checked Q identity. Every miss either +has a fresh exact absent unit column, extending an original full minor, or +has augmented modular rank m+1 equal to the exact m+1 row-count upper bound. +Any modular candidate is resolved over Q, so no rank-dropping modular miss +is accepted. The source-only checker covers all18*979 unit questions and +thus every original public and owned cut for every singleton. + +The twelve neutral rank-one helpers are + + 450,556,647,748,1231,1301,1443,1480,1485,1486,1487,1500. + +Each has one zero rank-one MOVE and no new nonzero cached target, agreeing +with the stronger published neutral-subset theorem. The other six have no +zero MOVE and precisely the one public rank-one cache in README's table. +For each helper e_h occurs in exactly two final coframe spans: its initial +unit observation and the one dependency yielding its sole credited arrival. +All event and coefficient details are regenerated and committed to the +deterministic full-certificate hash, rather than a bundled old receipt. + +## Independent completeness and physical limits + +The independent checker uses its own fresh Q replay and a distinct-prime +ROW method. It derives18 and the12/6 partition from the source itself. +It binds every unit-expression and provider observation to the asserted +exact coframe, source event, owner and observation kind. From each unique +expression it derives the latest nonzero observation and the complete +enabled/zero event sets, rejecting omitted or duplicate cases. Direct target +identities, original ranks and credits are checked independently. Actual +wrong-coframe, wrong-latest, omitted-hit and other mutations exercise these +same validators. Finite controls support the source/rank proof. + +On the stated linear arbitrary-input domain, a target outside the observation +span modulo e_h has a kernel direction with unchanged observations and +different target, excluding any deterministic decoder from that information. +For finite arrays one can multiply that scalar direction by a nonzero entry +vector. This is an algebraic whole-job information bound, not admission of +a finite-grid-only decoder or a physical tensor layout. + +Every singleton's one f(1) credit cancels its lost f(1) original target. +Extra physical costs can only reduce the optimistic gain. No public +CLEAR/INIT, uncharged transport, free disposal of dirty data or decoded +productive price is inferred. Changed operations/histories, imported data, +joint zero promises, partial jobs and other helper relations are excluded. +All five foundational assumptions and selected conditional kappa remain. +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance; +all exact source notices and predecessor credit are retained. diff --git a/research/p104-rank1-zero-cache-bound/README.md b/research/p104-rank1-zero-cache-bound/README.md new file mode 100644 index 0000000000..a20de52500 --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/README.md @@ -0,0 +1,97 @@ +# Bound every rank-one helper singleton-zero promise by its lost original target across all public and owned MOVE histories + +**Complete singleton class, scoped source-bound budget theorem; no new kappa.** +For exact unselected #7481, each of its18 original rank-one helpers can be +individually set to zero. Under unchanged instructions/coframes and strict +original destination histories, the total optimistic recursive credit is +exactly one rank-one MOVE price. It cancels the one lost original target. +This covers all6,279 cuts, public and owned, for every singleton. It does +not claim an extension to two or more simultaneously zeroed helpers. + +The published neutral-subset predecessor is **cache commit +`fdbb41450a98594bdf1f5fe4535e77d2466adb4f`**, at +`research/p104-earlier-destination-cache-bound/ALL-HISTORY-PROOF.md` in +CubeJerry/integer-mult-bounds. No upstream PR number is asserted for that +commit. Its12 rank-one neutral singletons have one zero MOVE and no nonzero +cache. This package cross-checks them source-only and adds the six remaining +public-cache classifications: + +| Zero helper | Sole newly recoverable MOVE | Owner | Frames | Rank | +| --- | ---: | ---: | --- | ---: | +|451|39448|1207|3 to595|1| +|746|36561|746|3 to595|1| +|750|49776|750|477 to127|1| +|769|49911|438|245 to127|1| +|1254|33335|561|3 to593|1| +|1459|52236|763|189 to127|1| + +Those six have no zero MOVE. The full18 set and12/6 partition are derived +freshly from the original helper target ranks and pure source MOVE rows, +not accepted from saved author metadata. Every other original coordinate +stays jointly arbitrary; demoted zero fields receive no target credit. +Decoded targets, changed producers, imported observations and partial jobs +are excluded. Ordinary work, storage, public zero/cache interfaces and +return are optimistically free, so the zero net rank gain is an upper bound. + +## Read-only portable verification + +Python3.12 standard library only, from this directory or any checkout: + +```sh +python3 -I -B verify.py +python3 -I -O -B verify.py +``` + +The verifier reads only bundled exact WORD/NOTICE and local code. It needs +no Git, network, absolute workspace path, foreign commit or raw receipt. +It writes no files and prints compact decisions plus a deterministic +SHA256 of the full generated certificate; the multi-megabyte certificate +is reconstructed in memory and is not bundled. Source byte pin: +`acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9`. + +The primary checker freshly replays all76,475 instructions over Q and uses +maximum-row-pivot COLUMN elimination at prime1000033. The separate checker +freshly replays again, uses minimum-column-pivot ROW elimination at65521, +and derives every coframe circuit's latest observation independently. +Every provider and unit-expression observation is bound to its actual exact +coframe and source label. Complete enabled/zero sets, duplicates, omissions, +coefficients, original helper endpoints and the18/12+6 partition are checked. +Nine actual mutations reject wrong coframes, wrong latest labels, omitted or +duplicated hits, wrong signs, self-arrival, omitted helper and wrong partition. + +Registered commands from a repository root are: + +```sh +python3 -B scripts/research_package.py --package research/p104-rank1-zero-cache-bound --check-only +python3 -B scripts/research_package.py --package research/p104-rank1-zero-cache-bound +``` + +Expected status: `PASS_COMPLETE_RANK1_SINGLETON_ZERO_CACHE_BOUND`, followed by +the registered package marker. Normal and optimized receipts are deterministic; +read-only and Git-free copied-package checks are recorded separately by root. +Typical full replay is roughly one minute; no predecessor historical suite is +rerun and no tensor-width sample is called a universal physical proof. + +## Scope and credit + +[PROOF.md](PROOF.md) gives the final-matrix/one-circuit argument, exact funding +model and limits. Canonical base is +`e54523517d0f03e58352e647c403a5af3e525a57`; tested native source is the +unchanged unselected #7481 at89eaa9d8cae37c1540de98f2d29a3abaabb96a2b. +SOURCES.json retains exact exports and the original task card provenance. +All five selected foundations and the selected conditional kappa remain. + +The neutral theorem, source construction, helper-funding, original-history +and owned/public cache predecessors retain their authorship. Exact source +notice is in inputs/PREDECESSOR-NOTICE. Prepared for Jerry Chen / CubeJerry +with substantial OpenAI assistance. Classical rank and kernel facts are not +claimed new; independent agent checks are not human or proof-kernel acceptance. + +## Open next questions + +1. Join one exact public cache identity to a fully priced same-owner physical + interface, including allocation, layout, public retirement and return. + Its rank budget already has zero surplus; those costs cannot create gain. +2. A changed-carrier, other-relation, joint-zero or decoded-target proposal + needs a new explicit scope and complete bill. This package neither tests + nor excludes it. TASK.json records first steps and blockers. diff --git a/research/p104-rank1-zero-cache-bound/RESULT.json b/research/p104-rank1-zero-cache-bound/RESULT.json new file mode 100644 index 0000000000..b189abc7dd --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/RESULT.json @@ -0,0 +1,769 @@ +{ + "all_MOVE_cuts_per_promise": 6279, + "coframes": 979, + "decisions": [ + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 39445, + "literal": [ + "MOVE", + 450, + 3, + 595, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 450, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 39445 + ] + }, + { + "class": "new_public_cache_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 39448, + "literal": [ + "MOVE", + 1207, + 3, + 595, + false + ], + "rank": 1, + "zero": false + } + ], + "helper": 451, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [ + 39448 + ], + "zero_MOVEs": [] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 76464, + "literal": [ + "MOVE", + 556, + 3, + 105, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 556, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 76464 + ] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 76465, + "literal": [ + "MOVE", + 647, + 3, + 597, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 647, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 76465 + ] + }, + { + "class": "new_public_cache_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 36561, + "literal": [ + "MOVE", + 746, + 3, + 595, + false + ], + "rank": 1, + "zero": false + } + ], + "helper": 746, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [ + 36561 + ], + "zero_MOVEs": [] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 76468, + "literal": [ + "MOVE", + 748, + 517, + 127, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 748, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 76468 + ] + }, + { + "class": "new_public_cache_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 49776, + "literal": [ + "MOVE", + 750, + 477, + 127, + false + ], + "rank": 1, + "zero": false + } + ], + "helper": 750, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [ + 49776 + ], + "zero_MOVEs": [] + }, + { + "class": "new_public_cache_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 49911, + "literal": [ + "MOVE", + 438, + 245, + 127, + false + ], + "rank": 1, + "zero": false + } + ], + "helper": 769, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [ + 49911 + ], + "zero_MOVEs": [] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 33250, + "literal": [ + "MOVE", + 490, + 3, + 594, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 1231, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 33250 + ] + }, + { + "class": "new_public_cache_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 33335, + "literal": [ + "MOVE", + 561, + 3, + 593, + false + ], + "rank": 1, + "zero": false + } + ], + "helper": 1254, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [ + 33335 + ], + "zero_MOVEs": [] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 76470, + "literal": [ + "MOVE", + 1301, + 3, + 597, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 1301, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 76470 + ] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 45844, + "literal": [ + "MOVE", + 1443, + 246, + 127, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 1443, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 45844 + ] + }, + { + "class": "new_public_cache_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 52236, + "literal": [ + "MOVE", + 763, + 189, + 127, + false + ], + "rank": 1, + "zero": false + } + ], + "helper": 1459, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [ + 52236 + ], + "zero_MOVEs": [] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 58979, + "literal": [ + "MOVE", + 1480, + 245, + 127, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 1480, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 58979 + ] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 45508, + "literal": [ + "MOVE", + 1485, + 246, + 127, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 1485, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 45508 + ] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 45836, + "literal": [ + "MOVE", + 1486, + 246, + 127, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 1486, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 45836 + ] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 45525, + "literal": [ + "MOVE", + 1487, + 246, + 127, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 1487, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 45525 + ] + }, + { + "class": "prior_neutral_singleton", + "credit_rank1_jobs": 1, + "events": [ + { + "event": 58942, + "literal": [ + "MOVE", + 1500, + 245, + 127, + false + ], + "rank": 1, + "zero": true + } + ], + "helper": 1500, + "lost_rank1_target": 1, + "net_native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 58942 + ] + } + ], + "full_certificate_sha256": "b7f1215c6f5614adaf79f1cb7fc3f893fd39df4329953e5fc9c0ab3c37c9c40d", + "helpers": [ + 450, + 451, + 556, + 647, + 746, + 748, + 750, + 769, + 1231, + 1254, + 1301, + 1443, + 1459, + 1480, + 1485, + 1486, + 1487, + 1500 + ], + "independent_review": { + "all18_rank1_helpers": [ + 450, + 451, + 556, + 647, + 746, + 748, + 750, + 769, + 1231, + 1254, + 1301, + 1443, + 1459, + 1480, + 1485, + 1486, + 1487, + 1500 + ], + "decisions": [ + { + "class": "neutral", + "credit_rank": 1, + "helper": 450, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 39445 + ] + }, + { + "class": "nonneutral_public_cache", + "credit_rank": 1, + "helper": 451, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [ + 39448 + ], + "zero_MOVEs": [] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 556, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 76464 + ] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 647, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 76465 + ] + }, + { + "class": "nonneutral_public_cache", + "credit_rank": 1, + "helper": 746, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [ + 36561 + ], + "zero_MOVEs": [] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 748, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 76468 + ] + }, + { + "class": "nonneutral_public_cache", + "credit_rank": 1, + "helper": 750, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [ + 49776 + ], + "zero_MOVEs": [] + }, + { + "class": "nonneutral_public_cache", + "credit_rank": 1, + "helper": 769, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [ + 49911 + ], + "zero_MOVEs": [] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 1231, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 33250 + ] + }, + { + "class": "nonneutral_public_cache", + "credit_rank": 1, + "helper": 1254, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [ + 33335 + ], + "zero_MOVEs": [] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 1301, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 76470 + ] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 1443, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 45844 + ] + }, + { + "class": "nonneutral_public_cache", + "credit_rank": 1, + "helper": 1459, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [ + 52236 + ], + "zero_MOVEs": [] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 1480, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 58979 + ] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 1485, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 45508 + ] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 1486, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 45836 + ] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 1487, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 45525 + ] + }, + { + "class": "neutral", + "credit_rank": 1, + "helper": 1500, + "lost_target_rank": 1, + "native_gain": 0, + "nonzero_cached_MOVEs": [], + "zero_MOVEs": [ + 58942 + ] + } + ], + "exact_Q_unit_expressions": 36, + "exact_complete_target_decoders": 18, + "executed_mutation_controls": { + "duplicate_hit": "independent: complete unique enabled MOVE set", + "omitted_helper": "independent: complete unique helper cases", + "omitted_latest_hit": "independent: complete unique enabled MOVE set", + "self_arrival_as_provider": "independent: strict unique provider", + "wrong_12_6_partition": "independent: complete fresh helper partition", + "wrong_latest_event": "independent: exact latest nonzero observation", + "wrong_provider_coframe": "independent: observation exact coframe", + "wrong_provider_sign": "independent: unique exact strict decoder identity", + "wrong_unit_observation_coframe": "independent: observation exact coframe" + }, + "full_row_count_augmented_misses": 17586, + "neutral12": [ + 450, + 556, + 647, + 748, + 1231, + 1301, + 1443, + 1480, + 1485, + 1486, + 1487, + 1500 + ], + "new6": [ + 451, + 746, + 750, + 769, + 1254, + 1459 + ], + "original_observation_rank": 7780, + "prime": 65521, + "status": "PASS_INDEPENDENT_ALL18_COFRAME_LATEST_COMPLETENESS", + "unit_coframe_decisions": 17622 + }, + "joint_helper_extension_claimed": false, + "neutral12": [ + 450, + 556, + 647, + 748, + 1231, + 1301, + 1443, + 1480, + 1485, + 1486, + 1487, + 1500 + ], + "new6": [ + 451, + 746, + 750, + 769, + 1254, + 1459 + ], + "original_observation_rank": 7780, + "published_neutral_predecessor_cache_commit": "fdbb41450a98594bdf1f5fe4535e77d2466adb4f", + "scope": "Original retained coordinate targets, whole original MOVEs and unchanged strict original histories only. Each singleton permits at most f1 credit against f1 target debit. No physical cache/zero-reframe/ordinary/owned admission, foundation removal or new kappa.", + "singletons_only": true, + "source_payload_sha256": "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8", + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "status": "PASS_COMPLETE_RANK1_SINGLETON_ZERO_CACHE_BOUND" +} diff --git a/research/p104-rank1-zero-cache-bound/SOURCES.json b/research/p104-rank1-zero-cache-bound/SOURCES.json new file mode 100644 index 0000000000..387472e2c8 --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/SOURCES.json @@ -0,0 +1,52 @@ +{ + "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" + } + ], + "bundled_external_inputs": [ + { + "path": "inputs/WORD.json.gz", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "source_path": "research/p104-funded-485-1455-return/producer54/reroute/WORD.json.gz", + "git_blob": "77df4ad624f4ed3d4bb5e08b4ac1891534d2261d", + "sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "bytes": 381925 + }, + { + "path": "inputs/PREDECESSOR-NOTICE", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "source_path": "research/p104-funded-485-1455-return/NOTICE", + "git_blob": "4133e9216529e7a1dbceb092a05db2300305d102", + "sha256": "78e060cbd33ebc4078cabf39e50191a977fb9eb5c41104533079e22da1d9d248", + "bytes": 1538 + } + ], + "predecessors": [ + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "fdbb41450a98594bdf1f5fe4535e77d2466adb4f", + "path": "research/p104-earlier-destination-cache-bound/ALL-HISTORY-PROOF.md", + "role": "Published cache commit proving the neutral-subset theorem. No upstream PR number is asserted; its12 rank-one singleton cases are cross-checked here." + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "role": "Exact unselected #7481 native word, with retained source notice." + } + ], + "dependency_policy": "All runtime inputs are bundled exact bytes; no foreign commit, Git checkout or network required by standalone verification. No raw author receipt is bundled." +} diff --git a/research/p104-rank1-zero-cache-bound/TASK.json b/research/p104-rank1-zero-cache-bound/TASK.json new file mode 100644 index 0000000000..4cb3ad3ffe --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/TASK.json @@ -0,0 +1,89 @@ +{ + "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": "refined", + "actual_scope": "Complete all18 singleton rank-one helper-zero promises on exact #7481, with original whole MOVE targets and strict original histories; each permits at most one rank1 credit, cancelling its lost original target. No joint helper claim.", + "scope_change_reason": "The broad foundational card is narrowed to one exact original-coordinate cache/zero funding interface. Twelve cases use and cross-check the published neutral-subset theorem at cache commit fdbb41450a98594bdf1f5fe4535e77d2466adb4f; six are the new public-cache classifications.", + "bottleneck_link": "Closes the complete singleton rank-one helper-zero strategy under unchanged original histories, including public caches outside the prior owned-only funding theorem.", + "budget_minutes": 30, + "stop_rule": "Verify the exact18/12+6 partition, all whole MOVE zeros/caches, exact chronological witnesses, rank upper certificates and independent coframe/latest completeness controls. Do not extend to joint zero promises or physical construction.", + "outcome": "partial", + "evidence": "Source-only exact Q replay and full-size column minors; separate fresh distinct-prime row ranks, exact coframe-bound unit/decoder identities and actual completeness mutations; registered normal/optimized read-only replay.", + "author": "Jerry Chen / CubeJerry", + "ai_assistance": "Substantial OpenAI assistance in mathematics, implementation, separate verification and writing. No human or proof-kernel acceptance is asserted.", + "open_questions": [ + { + "question": "Construct an actually charged public cache replacement on one zero promise.", + "why_it_matters": "Information recoverability does not admit public retirement, copying, layout and owned return.", + "first_step": "Choose one exact rank1 event and join its coframed provider identity to a literal same-owner interface with every cost.", + "blocked_by": "Public field and owned-bank lifecycle, ordinary layout/precision and complete source return; the optimistic rank budget already has no positive surplus." + }, + { + "question": "Change the fixed-history or original-target hypothesis in a separately scoped strategy.", + "why_it_matters": "This singleton bound does not cover changed carriers, other relations, joint zeros or decoded productive types.", + "first_step": "Specify one changed interface and its complete target/paid bill before any search.", + "blocked_by": "A new authorized scope and all source/ownership/precision and full-system admission obligations." + } + ] +} diff --git a/research/p104-rank1-zero-cache-bound/VALIDATION.json b/research/p104-rank1-zero-cache-bound/VALIDATION.json new file mode 100644 index 0000000000..4263d6c39c --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/VALIDATION.json @@ -0,0 +1,43 @@ +{ + "status": "PASS_REGISTERED_AND_READ_ONLY_GIT_FREE_EMPTY_PATH_EXPORT", + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "scientific_commit": "597695ed824cae6c546d99a0195b9aab2bd439d3", + "primary_stdout_sha256": "b192dd96470338aec5512268bb9b882dbeda4251f12965dd655b3f0a1b1dc6f7", + "full_certificate_sha256": "b7f1215c6f5614adaf79f1cb7fc3f893fd39df4329953e5fc9c0ab3c37c9c40d", + "normal_optimized_byte_identical": true, + "declared_inputs_checked": 2, + "independent_method": "Fresh exact-Q source replay, distinct-prime ROW ranks, exact unit/target identities and complete coframe/latest event derivation.", + "independent_mutation_controls": { + "duplicate_hit": "independent: complete unique enabled MOVE set", + "omitted_helper": "independent: complete unique helper cases", + "omitted_latest_hit": "independent: complete unique enabled MOVE set", + "self_arrival_as_provider": "independent: strict unique provider", + "wrong_12_6_partition": "independent: complete fresh helper partition", + "wrong_latest_event": "independent: exact latest nonzero observation", + "wrong_provider_coframe": "independent: observation exact coframe", + "wrong_provider_sign": "independent: unique exact strict decoder identity", + "wrong_unit_observation_coframe": "independent: observation exact coframe" + }, + "root_review": "INDEPENDENT-REVIEW.md; original-target debit, rational rank certification, all-unit chronology and final coframe/latest completeness fixes reviewed.", + "scientific_file_sha256": { + "verify.py": "60451e71b406962048ec94f44cd7e4e5230664e8b9ae816343364b62ae0d6d67", + "verifier/author.py": "da42709e587e884453d28c0b6a572f5d99c33d3daeb476307d6926aef6e1bc8d", + "verifier/independent.py": "cde28ec4588d45321cfd857fbd1f8ca52ce5160ee015f8d38d5586fd1a850858", + "inputs/WORD.json.gz": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" + }, + "scope": "No new kappa or physical source admission; singletons only.", + "read_only_export": { + "status": "PASS_READ_ONLY_GIT_FREE_EMPTY_PATH_EXPORT", + "tested_commit": "97d1028ea372c6897828af46e25ea7dbe5d1820c", + "files": 16, + "declared_inputs_checked": 2, + "seconds": 64.003, + "exit_code": 0, + "stdout_sha256": "b192dd96470338aec5512268bb9b882dbeda4251f12965dd655b3f0a1b1dc6f7", + "read_only_modes": true, + "git_free": true, + "empty_path": true, + "package_bytes_and_modes_unchanged": true, + "stderr_empty": true + } +} diff --git a/research/p104-rank1-zero-cache-bound/VERIFY.json b/research/p104-rank1-zero-cache-bound/VERIFY.json new file mode 100644 index 0000000000..430a93a5ce --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/VERIFY.json @@ -0,0 +1,33 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-rank1-zero-cache-bound/inputs/WORD.json.gz", + "research/p104-rank1-zero-cache-bound/inputs/PREDECESSOR-NOTICE" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Source-only all18 singleton decisions and deterministic full certificate hash; separate source replay/row-rank/coframe/latest completeness review and nine actual mutation controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "The same exact scientific and mutation checks under optimized Python; compact output only; read-only." + } + ] +} diff --git a/research/p104-rank1-zero-cache-bound/inputs/PREDECESSOR-NOTICE b/research/p104-rank1-zero-cache-bound/inputs/PREDECESSOR-NOTICE new file mode 100644 index 0000000000..4133e92165 --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/inputs/PREDECESSOR-NOTICE @@ -0,0 +1,16 @@ +Apache-2.0. Clear1nsight, with substantial OpenAI Codex assistance. +ChatGPT Pro audited the adjacent signed-swap approach and recommended checking +full input and output defects at a coframe. The literal witness was found by +the local chart-component scan and checked over the rationals. + +Exact #7314 and its recursive sources are retained with their original notices. +Credit Clear1nsight for #7314 and #7274, Rohan Arun for #7277 and the signed +#7113 caller, ToikY for the #7312 public MOVE contact study, the independent +#7317 replay, #7329's scalar-contraction bound and the directed price engines. +The earlier compensated fusion #6529 and the work it credits supply a related +precedent. Credit dillona, Ali Romman, Jerry Chen / CubeJerry, DreamingOfClouds, +and all contributors named in the retained sources. + +Successor helper449 paid high-readout correction: Rohan Arun with substantial OpenAI Codex assistance. Extends Clear1nsight helper319 construction, retains all nested notices and authors. Apache-2.0. + +Funded485/1455 successor,2026-11-13: the new two-shear encoding, funded itinerary change, proof and initial full replay were developed with verified GPT-6 Pro. Clear1nsight with OpenAI Codex assistance audited, integrated, independently replayed and prepared this contribution. The preceding paragraphs describe retained predecessor work; their chart-component authorship claim does not describe this successor. All source notices remain unchanged under inputs/. No independent human or formal-kernel acceptance is claimed. diff --git a/research/p104-rank1-zero-cache-bound/inputs/WORD.json.gz b/research/p104-rank1-zero-cache-bound/inputs/WORD.json.gz new file mode 100644 index 0000000000..77df4ad624 Binary files /dev/null and b/research/p104-rank1-zero-cache-bound/inputs/WORD.json.gz differ diff --git a/research/p104-rank1-zero-cache-bound/verifier/author.py b/research/p104-rank1-zero-cache-bound/verifier/author.py new file mode 100644 index 0000000000..77a01930e0 --- /dev/null +++ b/research/p104-rank1-zero-cache-bound/verifier/author.py @@ -0,0 +1,153 @@ +#!/usr/bin/env python3 +"""Source-only exact all18 singleton rank-one helper-zero certificate.""" +from pathlib import Path +from fractions import Fraction as Q +from collections import defaultdict,Counter +from hashlib import sha256 +from datetime import datetime,timezone +import argparse,gzip,json,math,time +HERE=Path(__file__).resolve().parent +PIN='acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' +NEW_HELPERS=(451,746,750,769,1254,1459) +PRIME=1000033 +DEADLINE=None +def bounded(): + if DEADLINE is not None and time.time()>=DEADLINE:raise TimeoutError('task UTC deadline') +def need(ok,label): + if not ok:raise ValueError(label) +def add(a,b,q): + for h,v in b.items(): + z=a.get(h,0)+q*v + if z:a[h]=z + else:a.pop(h,None) +def framekey(frame): + s={0} + for u in frame: + need(0=n),'live owned/public MOVE') + left,right=set(classes[old]),set(classes[new]);need(left0,'paid positive rank');moves[event]={'event':event,'literal':e,'rank':r,'row':rows[a].copy()} + if len(rows[a])==1: + h=next(iter(rows[a])) + if h in zeros:zeros[h].append(event) + cur[a]=new;observe(event,a,new,'arrival') + elif op=='INIT':need(a>=n and cur[a] is None and rows[a] is None,'fresh INIT');cur[a]=e[2];rows[a]={} + elif op=='CLEAR':need(a>=n and cur[a]==e[2] and rows[a] is not None,'owned CLEAR');cur[a]=None;rows[a]=None + elif op=='SCALE': + need(cur[a]==e[-1] and Q(e[2]),'coframed SCALE');q=Q(e[2]);rows[a]={h:q*v for h,v in rows[a].items()} + elif op in ['ADD','COPY']: + b=e[2];need(a!=b and cur[a]==cur[b]==e[-1],'coframed contact') + if op=='COPY':need(a>=n and not rows[a],'COPY into zero') + add(rows[a],rows[b],Q(e[3])) + else:raise ValueError(op) + need(cur==w['final']+[None]*w['owned_fields'] and len(moves)==6279,'complete endpoints and all cuts') + need(all(rows[h]=={h:Q(1)} for h in HELPERS),'all18 autonomous original helper endpoints') + need(sum(map(len,banks.values()))==7780,'complete observation stock') + neutral=tuple(h for h in HELPERS if len(zeros[h])==1 and moves[zeros[h][0]]['rank']==1) + other=tuple(h for h in HELPERS if h not in neutral) + need(len(neutral)==12 and other==NEW_HELPERS,'fresh12neutral6nonneutral partition') + inverses={};originals=[];cases={h:{'helper':h,'target_rank':1,'zero_MOVE_events':zeros[h],'hits':[],'coframes':[]} for h in HELPERS};basis_cache={};rank_total=0 + def mod(q): + if q.denominator not in inverses: + need(q.denominator%PRIME,'source denominator invertible');inverses[q.denominator]=pow(q.denominator%PRIME,PRIME-2,PRIME) + return q.numerator*inverses[q.denominator]%PRIME + def label(o):return {k:v for k,v in o.items() if k!='row'} + for ix,(key,bank) in enumerate(sorted(banks.items(),key=lambda x:aliases[x[0]][0])): + bounded();frame=aliases[key][0];m=len(bank);columns=defaultdict(dict);support=set();digest=sha256() + for i,o in enumerate(bank): + support.update(o['row']);digest.update((json.dumps([label(o),encode(o['row'])],sort_keys=True,separators=(',',':'))+'\n').encode()) + for h,q in o['row'].items(): + value=mod(q) + if value:columns[h][i]=value + original=column_rank(columns,m);need(original['full_row_rank'],'full row count certifies exact original rank') + need(len(set(o['frame'] for o in bank))==1,'no used nonidentical frame aliases') + originals.append({'frame':frame,'row_count':m,'matrix_sha256':digest.hexdigest(),'full_row_rank_certificate':original});rank_total+=m + for h in HELPERS: + bounded();d={'frame':frame,'original_rows':m} + if h not in support: + d.update(relation_in_final_span=False,certificate={'method':'original_minor_plus_exact_new_unit_column','original_frame_certificate':frame,'new_column':h,'new_pivot_row':m,'new_pivot_value':1,'exact_rational_rank':m+1,'literal_row_upper_bound':m+1}) + else: + augmented={j:v.copy() for j,v in columns.items()};augmented.setdefault(h,{})[m]=1;cert=column_rank(augmented,m+1) + d['certificate']=cert + if cert['full_row_rank']:d['relation_in_final_span']=False + else: + need(cert['rank_mod']==m,'unit extension rank at least original rank');answer,residual=exact_unit_expression(bank,h,basis_cache,key) + if residual: + d.update(relation_in_final_span=False,exact_Q_remainder=encode(residual),exact_Q_basis_row_count=m) + else: + d['relation_in_final_span']=True + d['unique_expression']=[{'observation':label(bank[i]),'coefficient':str(q)} for i,q in sorted(answer.items())] + last=max(answer,key=lambda i:(bank[i]['event'],i));o=bank[last] + if o['kind']=='arrival': + e=o['event'];q=answer[last];providers=[{'observation':label(bank[i]),'coefficient':str(-a/q)} for i,a in sorted(answer.items()) if i!=last] + need(all(p['observation']['event']=n and loc[a] is None,'INIT');values[a]={};loc[a]=e[2] + elif op=='CLEAR':need(a>=n and loc[a]==e[2],'CLEAR');values[a]=None;loc[a]=None + elif op=='SCALE':need(loc[a]==e[3],'SCALE');values[a]={j:q*F(e[2]) for j,q in values[a].items()} + else: + b=e[2];need(op in ('ADD','COPY') and loc[a]==loc[b]==e[4],'contact') + if op=='COPY':need(not values[a],'COPY zero') + axpy(values[a],values[b],F(e[3])) + need(loc==w['final']+[None]*w['owned_fields'] and len(targets)==6279,'complete source') + mains=set(w['live'])|{a+112 for a in w['live']}|set(w['hosted']['X2'])|set(w['hosted']['Y2']);helpers=set(range(n))-mains + ranks={h:abs(len(w['frames'][w['initial'][h]])-len(w['frames'][w['final'][h]])) for h in helpers};tested=tuple(sorted(h for h,r in ranks.items() if r==1));need(len(tested)==18,'fresh all18 rank-one helpers') + need(all(values[h]=={h:F(1)} for h in tested),'fresh autonomous helper endpoint identities') + zeros={h:sorted(e for e,row in targets.items() if set(row)=={h}) for h in tested};neutral=tuple(h for h in tested if len(zeros[h])==1 and abs(len(w['frames'][w['program'][zeros[h][0]][2]])-len(w['frames'][w['program'][zeros[h][0]][3]]))==1);other=tuple(h for h in tested if h not in neutral) + need(len(neutral)==12 and other==NEW,'fresh12/6 partition') + need(all(P%d for d in range(2,math.isqrt(P)+1)),'prime');inverses={};membership={h:set() for h in tested};rank_sum=0;misses=0 + def mod(q): + if q.denominator not in inverses:need(q.denominator%P,'denominator');inverses[q.denominator]=pow(q.denominator,P-2,P) + return q.numerator*inverses[q.denominator]%P + for f,bank in banks.items(): + basis={} + for key,row in bank: + v={h:mod(q) for h,q in row.items() if mod(q)} + while v: + p=min(v) + if p not in basis: + inv=pow(v[p],P-2,P);basis[p]={h:q*inv%P for h,q in v.items()};break + q=v[p] + for h,a in basis[p].items(): + z=(v.get(h,0)-q*a)%P + if z:v[h]=z + else:v.pop(h,None) + need(len(basis)==len(bank),'ROW rank reaches exact row-count upper bound');rank_sum+=len(basis) + for h in tested: + v={h:1} + for p in sorted(basis): + if v.get(p): + q=v[p] + for j,a in basis[p].items(): + z=(v.get(j,0)-q*a)%P + if z:v[j]=z + else:v.pop(j,None) + if v:misses+=1 + else:membership[h].add(f) + need(rank_sum==7780 and len(banks)==979,'complete independent rank domain') + return dict(w=w,banks=banks,lookup=lookup,labels=labels,targets=targets,tested=tested,neutral=neutral,other=other,zeros=zeros,membership=membership,misses=misses) +def observation(o,frame,ctx): + need(o['frame']==frame,'observation exact coframe') + key=(o['event'],o['owner'],o['frame']);need(key in ctx['labels'] and o==ctx['labels'][key],'exact source observation label') + return key,ctx['lookup'][key] +def validate(data,ctx): + need(data['helpers_tested']==list(ctx['tested']) and data['neutral_rank1_helpers']==list(ctx['neutral']) and data['nonneutral_rank1_helpers']==list(ctx['other']),'complete fresh helper partition') + cases={c['helper']:c for c in data['cases']};need(len(cases)==len(data['cases'])==18 and set(cases)==set(ctx['tested']),'complete unique helper cases') + units=hits_count=0;decisions=[] + for h,c in sorted(cases.items()): + ds={d['frame']:d for d in c['coframes']};need(len(ds)==len(c['coframes'])==979 and set(ds)==set(ctx['banks']),'complete unique coframes') + inside={f for f,d in ds.items() if d['relation_in_final_span']};need(inside==ctx['membership'][h],'distinct-prime membership set') + derived={};circuit_zeros=set() + for frame in inside: + d=ds[frame];entries={};total={} + for item in d['unique_expression']: + key,row=observation(item['observation'],frame,ctx);q=F(item['coefficient']);need(q and key not in entries,'unique nonzero unit-expression entries');entries[key]=q;axpy(total,row,q) + need(total=={h:F(1)},'exact complete unit expression');units+=1 + latest=max(entries,key=lambda k:k[0]) + if latest[0]<0:need('latest_support_MOVE' not in d,'no invented initial latest MOVE');continue + event=latest[0];need(d.get('latest_support_MOVE')==event,'exact latest nonzero observation') + ins=ctx['w']['program'][event];need(ins[0]=='MOVE' and ins[1]==latest[1] and ins[3]==frame,'latest actual MOVE arrival') + q=entries[latest];providers={key:-a/q for key,a in entries.items() if key!=latest} + need(all(key[0]