diff --git a/research/p104-earlier-destination-cache-bound/ALL-HISTORY-PROOF.md b/research/p104-earlier-destination-cache-bound/ALL-HISTORY-PROOF.md new file mode 100644 index 0000000000..6a0b32987c --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/ALL-HISTORY-PROOF.md @@ -0,0 +1,142 @@ +# Every original same-coframe MOVE is an innovation + +The sole primary input is exact #7481 WORD.json.gz, SHA256 +`acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9`, +canonical payload `64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8`. +The independent engine reads no root prototype, precomputed ROWS receipt, +prior target rows or prior history generators. It freshly interprets all +76,475 instructions using sparse exact rational rows for all1,501 public +inputs and68 owned slots. Charts, strict native nesting, ownership flags, +coframed contacts, fresh COPY, lifetimes and endpoints are checked. + +## Complete final matrices imply every prefix innovation + +For each coframe, collect all original public initial rows in that coframe +and every MOVE arrival row in chronological order. Exact normalized MOVE +transport preserves the latent rational row, so its pre-MOVE target row is +the row appended at its destination. There are1,501 initial rows plus6,279 +arrivals,7,780 total, across979 nonempty coframe classes. The largest final +matrices have1,060 rows(frame3) and1,052 rows(frame127). + +The fresh exact-Q matrices are certified full ROW rank by a distinct +prime1000033 and sparse COLUMN elimination. The prime is verified by +exhaustive trial division. All575,804 stored rational entries have +invertible denominators at this prime; there are46 distinct denominators. +Every final matrix has modular rank equal to its literal row count. +Nonzero pivots supply a full-size nonzero minor over the prime field. +Because all rational denominators are invertible, the same minor is +nonzero over Q. Thus each exact rational final matrix has full row rank. +This is a full-rank certificate, not a modular nonmembership heuristic. + +Every chronological prefix is a subset of an independent final row set. +Consequently every one of the6,279 original MOVE targets lies outside its +strictly earlier destination history. Initials precede all events; a +candidate's own arrival is never included in its earlier history. + +Current same-coframe values remain in this history span: ADD/COPY/SCALE +form linear combinations; zero INIT adds no information; CLEAR or moving +out removes fields; each new arrival is recorded. The pool keeps every +historical value as if storage and normalization were free. This is more +information than an actual same-coframe cache need have. Phase/frame +aliases are overgranted normalized equivalences; no new physical adapter +admission is inferred. In this source the nonidentical alias1092 is unused. + +## Fresh maximal-neutral certificate + +The engine derives the neutral helper set from its own exact replay. A +helper is selected exactly when it has one singleton pure MOVE with paid +rank equal to its original target rank. The72 helpers and72 events are +freshly determined; no external neutral list is needed. + +Set all72 helper inputs to zero. Exactly144 observations vanish:72 initial +unit rows and72 MOVE arrivals. Every vanishing row is a nonzero multiple +of a SINGLE neutral-coordinate unit. Within each coframe these units have +distinct helper coordinates. All other rows remain nonzero. The projected +final matrices, after deleting exactly those144 zero rows, are independently +certified full row rank at the same distinct prime:7,636 rows total. +Thus all6,207 remaining nonzero MOVE targets are strict innovations under +the maximal restriction. + +The exact source paid/target histogram for the72 zero MOVEs is pointwise +identical: {1:12,2:8,3:24,4:4,5:18,6:1,7:4,8:1}. Every selected helper has +exactly one such occurrence. The initial observations have no MOVE credit. + +## Unit-extension lemma covers all2^72 subsets + +Fix any subset S of the neutral set N. In a coframe, divide the unrestricted +rows into general rows w_i whose maximal projections pi_N(w_i) are nonzero, +and maximally zero rows c_h e_h, with distinct h in that coframe. Under S, +the remaining row family is + + pi_S(w_i), together with c_h e_h for h in N minus S. + +Suppose a linear combination vanishes. Project further by pi_N. The unit +terms disappear and the certified independent pi_N(w_i) force every general +coefficient to zero. The remaining distinct coordinate units are independent, +so their coefficients also vanish. Therefore every subset-restricted final +coframe matrix, after deleting its actual zero rows, has full row rank. + +There are exactly|S| zero MOVEs and|S| zero initial rows: total nonzero row +rank7,780-2|S| and nonzero MOVE count6,279-|S|. All of those nonzero MOVE +targets are outside their earlier destination histories, at every public +AND owned cut. This is a proof for all subsets, not a finite subset census. +Pointwise zero-MOVE credit cancels the matching helper target debit for +every S. No extra nonzero cached deletion is enabled. + +Maximal-restriction nonmembership alone would NOT suffice. The explicit +counterexample history x+y,target x with N={x,y} has independent full rows +and no nonzero maximal projected rows, but zeroing only y enables the +nonzero target. Its maximally zero history is not a coordinate unit. The +production unit classifier rejects this control. Full original independence +and the distinct-unit property are retained as explicit hypotheses/data. + +## Any deterministic processing of these histories + +On the remaining arbitrary input field coordinates, a linear target outside +the history row span has an input direction annihilating every history row +but not the target. Compare that assignment with zero input: identical +histories, different targets. Therefore no deterministic function of those +histories, linear or nonlinear, recovers that nonzero target. For arbitrary +finite arrays, choose this scalar input direction times one nonzero entry +vector; all observed arrays remain zero and the target array differs. +No native tariff or dimension scaling is introduced. + +This scope uses arbitrary retained field inputs with coordinate-zero +restrictions. Finite-grid-only digit decoding, arbitrary nonlinear helper +promises, imported other-coframe information, changed operations/frames, +changed providers, partially cached jobs and newly decoded target types are +outside this result. Physical public zero reframe, allocation and complete +supplier admission remain separate. No changed source or kappa is claimed. + +## Reproduction and controls + +The package verify.py runs both the incremental prime1000003 engine and this +independent exact-Q/final-matrix column engine at prime1000033. Both freshly +derive the72 helpers and72 zero MOVE events from the primary source. The +independent core all_history_independent.py also exposes verify(source) and +controls(), both read-only. To reproduce the complete per-coframe pivot +certificates without saving them inside the package: + +```sh +python3 -I -W error -B research/p104-earlier-destination-cache-bound/all_history_independent.py research/p104-earlier-destination-cache-bound/inputs/WORD.json.gz +``` + +The full output contains every row label, exact rational matrix hash, zero-unit +record and modular pivot-column certificate. The main package checker reports +a compact digest and compares the two methods' complete counts, neutral sets, +zero-event lists and price histograms. Matrices are rebuilt from source rather +than stored as another large input snapshot. + +The independent controls include126 dense-row/sparse-column rank comparisons +and seven rejected failures: invalid prime/denominator, duplicate rows, naive +modular nonmembership after rank loss, missing zero-row deletion, repeated zero +units and the x+y all-subsets pitfall. The author engine checks every strict +cut before arrival and all6279 membership controls after the arrival, plus its +own rank-drop and nonunit counterexamples. Both reject altered source bytes. +All tests use explicit exceptions that remain active under python -O. + +The universal all-subsets and deterministic-provider conclusions follow from +the written proofs above, not the finite toy controls. VALIDATION.json records +executed normal/optimized and read-only Git-free export checks. Prepared for +Jerry Chen / @CubeJerry with substantial OpenAI assistance, retained source +credit, and no independent human or formal-kernel acceptance. diff --git a/research/p104-earlier-destination-cache-bound/INFORMATION-PROOF.md b/research/p104-earlier-destination-cache-bound/INFORMATION-PROOF.md new file mode 100644 index 0000000000..ae717360e5 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/INFORMATION-PROOF.md @@ -0,0 +1,125 @@ +# Information obstruction and main-only separator extension + +## Exact statements and scope + +The original proof establishes rational nonmembership in the cumulative +strictly earlier destination history at all 47 owned cuts and 18 additional +public cuts with live-source witnesses. This extension makes two implications +explicit. First, those nonmembership results exclude arbitrary deterministic +postprocessing of the stated history, not only scalar linear cache programs. +Second, at **33 of the 47 owned cuts**, an explicit separator supported solely +on the 400 main inputs makes the obstruction persist under every nonempty +restriction on helper inputs that is independent of the arbitrary mains. + +The native history, source operations and whole-field frame interpretation are +fixed. A cache may use any number of private fields and any fixed computation, +but its only input-dependent information must come from the tested earlier +destination-coframe observations. Additional input reads, transported stock, +other charts, input-dependent metadata, changed native histories and main-dependent +helper preparation are outside the claim. No new kappa is asserted. + +## From rational nonmembership to indistinguishable histories + +Let A be the rational matrix of all earlier destination-coframe latent rows, +and let c be the latent row the omitted MOVE must deliver. Nonmembership +`c not in rowspan_Q(A)` supplies a rational vector t with `A t=0` and +`c t != 0`. Clearing its denominators gives an integer t with the same +properties. Every native input denotes an arbitrary complete array. Set the +difference between two input assignments to `Delta X_h=t_h z`, where z is any +nonzero permitted complete array. + +The difference in every observation is zero. The destination coframe is the +same at each observation, so applying its full invertible frame operator +preserves this zero difference, including absolute phase and spectators. The +required target difference is the same invertible operator applied to +`(c t) z`, which is nonzero. A deterministic function receiving identical +ordered observations and fixed program metadata returns identical results; +it cannot produce both different targets. This allows arbitrary nonlinear +or operator-valued processing and arbitrary internal storage. It does not +grant extra observations outside the stated information interface. + +The algebraic assertion holds on the full rational or complex input-array +space. On a prescribed exact digital grid it requires two legal assignments +with the indicated difference and representable targets. Integer t ensures +the cancellations are exact; it does not by itself establish a complete +physical width or recovery theorem. The universal input contract supplies +the usual arbitrary-array domain; a new restricted numerical domain must +separately establish this legal-direction premise. The five selected +foundational assumptions remain retained. + +## Main-only separators survive helper restrictions + +For each of the 33 certified cuts, t has support only among the actual main +coordinates. Fix any permitted helper assignment, however correlated or +nonzero it is, and use it in both executions. Vary only the mains by t z. +Linearity of the unchanged native program makes every destination-history +difference zero while its target difference is nonzero. Thus the argument +does not require that the helper restriction be homogeneous, contain zero, +be a scalar graph, or preserve any particular helper target. It requires +that at least one fixed helper assignment remain available for both main +inputs. A rule whose helper values depend on the mains is outside this claim. + +In particular, restricting or correlating helpers alone cannot create an +earlier-history provider at these 33 cuts. This is an information statement, +independent of the price charged for those restrictions or source retirement. +The other 14 owned cuts are not excluded by these main-only certificates. +Neither a later-source test nor exact-zero cleanup is required by this +earlier-destination obstruction. + +## Independently checkable certificates + +`MAIN-PROBES.json` contains the 33 integer separators, their exact owned +MOVE/owner/source/destination identities, destination subspaces, and nonzero +target values. Its SHA256 is +`440b45249eb28596d2dbcfcff5e13dd9c9f435c6f6303aff22e2207a6b1a5aa5`. +The source is the same exact #7481 native used by the rest of this package. +The cuts are + +``` +30529 30537 30551 32939 33125 33133 33140 33142 33149 34524 34528 +35443 36324 36328 36336 39553 39581 39727 39785 39814 39820 39853 +40538 40556 40563 40567 41491 42005 42477 42482 44244 44251 45638 +``` + +The discovery implementation used fresh exact row replay and a separate +rational backsolve after taking only these candidate IDs from the first +projection screen. The published checker does **no span elimination**. It +reconstructs the main partition and canonical GF(2) frames from the source, +binds every advertised owner and frame to the actual instruction, and sets +each main input to the 33-vector of certificate values. All helper differences +are zero. It then executes all 76,475 literal instructions by rational scalar +arithmetic, checking every strictly earlier coframed bank operation and +arrival and each nonzero target. This directly proves `A t=0` and `c t!=0` +without trusting discovery ranks, bases or the certificate's history ranks. + +The runtime checks include 2,901 bank-value assertions. Its five executed +mutants change the actual destination, forge its subspace, replace the main +probe with a helper-supported probe, make the probe zero, and incorrectly +include the query's own arrival in its earlier history. They fail at the +specific binding, target or history check. All source-byte readers also +reject an altered native file; normal and optimized registered executions +must agree. The certificate is checked as exact bytes and every scientific +claim about those bytes is regenerated. A read-only export needs no Git. + +## Owned erasure is a separate interface + +A zero-clear two-cache schedule can be a sufficient implementation pattern; +it is not asserted to be necessary for the retained owned-erasure contract. +The original native interpreter permits nonzero owned rows at CLEAR, and +the selected application retains allocation, completed-return, erasure and +physical cost obligations. Consequently a failed later-source provider is +only a failed condition for a specified zero-cleanup pattern. All cache +exclusions claimed here instead use the missing **earlier destination** +information, so they do not rely on zero-before-CLEAR being mandatory. + +## Credit and remaining obligations + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance. +Credit Clear1nsight #7481, ToikY #7308, Jonathan Capalbo #6069 and all retained +native, caller, frame and ownership lineage. The explicit probes, separate +direct-input verifier and scoped information extension are this run's work; +linear duality and indistinguishability are standard arguments. No independent +human or proof-kernel review is claimed. Changed histories, main-dependent +preparation and physically priced providers at the 14 remaining cuts remain +research questions. No source implementation or full multiplication improvement +has been established by this extension. diff --git a/research/p104-earlier-destination-cache-bound/LICENSE b/research/p104-earlier-destination-cache-bound/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-earlier-destination-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-earlier-destination-cache-bound/MAIN-PROBES.json b/research/p104-earlier-destination-cache-bound/MAIN-PROBES.json new file mode 100644 index 0000000000..6a9df34b99 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/MAIN-PROBES.json @@ -0,0 +1,797 @@ +{ + "status": "COMPLETE_INDEPENDENT_FULL_NATIVE_REPLAY", + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "A_candidate_id_source_sha256": "45d580c2b5c691564dba5fa27cd00496178e79e34918bfa59032dfb5020481d1", + "candidate_event_ids_only_from_A": [ + 30529, + 30537, + 30551, + 32939, + 33125, + 33133, + 33140, + 33142, + 33149, + 34524, + 34528, + 35443, + 36324, + 36328, + 36336, + 39553, + 39581, + 39727, + 39785, + 39814, + 39820, + 39853, + 40538, + 40556, + 40563, + 40567, + 41491, + 42005, + 42477, + 42482, + 44244, + 44251, + 45638 + ], + "main_coordinate_count": 400, + "main_coordinates_sha256": "52270be5ea0af1c794b4c79db188eb0fbd0b921ae51298b7aa41b50ebd99e6aa", + "candidate_count": 33, + "candidate_probes": [ + { + "event": 30529, + "owner": 1510, + "source_frame": 477, + "destination_frame": 1090, + "destination_key": [ + 45, + 75, + 137, + 265 + ], + "history_rank": 8, + "main_separator": [ + [ + 4, + 1 + ] + ], + "target_dot": "-1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 30537, + "owner": 1520, + "source_frame": 1090, + "destination_frame": 470, + "destination_key": [ + 75, + 137, + 265 + ], + "history_rank": 4, + "main_separator": [ + [ + 4, + 1 + ] + ], + "target_dot": "-1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 30551, + "owner": 1521, + "source_frame": 470, + "destination_frame": 601, + "destination_key": [ + 137 + ], + "history_rank": 2, + "main_separator": [ + [ + 4, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 32939, + "owner": 1529, + "source_frame": 267, + "destination_frame": 1091, + "destination_key": [ + 11, + 21, + 38, + 448 + ], + "history_rank": 7, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 33125, + "owner": 1528, + "source_frame": 543, + "destination_frame": 541, + "destination_key": [ + 4, + 8, + 17, + 34, + 64, + 131, + 256 + ], + "history_rank": 5, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "-1/2", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 33133, + "owner": 1514, + "source_frame": 1091, + "destination_frame": 260, + "destination_key": [ + 11, + 51, + 448 + ], + "history_rank": 5, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 33140, + "owner": 1502, + "source_frame": 541, + "destination_frame": 534, + "destination_key": [ + 4, + 8, + 17, + 34, + 64, + 387 + ], + "history_rank": 3, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "-1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 33142, + "owner": 1502, + "source_frame": 534, + "destination_frame": 117, + "destination_key": [ + 8, + 17, + 34, + 68, + 391 + ], + "history_rank": 1, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "-1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 33149, + "owner": 1502, + "source_frame": 117, + "destination_frame": 594, + "destination_key": [ + 25 + ], + "history_rank": 3, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "-1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 34524, + "owner": 1513, + "source_frame": 517, + "destination_frame": 243, + "destination_key": [ + 22, + 37, + 67, + 392 + ], + "history_rank": 7, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 34528, + "owner": 1518, + "source_frame": 243, + "destination_frame": 431, + "destination_key": [ + 22, + 67, + 392 + ], + "history_rank": 4, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 35443, + "owner": 1519, + "source_frame": 431, + "destination_frame": 600, + "destination_key": [ + 67 + ], + "history_rank": 3, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 36324, + "owner": 1512, + "source_frame": 518, + "destination_frame": 240, + "destination_key": [ + 13, + 19, + 70, + 416 + ], + "history_rank": 8, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "-1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 36328, + "owner": 1516, + "source_frame": 240, + "destination_frame": 394, + "destination_key": [ + 13, + 85, + 435 + ], + "history_rank": 4, + "main_separator": [ + [ + 1, + 1 + ] + ], + "target_dot": "-1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 36336, + "owner": 1517, + "source_frame": 394, + "destination_frame": 598, + "destination_key": [ + 491 + ], + "history_rank": 1, + "main_separator": [ + [ + 1, + 1 + ] + ], + "target_dot": "-1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 39553, + "owner": 1539, + "source_frame": 243, + "destination_frame": 517, + "destination_key": [ + 2, + 4, + 8, + 16, + 33, + 65, + 128, + 256 + ], + "history_rank": 8, + "main_separator": [ + [ + 8, + 1 + ] + ], + "target_dot": "-1/16", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 39581, + "owner": 1538, + "source_frame": 240, + "destination_frame": 518, + "destination_key": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "history_rank": 8, + "main_separator": [ + [ + 1, + 1 + ] + ], + "target_dot": "-1/8", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 39727, + "owner": 1526, + "source_frame": 531, + "destination_frame": 529, + "destination_key": [ + 1, + 10, + 20, + 32, + 64, + 128, + 262 + ], + "history_rank": 2, + "main_separator": [ + [ + 5, + 1 + ] + ], + "target_dot": "-1/2", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 39785, + "owner": 1548, + "source_frame": 529, + "destination_frame": 531, + "destination_key": [ + 1, + 4, + 10, + 16, + 32, + 64, + 128, + 258 + ], + "history_rank": 4, + "main_separator": [ + [ + 5, + 5 + ], + [ + 8, + -4 + ], + [ + 9, + -4 + ], + [ + 10, + -4 + ], + [ + 164, + 2 + ] + ], + "target_dot": "-1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 39814, + "owner": 1503, + "source_frame": 529, + "destination_frame": 520, + "destination_key": [ + 1, + 10, + 20, + 32, + 64, + 390 + ], + "history_rank": 2, + "main_separator": [ + [ + 5, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 39820, + "owner": 1503, + "source_frame": 520, + "destination_frame": 595, + "destination_key": [ + 52 + ], + "history_rank": 9, + "main_separator": [ + [ + 0, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 39853, + "owner": 1515, + "source_frame": 260, + "destination_frame": 599, + "destination_key": [ + 448 + ], + "history_rank": 4, + "main_separator": [ + [ + 0, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 40538, + "owner": 1549, + "source_frame": 549, + "destination_frame": 559, + "destination_key": [ + 1, + 2, + 4, + 16, + 40, + 72, + 128, + 256 + ], + "history_rank": 1, + "main_separator": [ + [ + 1, + 1 + ], + [ + 142, + 1 + ] + ], + "target_dot": "1/2", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 40556, + "owner": 1527, + "source_frame": 559, + "destination_frame": 549, + "destination_key": [ + 2, + 5, + 16, + 40, + 73, + 128, + 256 + ], + "history_rank": 8, + "main_separator": [ + [ + 1, + 1 + ] + ], + "target_dot": "1/2", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 40563, + "owner": 1501, + "source_frame": 549, + "destination_frame": 115, + "destination_key": [ + 7, + 42, + 75, + 144, + 272 + ], + "history_rank": 4, + "main_separator": [ + [ + 1, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 40567, + "owner": 1501, + "source_frame": 115, + "destination_frame": 593, + "destination_key": [ + 7 + ], + "history_rank": 9, + "main_separator": [ + [ + 1, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 41491, + "owner": 1537, + "source_frame": 1090, + "destination_frame": 477, + "destination_key": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "history_rank": 7, + "main_separator": [ + [ + 15, + 1 + ] + ], + "target_dot": "5/16", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 42005, + "owner": 1531, + "source_frame": 594, + "destination_frame": 117, + "destination_key": [ + 8, + 17, + 34, + 68, + 391 + ], + "history_rank": 5, + "main_separator": [ + [ + 129, + 1 + ], + [ + 131, + -1 + ] + ], + "target_dot": "-1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 42477, + "owner": 1504, + "source_frame": 591, + "destination_frame": 1031, + "destination_key": [ + 12, + 18, + 33, + 64, + 391 + ], + "history_rank": 4, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 42482, + "owner": 1504, + "source_frame": 1031, + "destination_frame": 597, + "destination_key": [ + 82 + ], + "history_rank": 6, + "main_separator": [ + [ + 2, + 1 + ] + ], + "target_dot": "1/4", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 44244, + "owner": 1550, + "source_frame": 541, + "destination_frame": 543, + "destination_key": [ + 1, + 4, + 8, + 16, + 34, + 64, + 130, + 256 + ], + "history_rank": 3, + "main_separator": [ + [ + 4, + 7 + ], + [ + 129, + -2 + ] + ], + "target_dot": "1", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 44251, + "owner": 1531, + "source_frame": 117, + "destination_frame": 534, + "destination_key": [ + 4, + 8, + 17, + 34, + 64, + 387 + ], + "history_rank": 4, + "main_separator": [ + [ + 899, + 1 + ] + ], + "target_dot": "2", + "history_dot_claim": "zero by exact backsolve" + }, + { + "event": 45638, + "owner": 1551, + "source_frame": 1091, + "destination_frame": 267, + "destination_key": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "history_rank": 7, + "main_separator": [ + [ + 0, + 1 + ] + ], + "target_dot": "-1/4", + "history_dot_claim": "zero by exact backsolve" + } + ], + "event_count": 76475, + "last_event": 76474, + "operation_counts": { + "INIT": 74, + "ADD": 66321, + "SCALE": 3726, + "MOVE": 6279, + "CLEAR": 74, + "COPY": 1 + }, + "construction": "Every native row was replayed over all 1501 public input columns first; each observation was then projected to the independently reconstructed 400-main set. A separate dense exact-Q echelon/backsolve produced integer null vectors.", + "scope": "33 strict earlier-destination-history nonmembers in the main-only projection; no 14-hit cases or full all-column cache admission examined." +} diff --git a/research/p104-earlier-destination-cache-bound/NOTICE b/research/p104-earlier-destination-cache-bound/NOTICE new file mode 100644 index 0000000000..4133e92165 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/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-earlier-destination-cache-bound/NOTICE-ADDENDUM b/research/p104-earlier-destination-cache-bound/NOTICE-ADDENDUM new file mode 100644 index 0000000000..c544ea2b27 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/NOTICE-ADDENDUM @@ -0,0 +1,12 @@ +Earlier destination-cache exclusion +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +The original NOTICE is retained byte-for-byte and applies to the native input. +New exact relation-kernel screen, history replays, proofs and integration are +provided under Apache-2.0. Credit the originating #7481 native and lineage, +ToikY #7308 and Jonathan Capalbo #6069 for their prior scoped exclusions. +Independent review denotes separate algorithmic evidence, not human acceptance. + +The all-history extension adds separate chronological-row and final-column +certificates, the distinct-unit neutral-subset lemma, and executed rank/unit +controls. These new proofs and implementations retain the same Apache-2.0 +license and Jerry Chen / CubeJerry and OpenAI assistance attribution. diff --git a/research/p104-earlier-destination-cache-bound/PINS.json b/research/p104-earlier-destination-cache-bound/PINS.json new file mode 100644 index 0000000000..b3f49417db --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/PINS.json @@ -0,0 +1,47 @@ +{ + "native": { + "pr": 7481, + "path": "inputs/WORD.json.gz", + "sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "format": "gzip-compressed native JSON" + }, + "notice": { + "path": "NOTICE", + "sha256": "78e060cbd33ebc4078cabf39e50191a977fb9eb5c41104533079e22da1d9d248", + "copied_from": "reference/pr7481/NOTICE" + }, + "related_scope": { + "path": "RELATED-SCOPE.json", + "sha256": "911799b3858879626ad12d8e07effe35c9533211a93cd5f13ac0d4bf774dbd1d", + "pr6069_info": "inputs/pr6069-info.json", + "pr6069_info_sha256": "35bcb3413929ef9a7165ba02e50cb9c94ba2592b3a0f04b39393193d02226b5d", + "pr6069_merged_head": "b3f5aabddbae2d65f80bb8356e6993e0a65cd245" + }, + "review_code": { + "kernel_screen.py": { + "sha256": "a5679864dfe2f658eab10dba16676f5911928ab51b2075ae3431a59e729fb1ee", + "adapted_from_worker_b_sha256": "20df40df17b3863822a3e73b8e7753d32f6930783c5f5e68a6e726d569026135" + }, + "history_filter.py": { + "sha256": "b409b752c3fd055f35fe0dc07210df1c00d7bb0ad91bfd7ac27105befcb91ab2", + "adapted_from_worker_b_sha256": "cec542c6c64b61926eb1dd2e84058d23473849a7957da0a5620939dfc39ef203" + }, + "history_exact.py": { + "sha256": "c84094457be184aaa67698bc61e53bed94f729f2b79f048a53b902b8bf793b60", + "adapted_from_worker_c_review_sha256": "6204794f461d86243057a3ab7d51225e3ef253128c4456be09edfa4164d42d16" + }, + "prefilter_controls.py": { + "sha256": "31a4752a33251cd948c3b5182dcf5d379e52e0acc596f1cf0bc5cd76edb4cfe1", + "adapted_from_worker_c_review_sha256": "faa7e99170dc647007e21ba9cafa13872ac8e1c92d9e3789d73fd95c47ff7d9b" + }, + "VALIDATION.json": { + "sha256": "747d696e41d7cd6712e4477e951aaa804fe59f3444bdb57dd99796cb5b7471c1" + }, + "PROOF.md": { + "sha256": "cbe6fd2a3294c1fed00355d3e999824acbfbf4ef131b5a8ce28b77656ac9ebaf" + }, + "verify.py": { + "sha256": "2708207c4af239d5be7f880a61db11a9f8515ea9d8bc27b0c09db7a6f0045478" + } + } +} diff --git a/research/p104-earlier-destination-cache-bound/PR-DESCRIPTION.md b/research/p104-earlier-destination-cache-bound/PR-DESCRIPTION.md new file mode 100644 index 0000000000..65572dfd49 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/PR-DESCRIPTION.md @@ -0,0 +1,76 @@ +## Complete all-transfer and neutral-subset extension + +Every one of the **6,279 original MOVEs** in the exact #7481 native is outside its strictly earlier destination-coframe history when the 1,501 original inputs are arbitrary. This includes all public and owned cuts, with no live-source reconstruction premise. The complete coframe observation matrices have **7,780 independent rows across 979 coframes**. + +The result also holds after **every subset of 72 neutral helper inputs is set to zero**. Exactly one MOVE and one initial observation vanish per chosen helper; every remaining MOVE is still an innovation. Saved whole-MOVE prices cancel the corresponding original helper target debits pointwise. The universal subset conclusion follows from a written distinct-coordinate-unit extension lemma; it is not inferred from a finite subset search. The earlier 65-cut diagnostic and 33 main-only certificates below remain complementary evidence. + +Two fresh source interpretations use different algorithms: chronological row elimination at prime 1,000,003 and exact rational final matrices with sparse column elimination at prime 1,000,033. Modular rank equals each entire literal generator count, yielding a nonzero rational minor; modular nonmembership alone is explicitly rejected. The second engine checks 575,804 rational entries and 46 distinct denominators. Both derive the neutral helpers from the source independently. + +Controls include source-byte rejection in eight engines, 6,279 strict-before/after-arrival queries, seven independent rank/unit failure controls and 126 small row/column cross-checks. The nonunit example `history=x+y, target=x` rejects the false inference from maximal zeroing alone. Normal, optimized and read-only Git-free export results are in `VALIDATION.json`; use the registered reproduction command below. + +Original instructions, coframes and whole target fields are fixed. New imported information, changed paid-carrier histories, nonneutral helper promises, main-dependent encodings, partial outputs, finite-grid digit decoders and new decoded target types remain outside the theorem. A free public zero reframe is not an existing admitted opcode; zero-MOVE credit is only an optimistic upper bound. **No new kappa**, physical supplier, recurrence, selected certificate or discharged foundational assumption is claimed. The next useful obligation is fully priced preparation and owner return for a nonneutral public-cache promise, or an explicitly changed earlier carrier supplying new information. + +## Retained owned-cut and main-only results + +Exclude earlier destination-cache reconstruction at **every one of the 47 owned +MOVEs** in the exact #7481 native, and at **all 18 public cuts with a live source +reconstruction**. These are 65 distinct cuts. The owned result has no live-source +premise: deferred source cleanup cannot fix the missing destination value. + +For these 65 cuts, all 1,501 public inputs remain arbitrary. The screen pools every +strictly earlier coframed native observation. A linear-duality information argument +excludes arbitrary deterministic postprocessing whose only input-dependent data +come from that history, with preparation, storage and cleanup free. + +At **33 owned cuts**, explicit integer separators are supported on main inputs +alone. Those obstructions survive every nonempty helper-only restriction +independent of the arbitrary mains, even correlated or nonzero helpers. The +other 14 cuts remain outside this stronger result. The proof states the legal +input-direction requirement for a prescribed exact grid. +**No new kappa** or unconditional multiplication theorem is claimed. + +## Novelty, pins and evidence + +#7308 checks live destination banks at the 47 owned clocks on #7277. #6069 treats +an older #6030 word: 4,033 leaking injection classes including dynamic affine +closure, 764 incoming-only intervals, and five private rank-four output seams. +This contribution credits those actual scopes and adds the complete later-word +cumulative-history test, the temporal owned extension and main-only information +certificates. Later-source failure is only diagnostic for a sufficient +zero-cleanup pattern; no necessity is imposed on general owned erasure. + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +Exact unselected #7481 head: `89eaa9d8cae37c1540de98f2d29a3abaabb96a2b`. +Original paths, blobs and SHA256 pins are in `SOURCES.json`; scientific input +bytes are bundled. + +```sh +python3 scripts/research_package.py --package research/p104-earlier-destination-cache-bound +``` + +Expected status: `PASS_P104_EARLIER_DESTINATION_CACHE_EXCLUSION`. +The complete exact relation-kernel census covers all 6,279 MOVEs. Two distinct +rational history engines check all 49 live-source survivors, their exact witnesses +and history ranks. Two temporal replays cover the additional 16 owned cuts and +independently replay all 47 owned cuts. The latter finds exactly 31 genuine +later-source memberships, providing positive controls. Every one of the 76,475 +instructions is replayed. Source-byte mutations, inserted-arrival controls and +44 independent synthetic donor queries detect false acceptance and rejection. +Normal, optimized and read-only Git-free export checks are in `VALIDATION.json`. +The 33 main-only certificates are also checked by literal simultaneous scalar +input replay without elimination. All owner/frame/main-support bindings and +2,901 bank-value assertions pass; wrong destination/coframe, helper-supported, +zero-probe and inclusive-arrival mutants fail through the actual verifier. + +## Limits and credit + +The native history is unchanged. Helper restrictions at the remaining 14 owned +cuts, main-dependent preparation, incoming transported stock, changed earlier +native operations and a complete physical supplier remain open. +All five foundational assumptions remain. No selected certificate is changed. + +Prepared for **Jerry Chen / @CubeJerry** with substantial **OpenAI assistance** +in research, separate exact implementations, review and packaging. Retain +Clear1nsight #7481 and its lineage, ToikY #7308, Jonathan Capalbo #6069 and all +original notices. No independent human or proof-kernel acceptance is claimed. +The complete proof and open questions are in the package. diff --git a/research/p104-earlier-destination-cache-bound/PROOF.md b/research/p104-earlier-destination-cache-bound/PROOF.md new file mode 100644 index 0000000000..4b28856591 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/PROOF.md @@ -0,0 +1,200 @@ +# Earlier destination-history exclusion for #7481 + +## Original source-reconstructible claim + +For the frozen 76,475-instruction #7481 native word, none of the 49 MOVE +owners whose current value is exactly reconstructible from the other live +rows in its source coframe can be reconstructed from the cumulative span of +all rows observed in its destination coframe strictly before that MOVE. +There are 18 public and 31 owned candidates, with ranks +`{1:21, 2:12, 3:5, 4:9, 5:2}`. The result is an exact scalar-history +nonmembership screen, not an unconditional lower bound or a supplier change. + +## Source and overlap + +The bundled compressed word is byte-for-byte pinned by SHA256 +`acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9`. +Its original `NOTICE` is retained byte-for-byte. The source-bound screen uses +the normalized latent-row semantics of the retained #7481 native word: ADD, +COPY and nonzero SCALE are exact linear row operations; INIT/CLEAR give zero; +MOVE changes a row's chart and leaves the normalized latent row unchanged. + +Earlier work is credited with its actual scopes. #7308 checks the 47 paid +owned MOVE clocks on #7277 against other values live in each fixed destination +chart. #6069 covers the unchanged #6030 word and reports 4,033 leaking +unit-injection classes (including dynamic affine closure of its two remaining +cases), 764 incoming-only MOVE intervals, and five private rank-four query +outputs tested against other live destination-chart values at their immediate +output seam. This package covers every source-span MOVE survivor on the later +#7481 word and the full cumulative destination-coframe history at each cut. +The original component is this 49-cut unchanged-history screen; the temporal +extension below additionally covers all 47 owned MOVEs. Neither component asserts that #6069 lacked all earlier-history or dynamic affine reasoning. +See `RELATED-SCOPE.json` and `inputs/pr6069-info.json` for the pinned overlap +record. + +## Exact method + +The source prefilter keeps the full rational relation kernel among all live +normalized rows. For an owner `a` and same-coframe donor set `D`, the value is +in `span(D)` exactly when the current relation kernel contains a relation +with nonzero coefficient at `a` and support contained in `D ∪ {a}`. The +scanner projects relations outside that allowed set, carries the full +relation along an exact rational echelon basis, and detects precisely such a +projected dependency. Its relation updates are the exact changes for INIT, +ADD/COPY, nonzero SCALE and CLEAR; MOVE preserves latent rows. The moving owner +is excluded from its donor set. Live bank membership is keyed by equality of +the complete GF(2) frame subspace, not by literal frame ID. + +For each candidate destination class `B`, the history basis starts with all +public entrance rows at `B`. Every nonzero MOVE arrival at `B` is added after +its move. At a candidate cut, membership is tested before changing its chart +or adding the current arrival. This cumulative span contains every earlier +actual coframed bank: initial public rows are included, MOVE arrivals are +inserted, INIT/CLEAR yield zero, and coframed ADD/COPY/SCALE preserve linear +span. Pooling rows from different earlier times only enlarges the tested +span, so its zero hits exclude any one earlier bank as a source of the target +row. No simultaneously available multi-chart cache is inferred. + +The original 49-cut component runs three pieces: the exact source-kernel screen; the streaming +exact history filter; and an independent direct exact-rational forward replay +using a separate GF(2) frame canonicalizer and low-pivot Q echelon basis. Both +history engines agree on all 49 strict-before decisions and on each cut's +history rank. The direct replay also reconstructs all 49 source witnesses. +The small independent source-kernel controls compare seven synthetic +relation-space states with a direct rational nullspace, check 44 owner/donor +span decisions and verify 19 emitted witnesses. They include INIT, ADD, +COPY-zero, negative SCALE, dirty-coordinate, CLEAR, singular-prefix and +redundant-frame controls. + +The source prefilter covers all 6,279 MOVE events through event 76,474: +6,214 public source-span misses and 18 public survivors, plus 16 owned misses +and 31 owned survivors. The history screen uses 40 destination subspaces, +55 initial public generators and 1,410 nonzero MOVE arrivals, for 1,465 +independent history generators. It checks 29,874 coframed ADDs, 1,404 SCALEs +and one COPY by the exact linearity argument. All 49 candidates are outside +their strict-before destination history; there are zero hits. + +## Reproduce + +Run from any working directory with CPython 3.12 and the standard library: + +```sh +python3 -I -B research/p104-earlier-destination-cache-bound/verify.py +python3 -I -B -O research/p104-earlier-destination-cache-bound/verify.py +``` + +Each command regenerates source and history bases in memory, takes under 180 +seconds in the reviewed environment, and writes only its compact JSON receipt +to standard output. It does not write or modify package files. The two modes +returned the same receipt. The 3 MB generator log and the 1.5 MB source census +log are not bundled. + +## Limits + +The conclusion applies to the exact pinned word, arbitrary independent public +inputs as represented by its normalized linear rows, the stated exact scalar +operations, and one earlier destination-coframe cache. It does not cover +imported external stock, changed earlier operations or histories, correlated +inputs, multi-chart stock, a physical cache construction, or an unrelated source-map rewrite. The temporal +extension below removes the live-source premise for owned movers; it still requires +a destination value from the unchanged earlier history. No new kappa, complete supplier admission or unconditional multiplication +proof is claimed. All five foundational assumptions remain. + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance in +research, separate implementations, review and packaging. Retain the original +NOTICE and NOTICE-ADDENDUM; no independent human acceptance is claimed. + +## Relation-kernel completeness lemma + +Let Y have the live normalized owner rows as its rows, and let +K = {c : c^T Y = 0}. Initially the public rows are independent, so K is zero. +An INIT appends a zero row and hence a new unit relation. For an ADD +`row_a <- row_a + q row_b`, contragredience changes every relation by +`c_b <- c_b - q*c_a`; nonzero SCALE changes `c_a <- c_a/q`. +COPY into a certified zero destination is that same invertible ADD update. +MOVE changes only the chart inventory. On CLEAR, relations among the remaining +owners are exactly the restrictions of `K intersect {c_a=0}`; eliminating +one nonzero a-pivot, if present, computes that intersection exactly. +These rules prove by induction that the scanner retains the complete kernel, +even when a public prefix has lost rank. + +For donor set D excluding a, write A=D union {a}. The wanted witness exists +exactly when the projection of K outside A has a kernel vector with nonzero +a-coordinate. Gaussian elimination of those projected rows, while carrying +the full relations, returns generators of this projection kernel. Such a +linear combination has a nonzero a-coordinate iff at least one returned +generator does. Normalizing by `-1/c_a` gives the reconstruction coefficients. +This proves completeness of the prefilter; the bounded independent nullspace +controls corroborate its implementation rather than replace this argument. + +## Optimistic budget interpretation + +The screen grants all cache preparation, preservation, basis normalization, +ordinary copying and eventual restoration free. It preserves the native public +input/output map and its productive inventory. Even this favorable mechanism +cannot replace a paid MOVE at a cut passing the required live-source premise, +because no corresponding destination value is in the earlier history span. +Adding complete implementation costs cannot rescue an absent provider. +This is a necessary-condition obstruction for that mechanism; it is not a +priced replacement word or a new full caller calculation. + + +## Temporal extension: all 47 owned MOVEs + +The complete owned candidate set is read directly from the literal word, with no +source-span prefilter. It has 47 cuts. The same strictly earlier destination span +is tested at every cut, independently of how the source owner might eventually be +cleared. All 47 tests fail. + +For an additional strictly later source test, start each source coframe span with +the final public rows in that coframe. Scan native events backwards, adding the +row just before every strictly later departure MOVE and CLEAR in that coframe. +An ADD with distinct operands and a nonzero SCALE preserve the entire current +coframed bank span; COPY into zero is the same invertible ADD operation. INIT only +adds zero. The recorded departures and retirements therefore span every strictly +later native bank, by reverse induction. At cut E, add only events with index >E; +the candidate's own departure at E is deliberately excluded. The final bank is +included as the terminal cut. + +Exactly 31 of the 47 owned rows belong to this future source span. These are +precisely the 31 live-source reconstructible cuts from the complete kernel census. +Their donors remain available immediately after the MOVE, so these are genuine +positive controls for the future-history computation. All 16 remaining owned +cuts fail both past-destination and future-source tests; their rank histogram is +`{1:6, 2:1, 3:1, 4:5, 5:2, 6:1}`. + +The author extension uses high-pivot exact rational elimination, independent +history-generator witnesses and the frozen frame-span routine. The independent +extension replays the whole source afresh, enumerates each GF(2) frame's at most +512 elements as its class key, and uses low-pivot rational elimination without +history witness reuse. It checks all 47 past and future decisions. For the 16 +new cuts, both engines agree on every full rational target row and both history +ranks, not just the final failure counts. For the remaining 31, the earlier +49-cut dual replay and the full source-kernel census provide separate checks. +All 47 independent past queries also recognize the target after inserting its +otherwise unavailable arrival into a cloned basis; existing basis members and +the 31 actual future memberships test the positive side. + +### Arbitrary ordinary caches in one fixed coframe + +Fix a destination coframe B and a cut E. Let H_B(E) be the span of its native +public entrances and native MOVE arrivals with event index strictly below E. +Every earlier native B row lies in H_B(E), by the forward induction already +proved. Any finite network of auxiliary B fields initialized at zero, read-only +copies of such native observations, and coframed rational ADD/COPY/SCALE operations +also stays inside H_B(E), by a second induction on the auxiliary operations. +Holding a field across many native clocks, combining observations taken at different +times, changing the number of auxiliary fields, or delaying source cleanup does +not enlarge this span. All such preparation and storage is granted free here. + +Since each of the 47 owned target rows is outside its respective H_B(E), no such +cache network supplies that owned MOVE's destination value. This obstruction +holds regardless of a live or future source witness. Together with the 18 public +source-reconstructible cases, the package proves 65 distinct earlier-destination +exclusions. It does not infer a general impossibility for correlated inputs, +external stock, extra transported values, changed native histories, or other +nonlinear/state-dependent operation classes. + +No changed word or complete caller bill is emitted: the optimistic construction +already lacks a necessary provider. The temporal extension changes neither selected +certificates nor the accepted kappa. diff --git a/research/p104-earlier-destination-cache-bound/README.md b/research/p104-earlier-destination-cache-bound/README.md new file mode 100644 index 0000000000..b1f927fc8c --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/README.md @@ -0,0 +1,119 @@ +# Every original P104 MOVE is a strict history innovation + +On the exact #7481 native, **all6279 public and owned MOVE targets lie outside +their strictly earlier destination histories**. The complete979 coframe +matrices have7780 independent initial/arrival rows. Independent exact-Q and +prime-field reconstruction methods certify this universal finite-source claim. + +The same statement holds for **every subset S of the72 derived neutral helpers +set to zero**: exactly|S| original MOVEs become zero, and the other6279−|S| +remain innovations. Every zero MOVE's rank matches its lost helper target rank, +so their prices cancel pointwise and no nonzero history-cache deletion is added. +The all2^72 conclusion uses a proved distinct-coordinate-unit extension lemma; +it is not an exhaustive subset experiment. ALL-HISTORY-PROOF.md gives the proof. + +The earlier65-cut, source-prefilter and temporal certificates remain included +as separate checks and diagnostics. In particular, the33 main-only owned-cut +separators below survive arbitrary main-independent helper promises, a stronger +input scope than the coordinate-zero theorem for those33 cuts. + +The complete source screen covers all 6,279 MOVEs. Its 18 public and 31 owned +survivors fail the earlier-history test. A separately checked temporal extension +covers the remaining 16 owned cuts, and also shows that those 16 lack a strictly +later source-coframe provider. The other 31 owned cuts correctly pass the later +source test, supplying genuine positive controls. + +A cumulative history includes observations from different times. Its failure +excludes arbitrary deterministic caches whose only input-dependent observations +come from that unchanged native history, +even with arbitrarily many zero-initialized cache fields, free storage, free +ordinary scalar operations and deferred source cleanup. No extra incoming +transport, external stock or changed input promise is allowed in this scope. +**No new kappa**, source implementation or supplier admission is claimed. + +At **33 owned cuts**, explicit integer separators use only main inputs. +The information obstruction therefore survives every nonempty helper-only +restriction independent of the arbitrary mains, including correlated and +nonzero helper assignments. The other 14 owned cuts remain outside this stronger +result. `INFORMATION-PROOF.md` states the exact input-domain qualifications. + +## Evidence and reproduction + +A complete rational relation kernel supplies the live-source census. Two exact +history implementations agree at all 49 source-reconstructible cuts, reconstruct +their witnesses and compare per-cut history ranks. The original screen covers +40 destination subspaces and 1,465 independent generators. + +The temporal extension adds an author high-pivot rational replay of the 16 +remaining owned cuts and a separate low-pivot exact replay of all 47 owned cuts. +The latter independently enumerates GF(2) frame spans, checks all 16 target rows, +both temporal decisions and both history ranks, and finds exactly the expected +31 genuine later-source witnesses. It uses 32 past and 32 future coframe classes. +All 76,475 native instructions are replayed. No floating rank decision is used. +The 33 main-only certificates also pass a direct rational input replay with no +span solver: every earlier bank difference is zero and every target difference +is nonzero. Actual owners, source/destination frames and main support are bound +to the word; wrong-coframe, helper-supported, zero-probe and off-by-one mutants +are rejected through the real verifier. + +```sh +python3 -I -W error -B research/p104-earlier-destination-cache-bound/verify.py +python3 -O -I -W error -B research/p104-earlier-destination-cache-bound/verify.py +python3 scripts/research_package.py --package research/p104-earlier-destination-cache-bound +``` + +Expected status: `PASS_P104_EARLIER_DESTINATION_CACHE_EXCLUSION`. +The standard-library replay uses bundled exact source bytes, regenerates histories +in memory and writes only a compact stdout receipt. It needs no Git or network. +`VALIDATION.json` records the executed normal/optimized and portability checks. + +Controls include seven independent synthetic nullspaces, 44 direct donor queries, +19 exact witnesses, existing history members, deliberately inserted arrivals at +all 47 owned cuts, and the 31 genuine later-source members. All eight source readers +reject changed bytes; every check remains active under optimized Python. +The full-history extension independently rebuilds all1501 initial observations +and6279 arrivals. One method uses incremental row elimination modulo1000003 +with exact-Q zero supports. The other freshly builds full rational matrices +and proves their full row ranks by column elimination modulo1000033. A modular +miss alone is never promoted to characteristic-zero nonmembership. The new +controls include126 dense-row/column comparisons, bad primes/denominators, rank +drop, repeated units and the maximal-zero shortcut counterexample. + +## Pins, novelty and limits + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +Exact unselected #7481 head: `89eaa9d8cae37c1540de98f2d29a3abaabb96a2b`. +Native SHA256: `acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9`. +The original paths, Git blobs and hashes are in `SOURCES.json`; the source NOTICE +is retained byte-for-byte. + +#7308 checks live destination banks at all 47 owned MOVE clocks on #7277. +#6069 treats the older #6030 word: 4,033 leaking injection classes, including +dynamic affine closure; 764 incoming-only intervals; and five private rank-four +query output seams. This package adds the complete later-word cumulative-history +screen, owned temporal extension, all-MOVE full-rank certificate and all-neutral-subsets theorem. It does not claim earlier research lacked +dynamic or historical reasoning generally. `PROOF.md` gives the exact arguments. + +## Open next questions + +Can nonneutral helper restrictions or correlations enable a useful public +destination provider after fully charging lost productive targets and all new +boundaries? All subsets of the72 pointwise-neutral helpers are now excluded. +The separately published joint helper/owned-cache funding package bounds the +combined owned-cache route; it does not supply an actual source or close every +nonneutral input-interface question. Can imported stock +or changed earlier native operations do so with a favorable complete bill? Those +changes alter the tested history or arbitrary-input space. Their preparation, +transport, ownership, exact precision and full caller costs remain +separate obligations. Deferred source cleanup alone cannot remove the missing +destination provider for any of the 47 owned cuts. All five foundations remain. +Later-source membership is diagnostic for the sufficient zero-cleanup pattern, +not a necessary condition asserted for every retained owned-erasure service. + +## Credit + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance in research, +separate exact implementations, adversarial review and packaging. Retain the #7481 +native/caller lineage, ToikY #7308, Jonathan Capalbo #6069 and original notices. +Independence means algorithmic cross-checking, not human or formal-kernel acceptance. +Apache-2.0; see LICENSE and NOTICE-ADDENDUM. diff --git a/research/p104-earlier-destination-cache-bound/RELATED-SCOPE.json b/research/p104-earlier-destination-cache-bound/RELATED-SCOPE.json new file mode 100644 index 0000000000..a4eccf8926 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/RELATED-SCOPE.json @@ -0,0 +1,18 @@ +{ + "retrieved_utc_date": "2026-11-13", + "pr7308": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7308", + "title": "Exclude live destination-bank reuse for P104 owned MOVEs (0% kappa change)", + "scope_note": "On unchanged #7277, test each of 47 paid owned MOVE clocks against all other live rows in its original destination chart; the page summarizes #6069 as live destination spans on an older complex word.", + "head": "2c777389ec0476e97ab141c645af01ff28a46aa6" + }, + "pr6069": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6069", + "metadata_file": "inputs/pr6069-info.json", + "metadata_file_sha256": "35bcb3413929ef9a7165ba02e50cb9c94ba2592b3a0f04b39393193d02226b5d", + "merged_head": "b3f5aabddbae2d65f80bb8356e6993e0a65cd245", + "word": "unchanged #6030", + "scope_note": "4,033 leaking unit-injection classes (dynamic affine closure excludes the two remaining cases); 764 incoming-only MOVE intervals; five private rank-four query outputs excluded from other live destination-chart values at the immediate output seam." + }, + "scope_excerpt_sha256": "9ef55b399019a4f06488e5456a3940642ceb4f56824f707475210f3db102ffc4" +} diff --git a/research/p104-earlier-destination-cache-bound/SOURCES.json b/research/p104-earlier-destination-cache-bound/SOURCES.json new file mode 100644 index 0000000000..84993a9c49 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/SOURCES.json @@ -0,0 +1,79 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + } + ], + "bundled_external_inputs": [ + { + "path": "research/p104-earlier-destination-cache-bound/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", + "source_git_blob": "77df4ad624f4ed3d4bb5e08b4ac1891534d2261d", + "sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" + }, + { + "path": "research/p104-earlier-destination-cache-bound/NOTICE", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "source_path": "research/p104-funded-485-1455-return/NOTICE", + "source_git_blob": "4133e9216529e7a1dbceb092a05db2300305d102", + "sha256": "78e060cbd33ebc4078cabf39e50191a977fb9eb5c41104533079e22da1d9d248" + } + ], + "dependency_policy": "All scientific runtime inputs are bundled exact bytes. No foreign Git objects, network or previous result dump is required. Original PR heads are provenance, not claimed ancestors of this contribution.", + "predecessors": [ + { + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/7481", + "head": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "role": "Exact unselected native source and full retained NOTICE." + }, + { + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/7308", + "head": "2c777389ec0476e97ab141c645af01ff28a46aa6", + "role": "All47 owned live-destination-bank exclusions on #7277; retired caches and changed lifetimes outside its declared scope." + }, + { + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/6069", + "head": "b3f5aabddbae2d65f80bb8356e6993e0a65cd245", + "role": "Earlier #6030 fixed-word injection, incoming-interval and private-query exclusions; full overlap summary in RELATED-SCOPE.json." + } + ], + "retrieved_metadata": [ + { + "path": "research/p104-earlier-destination-cache-bound/inputs/pr6069-info.json", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6069", + "sha256": "35bcb3413929ef9a7165ba02e50cb9c94ba2592b3a0f04b39393193d02226b5d", + "role": "Directly retrieved PR metadata and scope, not executable proof input." + } + ], + "generated_certificates": [ + { + "path": "research/p104-earlier-destination-cache-bound/MAIN-PROBES.json", + "sha256": "440b45249eb28596d2dbcfcff5e13dd9c9f435c6f6303aff22e2207a6b1a5aa5", + "role": "Independently derived main-only integer separators; every identity reverified by literal scalar replay without elimination." + } + ], + "all_history_extension": { + "source_input": "inputs/WORD.json.gz", + "methods": [ + "Independent fresh exact-Q final coframe matrices; full-size nonzero minors at prime1000033 through sparse column elimination.", + "Incremental prime1000003 history row elimination, with a separate exact-Q source support replay." + ], + "external_generated_inputs": [], + "independent_core_sha256": "ddad7c43a02b3df025dba8dd31ea866079cf61ddd00c5f6e1af40461798cf207", + "proof_scope": "Every original whole MOVE and every subset of the72 pointwise-neutral helper coordinates; fixed original normalized maps/history. No new kappa." + } +} diff --git a/research/p104-earlier-destination-cache-bound/TASK.json b/research/p104-earlier-destination-cache-bound/TASK.json new file mode 100644 index 0000000000..af226d47d9 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/TASK.json @@ -0,0 +1,113 @@ +{ + "schema_version": 1, + "task_id": "scalar-to-moment", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "scalar-to-moment", + "question": "Can a scalar/frame rewrite improve the complete signed moment through paid jobs, productive targets, or both?", + "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", + "docs/research/recursive-invoice-preflight.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": "Require a legal chronological rewrite and favorable complete signed target-minus-paid moment with all extra charges. Unchanged ADD counts or unchanged paid-call counts alone decide neither success nor failure. Compiler, native and outer admission remain separate obligations.", + "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": "Construct one legal source-bound rewrite and compare complete before/after P and T. Charge restoration, source windows and owned helpers. A paid call need not disappear: a legal target split or rank redistribution may win. Stop if the signed moment is unchanged or the consumer repays the gain. Do not extend a scalar-only census on ADD counts.", + "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": [ + "signed moment", + "target split", + "rank exchange", + "scalar rewrite" + ], + "existing_checks": [ + { + "scope": "PR #3998: consecutive A2 scalar contraction", + "evidence": "research/staged544-a2-graph-rewrite/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "389268a6b5e0373a3125d5c6fcd6995f4ea324f5", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4019: separated A2 sites with unchanged recursive histogram", + "evidence": "research/staged544-separated-a2/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "f408e09df300b575235f7f77f81948071397e16d", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4112: composition audit", + "evidence": "research/staged544-a2-composition-audit/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "205b7380656ba4b6316a8a493b1a3c679b8f7a0e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4152: A1858 contraction audit", + "evidence": "research/staged544-a1858-contraction-audit/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "caaa14cde5962adc372fdca71f63d0f29e73c8b2", + "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": "Prove all6279 original public/owned MOVEs miss their strict earlier destination histories, using full final-matrix independence; prove the same for every nonzero MOVE after any subset of72 derived neutral helpers is zeroed. Retain earlier65-cut temporal/source diagnostics and33 main-only separators for arbitrary main-independent helper promises.", + "scope_change_reason": "A complete independent final-matrix certificate extends the earlier65-cut statement to all6279; distinct coordinate-unit maximal zeros permit a rigorous all2^72 subset lift.", + "bottleneck_link": "Every unchanged original history lacks its target; even all subsets of72 neutral restrictions create only equally debited zero jobs and no nonzero cache gain.", + "budget_minutes": 45, + "stop_rule": "Finish complete source census and past/future independent exact checks. Do not claim correlated inputs, imported stock, changed native histories or a general cache impossibility.", + "outcome": "negative-result", + "evidence": "ALL-HISTORY-PROOF.md; independent exact-Q final matrices with prime1000033 column minors; incremental prime1000003 histories with exact-Q zero support; all previous source/history and33 input-probe evidence. Both fresh neutral sets, zero lists and price histograms agree.", + "author": "Jerry Chen / CubeJerry", + "ai_assistance": "Substantial OpenAI assistance in exact research, separate source/history implementations, adversarial mathematical review and packaging. No independent human or proof-kernel acceptance.", + "open_questions": [ + { + "question": "Can nonneutral helper correlations enable useful public-MOVE caches after complete target and physical costs?", + "why_it_matters": "They change the arbitrary-input space and can collapse a nonzero history quotient.", + "first_step": "Specify the exact restriction, compute quotient membership and charge every productive direction lost, source/cleanup child and ordinary operation.", + "blocked_by": "Every neutral72 subset is excluded; the joint owned-cache funding envelope is separately proved. Nonneutral public-provider physical interfaces remain unconstructed." + }, + { + "question": "Can imported stock or a changed earlier native history produce a useful cache?", + "why_it_matters": "Only observations of the unchanged pinned native are included.", + "first_step": "Specify the changed producer, exact arbitrary-input identity and complete source/receiver bill.", + "blocked_by": "New preparation, transport, storage, ownership, precision and cleanup costs remain." + } + ] +} diff --git a/research/p104-earlier-destination-cache-bound/VALIDATION.json b/research/p104-earlier-destination-cache-bound/VALIDATION.json new file mode 100644 index 0000000000..cfbcec6424 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/VALIDATION.json @@ -0,0 +1,616 @@ +{ + "extension": "All6279 original innovations, maximal-neutral6207 innovations and full7780/7636 row ranks; two source interpretations and distinct primes; written unit-extension lemma proves all2^72 subsets. Retains33 main-only direct probes. No new kappa.", + "normal_optimized_export_semantic_receipts_equal": true, + "portable_export": { + "declared_inputs_checked": 3, + "empty_path": true, + "exit_code": 0, + "files": 27, + "git_free": true, + "package_bytes_and_modes_unchanged": true, + "read_only_modes": true, + "seconds": 137.29, + "status": "PASS_READ_ONLY_GIT_FREE_EMPTY_PATH_EXPORT", + "stderr_empty": true, + "stdout_sha256": "2713f87fe5630d9e58c095721c2dba29ea9abf3110a6fd2c64b9bea2df522450", + "tested_commit": "88e2f4aaa77433ca5f486a826dae10386865207b" + }, + "registered_normal_and_optimized": "PASS_REGISTERED_RESEARCH_PACKAGE", + "scientific_receipt": { + "all_history_and_neutral_subsets": { + "all_subsets": "Every subset of the 72 derived neutral helpers, by the written unit-extension proof.", + "author": { + "all_subsets": "2^72 by written unit-extension lemma, not exhaustive enumeration", + "maximal_neutral": { + "exact_zero_MOVEs": 72, + "final_total_history_rank": 7636, + "prime": 1000003, + "queries": 6279, + "query_digest": "cdf3000add5c7e75a5ef0579ebef752cd67b325ef258d94bac2c700eda343fde", + "rational_nonmembership_certified": 6207, + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "strict_before_arrival_controls": 6279 + }, + "neutral_helpers": [ + 76, + 115, + 231, + 345, + 450, + 455, + 459, + 462, + 463, + 480, + 481, + 493, + 503, + 514, + 515, + 556, + 593, + 607, + 623, + 647, + 649, + 696, + 708, + 713, + 718, + 721, + 722, + 727, + 741, + 748, + 751, + 753, + 754, + 771, + 1028, + 1209, + 1211, + 1213, + 1217, + 1218, + 1219, + 1220, + 1223, + 1225, + 1231, + 1237, + 1246, + 1252, + 1301, + 1333, + 1350, + 1351, + 1353, + 1354, + 1355, + 1356, + 1357, + 1358, + 1359, + 1390, + 1393, + 1437, + 1443, + 1448, + 1478, + 1480, + 1485, + 1486, + 1487, + 1496, + 1499, + 1500 + ], + "neutral_paid_histogram": { + "1": 12, + "2": 8, + "3": 24, + "4": 4, + "5": 18, + "6": 1, + "7": 4, + "8": 1 + }, + "neutral_target_histogram": { + "1": 12, + "2": 8, + "3": 24, + "4": 4, + "5": 18, + "6": 1, + "7": 4, + "8": 1 + }, + "nonunit_all_subsets_shortcut_rejected": true, + "status": "PASS_ALL_HISTORY_INCREMENTAL_RATIONAL_CERTIFICATE", + "unrestricted": { + "exact_zero_MOVEs": 0, + "final_total_history_rank": 7780, + "prime": 1000003, + "queries": 6279, + "query_digest": "914ce79e3477f2d89fede59def92943175fad3e2c409dbf350b8253a44fd83dd", + "rational_nonmembership_certified": 6279, + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "strict_before_arrival_controls": 6279 + }, + "writes_files": false, + "zero_MOVE_events": [ + 30540, + 31351, + 32126, + 32136, + 32951, + 33001, + 33250, + 33670, + 33792, + 34645, + 34944, + 34953, + 34960, + 34976, + 34986, + 34996, + 35006, + 35013, + 35022, + 35031, + 35039, + 35126, + 35129, + 35436, + 35683, + 36333, + 36398, + 36438, + 36452, + 36514, + 36973, + 36983, + 38003, + 38611, + 38726, + 39445, + 39960, + 40134, + 43661, + 45508, + 45525, + 45706, + 45801, + 45836, + 45844, + 46676, + 46841, + 47123, + 47227, + 47340, + 48158, + 48202, + 48628, + 48865, + 48894, + 48907, + 49009, + 49095, + 49195, + 49520, + 51637, + 51716, + 58942, + 58979, + 76463, + 76464, + 76465, + 76466, + 76467, + 76468, + 76469, + 76470 + ], + "zero_units_distinct_within_each_coframe": true + }, + "independent": { + "MOVE_arrivals": 6279, + "all_2_pow72_subsets_follow_from_unit_extension_lemma": true, + "all_denominators_invertible": true, + "coframes_with_observations": 979, + "distinct_rational_denominators": 46, + "event_counts": { + "ADD": 66321, + "CLEAR": 74, + "COPY": 1, + "INIT": 74, + "MOVE": 6279, + "SCALE": 3726 + }, + "exact_projected_matrix_collection_sha256": "14dd847ad133384eda62ee81541ea049bf5741c12017500effba3ebc804e8aad", + "exact_source_matrix_collection_sha256": "c1dfe4aafe6246d81ea3bf95a4753cf87878d69f885d26622a12265ccc183c5a", + "full_per_coframe_certificates_sha256": "6d749241a6b68707828b9882ee42ff8572db7b5d05a1348f767df7ebab94f26e", + "helpers": 1101, + "initial_observations": 1501, + "instructions": 76475, + "main_inputs": 400, + "max_neutral_nonzero_row_rank": 7636, + "neutral_helpers": [ + 76, + 115, + 231, + 345, + 450, + 455, + 459, + 462, + 463, + 480, + 481, + 493, + 503, + 514, + 515, + 556, + 593, + 607, + 623, + 647, + 649, + 696, + 708, + 713, + 718, + 721, + 722, + 727, + 741, + 748, + 751, + 753, + 754, + 771, + 1028, + 1209, + 1211, + 1213, + 1217, + 1218, + 1219, + 1220, + 1223, + 1225, + 1231, + 1237, + 1246, + 1252, + 1301, + 1333, + 1350, + 1351, + 1353, + 1354, + 1355, + 1356, + 1357, + 1358, + 1359, + 1390, + 1393, + 1437, + 1443, + 1448, + 1478, + 1480, + 1485, + 1486, + 1487, + 1496, + 1499, + 1500 + ], + "neutral_paid_histogram": { + "1": 12, + "2": 8, + "3": 24, + "4": 4, + "5": 18, + "6": 1, + "7": 4, + "8": 1 + }, + "neutral_target_histogram": { + "1": 12, + "2": 8, + "3": 24, + "4": 4, + "5": 18, + "6": 1, + "7": 4, + "8": 1 + }, + "nonzero_projected_MOVEs": 6207, + "original_total_row_rank": 7780, + "prime": 1000033, + "prime_verified_by_exhaustive_trial_division": true, + "rational_entries_checked": 575804, + "scope": "Whole original MOVE targets and strictly earlier same-coframe histories under arbitrary retained field inputs. Any neutral-helper subset zero. No new source/frames/providers, finite-grid nonlinear decoder claim, physical supplier or kappa.", + "source_payload_sha256": "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8", + "source_prototype_inputs_used": false, + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "status": "EXACT_Q_ALL_COFRAME_HISTORY_INNOVATIONS_CERTIFIED_BY_DISTINCT_PRIME_COLUMNS", + "zero_MOVE_events": [ + 30540, + 31351, + 32126, + 32136, + 32951, + 33001, + 33250, + 33670, + 33792, + 34645, + 34944, + 34953, + 34960, + 34976, + 34986, + 34996, + 35006, + 35013, + 35022, + 35031, + 35039, + 35126, + 35129, + 35436, + 35683, + 36333, + 36398, + 36438, + 36452, + 36514, + 36973, + 36983, + 38003, + 38611, + 38726, + 39445, + 39960, + 40134, + 43661, + 45508, + 45525, + 45706, + 45801, + 45836, + 45844, + 46676, + 46841, + 47123, + 47227, + 47340, + 48158, + 48202, + 48628, + 48865, + 48894, + 48907, + 49009, + 49095, + 49195, + 49520, + 51637, + 51716, + 58942, + 58979, + 76463, + 76464, + 76465, + 76466, + 76467, + 76468, + 76469, + 76470 + ], + "zero_MOVE_rows": 72, + "zero_initial_rows": 72, + "zero_rows_distinct_units_within_each_coframe": true + }, + "independent_controls": { + "all_failure_controls_rejected": true, + "failure_controls": [ + { + "control": "composite_modulus", + "rejected": true + }, + { + "control": "noninvertible_rational_denominator", + "reason": "rational denominator invertible at certificate prime", + "rejected": true + }, + { + "control": "duplicate_row", + "rejected": true + }, + { + "control": "modular_miss_without_full_history_rank", + "rejected": true + }, + { + "control": "maximal_zero_nonsingleton_x_plus_y_history_target_x", + "reason": "maximally zero observation is a single neutral-coordinate unit", + "rejected": true + }, + { + "control": "repeated_maxzero_coordinate_within_coframe", + "reason": "zero unit rows have distinct neutral coordinates within coframe", + "rejected": true + }, + { + "control": "forgot_to_delete_exact_projected_zero_row", + "rejected": true + } + ], + "independent_small_matrix_row_column_crosschecks": 126, + "prime": 1000033, + "read_only_no_source_replay": true, + "status": "PASS_READ_ONLY_INDEPENDENT_ALL_HISTORY_CONTROLS" + } + }, + "all_original_earlier_destination_exclusions": 6279, + "all_owned_temporal": { + "cuts": 47, + "earlier_destination_hits": 0, + "future_subspaces": 32, + "inserted_arrival_controls": 47, + "later_source_hits": 31, + "past_subspaces": 32, + "separately_checked_new_cuts": 16 + }, + "candidate_ranks": { + "1": 21, + "2": 12, + "3": 5, + "4": 9, + "5": 2 + }, + "candidate_source_witnesses_reconstructed": true, + "coframed_scalar_operations": { + "ADD": 29874, + "COPY": 1, + "SCALE": 1404 + }, + "destination_subspaces": 40, + "history_engines": "exact Fraction streaming filter and independent direct Fraction replay agree at all 49 strict-before cuts", + "history_hits": 0, + "independent_history_generators": 1465, + "initial_public_history_generators": 55, + "instructions": 76475, + "main_only_history_separators": { + "bank_checks": 2901, + "certificate_sha256": "440b45249eb28596d2dbcfcff5e13dd9c9f435c6f6303aff22e2207a6b1a5aa5", + "cuts": 33, + "earlier_arrivals": [ + 25, + 4, + 2, + 11, + 7, + 8, + 3, + 17, + 4, + 12, + 4, + 3, + 18, + 4, + 2, + 13, + 12, + 6, + 4, + 2, + 15, + 5, + 1, + 9, + 18, + 12, + 13, + 22, + 21, + 6, + 3, + 4, + 7 + ], + "events": 76475, + "main_coordinates": 400, + "method": "direct simultaneous rational scalar inputs; no span elimination", + "negative_controls": [ + "wrong destination", + "wrong coframe", + "helper-supported probe", + "zero separator", + "own arrival incorrectly earlier" + ], + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "status": "PASS_MAIN_ONLY_HISTORY_SEPARATORS", + "target_values": [ + "-1", + "-1", + "1/4", + "1", + "-1/2", + "1", + "-1/4", + "-1/4", + "-1/4", + "1", + "1", + "1/4", + "-1", + "-1", + "-1/4", + "-1/16", + "-1/8", + "-1/2", + "-1", + "1/4", + "1/4", + "1/4", + "1/2", + "1/2", + "1/4", + "1/4", + "5/16", + "-1", + "1/4", + "1/4", + "1", + "2", + "-1/4" + ] + }, + "moves": 6279, + "nonzero_move_arrivals": 1410, + "notice_sha256": "78e060cbd33ebc4078cabf39e50191a977fb9eb5c41104533079e22da1d9d248", + "output": "stdout only; no package files written", + "prefilter_controls": { + "controls": { + "add": true, + "clear_intersection": true, + "copy_zero_guard": true, + "dependent_clear": true, + "dirty_coordinate_rejection": true, + "exact_rational_witnesses": true, + "gf2_redundant_frame_alias": true, + "init_zero": true, + "negative_scale": true, + "owner_exclusion": true, + "singular_prefix": true + }, + "exact_bank_predicates_checked": 44, + "exact_witnesses_verified": 19, + "source_helper_sha256": "a5679864dfe2f658eab10dba16676f5911928ab51b2075ae3431a59e729fb1ee", + "status": "PASS", + "synthetic_direct_kernel_comparisons": 7 + }, + "source_mutation_rejected_by_eight_engines": true, + "source_prefilter": { + "owned_misses": 16, + "owned_survivors": 31, + "public_misses": 6214, + "public_survivors": 18 + }, + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "status": "PASS_P104_EARLIER_DESTINATION_CACHE_EXCLUSION", + "union_earlier_destination_exclusions": 65 + }, + "source_history_note": "Exact canonical base e54523517d0f03e58352e647c403a5af3e525a57. Extension follows verified remote796b03407d4d05da0390ebc6b28ab98a98c4fa6d; ancestry is checked by GitHub commit parents, not inferred from shallow local history.", + "status": "PASS_REGISTERED_PAIR_AND_READ_ONLY_EXPORT", + "tested_scientific_commit": "88e2f4aaa77433ca5f486a826dae10386865207b" +} diff --git a/research/p104-earlier-destination-cache-bound/VERIFY.json b/research/p104-earlier-destination-cache-bound/VERIFY.json new file mode 100644 index 0000000000..6b7c960488 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/VERIFY.json @@ -0,0 +1,38 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-earlier-destination-cache-bound/inputs/WORD.json.gz", + "research/p104-earlier-destination-cache-bound/NOTICE", + "research/p104-earlier-destination-cache-bound/MAIN-PROBES.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 240, + "checks": "All6279 source-bank cuts; dual exact history at49 source survivors; dual temporal extension at16 other owned cuts; independent all47 owned past/future replay,31 true future members,47 arrival controls; exact target rows, history ranks, source mutation and independent kernel controls. Direct scalar verification of33 main-only separators, actual coframe/owner/main-support binding, and five executed certificate/history mutants. All6279 original and6207 maximal-neutral innovations, full7780/7636 row-rank certificates from two primes and independent row/column methods, exact72 target cancellations, unit-extension prerequisites and seven independent failure controls." + }, + { + "argv": [ + "{python}", + "-O", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 240, + "checks": "All6279 source-bank cuts; dual exact history at49 source survivors; dual temporal extension at16 other owned cuts; independent all47 owned past/future replay,31 true future members,47 arrival controls; exact target rows, history ranks, source mutation and independent kernel controls. Direct scalar verification of33 main-only separators, actual coframe/owner/main-support binding, and five executed certificate/history mutants. All6279 original and6207 maximal-neutral innovations, full7780/7636 row-rank certificates from two primes and independent row/column methods, exact72 target cancellations, unit-extension prerequisites and seven independent failure controls." + } + ] +} diff --git a/research/p104-earlier-destination-cache-bound/all_history_author.py b/research/p104-earlier-destination-cache-bound/all_history_author.py new file mode 100644 index 0000000000..d456ab00c0 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/all_history_author.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python3 +"""Incremental modular history certificates with exact-Q zero-support replay. +A modular miss is lifted only with a generator-count rank upper bound. +""" +from collections import Counter, defaultdict +from hashlib import sha256 +from fractions import Fraction +from pathlib import Path +from math import isqrt +import gzip +import json + +ROOT = Path(__file__).resolve().parent +PRIME = 1000003 +PIN = "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def add(row, other, q): + for h, a in other.items(): + v = (row.get(h, 0)+q*a) % PRIME + if v: + row[h] = v + else: + row.pop(h, None) + + +def reduce(row, basis): + row = row.copy() + while row: + p = min(row) + if p not in basis: + break + add(row, basis[p], -row[p]) + return row + + +def insert(row, basis): + v = reduce(row, basis) + if v: + p = min(v) + q = pow(v[p], -1, PRIME) + basis[p] = {h: q*a % PRIME for h, a in v.items()} + + +def certifies_miss(row, basis, generators): + return bool(reduce(row,basis)) and len(basis)==generators + + +def frame_key(f): + s = {0} + for v in f: + s |= {u ^ v for u in s} + return tuple(sorted(s)) + + +def run_mode(source, neutral_mode, neutral, exact_zero_events): + need(all(PRIME % d for d in range(2, isqrt(PRIME)+1)), "prime modulus") + raw = Path(source).read_bytes() + need(sha256(raw).hexdigest() == PIN, "native source pin") + w = json.loads(gzip.decompress(raw)) + queries = {i: dict(event=i, literal=e, + rank=abs(len(w["frames"][e[2]])-len(w["frames"][e[3]]))) + for i,e in enumerate(w["program"]) if e[0]=="MOVE"} + frames = list(map(frame_key, w["frames"])) + banks = {f: {} for f in frames} + generator_count = {f: 0 for f in banks} + n = w["public"] + zero_record_pin = None + if not neutral_mode: + neutral, exact_zero_events = set(), set() + rows = [{h: 1} if h not in neutral else {} for h in range(n)]+[None]*w["owned_fields"] + current = w["initial"].copy()+[None]*w["owned_fields"] + for h, f in enumerate(w["initial"]): + if frames[f] in banks: + insert(rows[h], banks[frames[f]]) + generator_count[frames[f]] += bool(rows[h]) + scalars = {} + done = [] + hits = [] + controls = 0 + complete = True + for event, ins in enumerate(w["program"]): + op, a = ins[:2] + if op == "MOVE": + old, new = ins[2:4] + need(current[a] == old and rows[a] is not None, "MOVE source") + if event in queries: + bank = banks[frames[new]] + if event in exact_zero_events: + need(not rows[a], "exact zero event reduces to zero") + hit = not reduce(rows[a], bank) + record = dict(event=event, literal=ins, rank=queries[event]["rank"], + history_rank_mod_prime=len(bank), hit_mod_prime=hit, + original_history_generator_count=generator_count[frames[new]], + rational_nonmembership_certified=certifies_miss(rows[a], bank, generator_count[frames[new]]), + zero_mod_prime=not rows[a]) + done.append(record) + if hit: + hits.append(record) + current[a] = new + if frames[new] in banks: + insert(rows[a], banks[frames[new]]) + generator_count[frames[new]] += event not in exact_zero_events + if event in queries: + need(not reduce(rows[a], banks[frames[new]]), "inserted-arrival control") + controls += 1 + elif op == "INIT": + need(a >= n and current[a] is None and rows[a] is None, "INIT") + current[a], rows[a] = ins[2], {} + elif op == "CLEAR": + need(a >= n and current[a] == ins[2] and rows[a] is not None, "CLEAR") + current[a], rows[a] = None, None + else: + value = ins[2] if op == "SCALE" else ins[3] + if value not in scalars: + q = Fraction(value) + need(q.denominator % PRIME and q.numerator % PRIME, "valid nonzero scalar reduction") + scalars[value] = q.numerator*pow(q.denominator, -1, PRIME) % PRIME + q = scalars[value] + if op == "SCALE": + need(current[a] == ins[3], "SCALE chart") + rows[a] = {h: q*x % PRIME for h, x in rows[a].items()} + elif op in ("ADD", "COPY"): + b = ins[2] + need(a != b and current[a] == current[b] == ins[4], "ordinary chart") + if op == "COPY": + need(a >= n and not rows[a], "COPY zero destination") + add(rows[a], rows[b], q) + else: + raise ValueError("unknown instruction") + if complete: + need(current == w["final"]+[None]*w["owned_fields"], "complete final map") + need(len(done) == len(queries), "all selected queries completed") + need(complete and len(done)==6279, "all6279 original MOVE queries") + expected = 6207 if neutral_mode else 6279 + need(sum(x["rational_nonmembership_certified"] for x in done)==expected, + "full characteristic-zero nonmembership coverage") + need(all(x["event"] in exact_zero_events for x in hits), "no nonzero history hit") + need(sum(generator_count.values())==(7636 if neutral_mode else 7780), + "exact final generator-count rank totals") + # Rank-drop counterexample: a rational nonzero row may vanish modulo p. + vanished_history = {h:v%PRIME for h,v in {0:PRIME}.items() if v%PRIME} + rank_dropped_bank = {}; insert(vanished_history,rank_dropped_bank) + need(reduce({0:1},rank_dropped_bank) and not certifies_miss({0:1},rank_dropped_bank,1), + "modular history-rank drop must not be lifted to rational nonmembership") + return dict(source_sha256=PIN,prime=PRIME,queries=6279, + rational_nonmembership_certified=expected,exact_zero_MOVEs=len(exact_zero_events), + final_total_history_rank=sum(generator_count.values()), + strict_before_arrival_controls=controls, + query_digest=sha256(json.dumps(done,sort_keys=True,separators=(",",":")).encode()).hexdigest()) + + +def exact_neutral_data(source): + raw=Path(source).read_bytes();need(sha256(raw).hexdigest()==PIN,"native exact-Q source pin") + w=json.loads(gzip.decompress(raw));n=w['public'];main=set(w['live'])|{h+112 for h in w['live']}|set(w['hosted']['X2'])|set(w['hosted']['Y2']);helpers=set(range(n))-main + need((len(main),len(helpers))==(400,1101),"exact main/helper partition") + target={h:abs(len(w['frames'][w['final'][h]])-len(w['frames'][w['initial'][h]])) for h in helpers} + rows=[{h:Fraction(1)} for h in range(n)]+[None]*w['owned_fields'];current=w['initial'].copy()+[None]*w['owned_fields'] + pure=defaultdict(list);supports={};coframes={};keys=list(map(frame_key,w['frames'])) + for event,e in enumerate(w['program']): + op,a=e[:2] + if op=='MOVE': + need(current[a]==e[2] and rows[a],"exact MOVE source") + r=abs(len(w['frames'][e[2]])-len(w['frames'][e[3]]));supports[event]=(set(rows[a]),r);coframes[event]=keys[e[3]] + if len(rows[a])==1: + h=next(iter(rows[a])) + if h in helpers:pure[h].append((event,r)) + current[a]=e[3] + elif op=='INIT': + need(a>=n and current[a] is None and rows[a] is None,"exact INIT") + current[a],rows[a]=e[2],{} + elif op=='CLEAR': + need(a>=n and current[a]==e[2] and rows[a] is not None,"exact CLEAR") + current[a],rows[a]=None,None + elif op=='SCALE': + need(current[a]==e[3] and Fraction(e[2]),"exact SCALE frame") + rows[a]={h:Fraction(e[2])*v for h,v in rows[a].items()} + elif op in ('ADD','COPY'): + b=e[2];need(a!=b and current[a]==current[b]==e[4],"exact scalar coframes") + if op=='COPY':need(a>=n and not rows[a],"exact COPY") + q=Fraction(e[3]) + for h,v in rows[b].items(): + value=rows[a].get(h,Fraction(0))+q*v + if value:rows[a][h]=value + else:rows[a].pop(h,None) + else:raise ValueError('unknown exact source opcode') + need(current==w['final']+[None]*w['owned_fields'],"exact final map") + neutral={h for h in helpers if Counter(r for _,r in pure[h])==Counter({target[h]:1})} + zeros={e:next(iter(support)) for e,(support,_) in supports.items() if support<=neutral} + need(len(neutral)==len(zeros)==72 and all(len(supports[e][0])==1 for e in zeros),"exact72 singleton zero MOVEs") + need(set(zeros.values())==neutral and all(supports[e][1]==target[h] for e,h in zeros.items()),"bijection and individual price cancellation") + seen=defaultdict(set) + for h in neutral:seen[keys[w['initial'][h]]].add(h) + for e,h in zeros.items(): + need(h not in seen[coframes[e]],"zero units distinct within coframe") + seen[coframes[e]].add(h) + return neutral,set(zeros),Counter(target[h] for h in neutral) + + +def run(source=None): + source=Path(source) if source is not None else ROOT/'inputs/WORD.json.gz' + neutral,zeros,hist=exact_neutral_data(source) + full=run_mode(source,False,neutral,zeros);projected=run_mode(source,True,neutral,zeros) + # Maximal-zero testing alone is not sufficient: history x+y, target x, + # neutral{x,y}. Setting only y=0 creates a nonzero cache. + toy={};insert({0:1,1:1},toy);need(reduce({0:1},toy),"unrestricted toy miss") + smaller={};insert({0:1},smaller);need(not reduce({0:1},smaller),"nonunit maximal-zero shortcut rejected") + return dict(status='PASS_ALL_HISTORY_INCREMENTAL_RATIONAL_CERTIFICATE', + unrestricted=full,maximal_neutral=projected,neutral_helpers=sorted(neutral), + zero_MOVE_events=sorted(zeros),neutral_target_histogram=dict(sorted(hist.items())), + neutral_paid_histogram=dict(sorted(hist.items())),zero_units_distinct_within_each_coframe=True, + all_subsets='2^72 by written unit-extension lemma, not exhaustive enumeration', + nonunit_all_subsets_shortcut_rejected=True,writes_files=False) + + +if __name__=='__main__': + print(json.dumps(run(),indent=2,sort_keys=True)) diff --git a/research/p104-earlier-destination-cache-bound/all_history_independent.py b/research/p104-earlier-destination-cache-bound/all_history_independent.py new file mode 100644 index 0000000000..33965272fd --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/all_history_independent.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python3 +"""Fresh Q coframe matrices; distinct-prime sparse COLUMN independence. + +Only the pinned original word is an input. Root prototype rows are not used. +""" +from collections import Counter,defaultdict +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse,gzip,json,math,sys,time +PIN='acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' +PRIME=1000033 +def need(ok,label): + if not ok:raise ValueError(label) +def isprime(n):return n>=2 and all(n%d for d in range(2,math.isqrt(n)+1)) +def framekey(U): + s={0} + for u in U:need(u not in s and 0=n),'source ownership flag') + left,right=set(classes[e[2]]),set(classes[e[3]]);need((left0 and rows[a],'positive paid rank and nonzero unrestricted MOVE row');paid[r]+=1;move_rows[event]=(rows[a].copy(),r,a,e[2],e[3]) + if len(rows[a])==1: + h=next(iter(rows[a])) + if h in helpers:pure[h].append((event,r,rows[a][h])) + cur[a]=e[3];observe(event,a,e[3],'arrival') + elif op=='INIT':need(a>=n and cur[a] is None and rows[a] is None,'fresh owned INIT');cur[a],rows[a]=e[2],{} + elif op=='CLEAR':need(a>=n and cur[a]==e[2] and rows[a] is not None,'owned CLEAR chart');cur[a],rows[a]=None,None + elif op=='SCALE':need(cur[a]==e[-1] and Q(e[2]),'nonzero coframed SCALE');rows[a]={h:Q(e[2])*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 scalar contact') + if op=='COPY':need(a>=n and not rows[a],'COPY into fresh zero') + add(rows[a],rows[b],Q(e[3])) + else:raise ValueError(op) + need(cur==w['final']+[None]*owned,'complete source endpoints and lifetimes');need(len(move_rows)==6279,'all paid MOVE rows collected');need(sum(len(b) for b in banks.values())==7780,'all1501 initial plus6279 arrivals') + cold={h for h in helpers if Counter(r for event,r,c in pure[h])==Counter({target_rank[h]:1})};need(len(cold)==72,'fresh exact72 pointwise-neutral helpers') + neutral_moves={pure[h][0][0]:h for h in cold};need(len(neutral_moves)==72,'one distinct pure MOVE per neutral helper');lost=Counter(target_rank[h] for h in cold);removed=Counter(move_rows[e][1] for e in neutral_moves);need(lost==removed,'actual72 target/paid rank cancellation') + replay_seconds=time.monotonic()-start;emit({'phase':'fresh_exact_Q_matrices_complete','rows':7780,'coframes':len(banks),'neutral_helpers':72,'seconds':replay_seconds}) + inverses={};rational_entries=0;records=[];zero_rows=[];denominator_count=Counter();source_matrix_digest=sha256();projected_matrix_digest=sha256();original_pivots=projected_pivots=0 + def residue(q): + denominator_count[q.denominator]+=1 + return rational_mod(q,prime,inverses) + for index,(key,bank) in enumerate(sorted(banks.items(),key=lambda item:(-len(item[1]),aliases[item[0]][0]))): + need(time.monotonic()-start> p) & 1: + v ^= basis[p] + if v: + p = v.bit_length() - 1 + for q in list(basis): + if (basis[q] >> p) & 1: + basis[q] ^= v + basis[p] = v + return tuple((p, basis[p]) for p in sorted(basis, reverse=True)) + + +def row_add(dst, src, q): + require(dst is not src, 'aliasing row update') + for i, x in src.items(): + y = dst.get(i, Fraction(0)) + q * x + if y: + dst[i] = y + else: + dst.pop(i, None) + + +def row_scale(row, q): + if not q: + row.clear() + elif q != 1: + for i in list(row): + row[i] *= q + if not row[i]: + del row[i] + + +def reduced(row, basis): + value = row.copy() + while value: + p = min(value) + b = basis.get(p) + if b is None: + return value + row_add(value, b, -value[p]) + return value + + +def insert(basis, row): + value = reduced(row, basis) + if not value: + return False + p = min(value) + scale = 1 / value[p] + row_scale(value, scale) + basis[p] = value + return True + + +def member(basis, row): + return not reduced(row, basis) + + +def run(source=WORD, kr=None): + started = time.monotonic() + src = source.read_bytes() + require(hashlib.sha256(src).hexdigest() == WORD_SHA256, 'native word hash') + w = json.loads(gzip.decompress(src)) + require(kr is not None, 'in-memory exact source census supplied') + require(kr['source_sha256'] == WORD_SHA256, 'candidate source binding') + require(kr['status'] == 'COMPLETE_EXACT_GLOBAL_KERNEL_RELOCATION_CENSUS', + 'complete source-span census') + + frames = [frame_key(f) for f in w['frames']] + candidate = {r['event']: r for r in kr['records'] if r['source']['inside']} + require(len(kr['records']) == 6279, 'all MOVE cuts in source census') + source_counts = Counter((bool(r['owned']), bool(r['source']['inside'])) + for r in kr['records']) + require(source_counts == Counter({(False, False): 6214, + (False, True): 18, + (True, False): 16, + (True, True): 31}), + 'complete public/owned source-bank split') + require(len(candidate) == 49, 'all source-span survivors') + require(Counter(bool(r['owned']) for r in candidate.values()) == + Counter({False: 18, True: 31}), 'public/owned candidate split') + require(Counter(r['rank'] for r in candidate.values()) == + Counter({1: 21, 2: 12, 3: 5, 4: 9, 5: 2}), 'candidate ranks') + stable_candidates = [dict(event=r['event'], owner=r['owner'], owned=r['owned'], + rank=r['rank'], witness=r['source']['witness']) + for r in kr['records'] if r['source']['inside']] + census_sha = hashlib.sha256(json.dumps(stable_candidates, sort_keys=True, + separators=(',', ':')).encode()).hexdigest() + + targets = {frames[w['program'][i][3]] for i in candidate} + histories = {f: {} for f in targets} + hist_rank_total = 0 + initial_added = 0 + arrivals = Counter() + event_counts = Counter() + scalar_preservation_cases = Counter() + leave_checks = 0 + positive_controls = set() + records = [] + rows = [{i: Fraction(1)} for i in range(w['public'])] + rows.extend({} for _ in range(w['owned_fields'])) + charts = w['initial'] + [None] * w['owned_fields'] + + # History starts with every public row initially present at a target chart. + for owner, frame in enumerate(w['initial']): + key = frames[frame] + if key in histories: + initial_added += insert(histories[key], rows[owner]) + + for event, e in enumerate(w['program']): + op, a = e[:2] + event_counts[op] += 1 + if op == 'MOVE': + old, new = e[2], e[3] + require(charts[a] == old, f'MOVE source chart at {event}') + old_key, new_key = frames[old], frames[new] + # Before moving away, the value belongs to the full earlier history + # of its current target chart. The incoming row at the destination + # is deliberately not admitted until after a candidate check. + if event in candidate and old_key in histories and rows[a]: + require(member(histories[old_key], rows[a]), + f'candidate pre-MOVE history inclusion at {event}') + leave_checks += 1 + if event in candidate: + rec = candidate[event] + require(len(e) == 5 and bool(e[4]) == bool(rec['owned']), + f'candidate operation / ownership at {event}') + # Independently reconstruct source-span membership from the + # recorded exact coefficients and the directly replayed rows. + witness = {} + for field, coeff in rec['source']['witness'].items(): + row_add(witness, rows[int(field)], Fraction(coeff)) + require(witness == rows[a], f'exact source witness at {event}') + dst_key = frames[new] + hist = histories[dst_key] + pre_rank = len(hist) + hit = member(hist, rows[a]) + # Failure control: in a clone, inserting the alleged missing + # target must create a member; already-historical basis rows + # must also be recognized as members. + if dst_key not in positive_controls: + require(member(hist, {}) and + (not hist or member(hist, hist[min(hist)])), + f'positive membership control at {event}') + positive_controls.add(dst_key) + if not hit: + trial = {p: r.copy() for p, r in hist.items()} + require(insert(trial, rows[a]), f'negative control rank at {event}') + require(member(trial, rows[a]), f'negative control hit at {event}') + records.append(dict(event=event, owner=a, owned=bool(e[4]), + rank=rec['rank'], destination=new, + destination_history_rank=pre_rank, + member_before_arrival=hit)) + charts[a] = new + if new_key in histories and rows[a]: + arrivals[new_key] += 1 + if insert(histories[new_key], rows[a]): + hist_rank_total += 1 + elif op == 'INIT': + require(charts[a] is None and not rows[a], f'INIT zero/fresh at {event}') + charts[a] = e[2] + elif op == 'CLEAR': + require(charts[a] == e[2], f'CLEAR chart at {event}') + charts[a] = None + rows[a] = {} + elif op == 'SCALE': + require(charts[a] == e[-1], f'SCALE chart at {event}') + q = Fraction(e[2]) + require(q != 0, f'nonzero SCALE at {event}') + row_scale(rows[a], q) + key = frames[charts[a]] + if key in histories: + scalar_preservation_cases['SCALE'] += 1 + elif op in ('ADD', 'COPY'): + b = e[2] + require(charts[a] == charts[b] == e[-1], f'{op} coframe at {event}') + if op == 'COPY': + require(not rows[a], f'COPY zero destination at {event}') + key = frames[charts[a]] + row_add(rows[a], rows[b], Fraction(e[3])) + if key in histories: + scalar_preservation_cases[op] += 1 + else: + raise AssertionError(f'unknown instruction {op}') + + require(len(records) == 49, 'all candidate checks reached') + require(not any(r['member_before_arrival'] for r in records), + 'no destination-history membership hits') + require(charts == w['final'] + [None] * w['owned_fields'], + 'all final charts and owned lifetimes') + require(sum(len(b) for b in histories.values()) == + initial_added + hist_rank_total, 'history rank accounting') + expected_history_rank = 1465 + observed_rank = sum(map(len, histories.values())) + require(observed_rank == expected_history_rank, + 'independent exact cumulative generator count') + require(len(histories) == 40, '40 destination subspaces') + require(sum(arrivals.values()) > 0 and leave_checks > 0, + 'chronological arrival and departure coverage') + + result = dict( + status='INDEPENDENT_EXACT_EARLIER_DESTINATION_HISTORY_REPLAY', + source_sha256=WORD_SHA256, + source_census_sha256=census_sha, + native_events=len(w['program']), + native_MOVE_events=event_counts['MOVE'], + source_span_survivors=len(candidate), + public_candidates=18, + owned_candidates=31, + source_prefilter_counts=dict(public_misses=source_counts[(False, False)], + public_survivors=source_counts[(False, True)], + owned_misses=source_counts[(True, False)], + owned_survivors=source_counts[(True, True)]), + candidate_rank_histogram={str(k): v for k, v in sorted(Counter(r['rank'] for r in candidate.values()).items())}, + coframed_destination_subspaces=len(histories), + duplicate_frame_ids=len(w['frames']) - len(set(frames)), + initial_public_rows_inserted=initial_added, + nonzero_MOVE_arrivals_to_target_subspaces=sum(arrivals.values()), + independent_history_generators=observed_rank, + coframed_scalar_events_using_target_history=dict(scalar_preservation_cases), + MOVE_outgoing_live_row_history_checks=leave_checks, + candidate_history_hits=sum(r['member_before_arrival'] for r in records), + all_49_exact_source_witnesses_reconstructed=True, + failure_control='For every nonmember candidate, adding its target to a cloned history basis raises rank and makes it a member; existing basis rows test positive membership.', + records=records, + seconds=round(time.monotonic() - started, 3), + scope='Fixed #7481 source and unchanged complete scalar history at the destination coframe. Does not cover imported stock, modified prior histories, changed later repair, or a physical multi-chart cache.', + ) + return result diff --git a/research/p104-earlier-destination-cache-bound/history_filter.py b/research/p104-earlier-destination-cache-bound/history_filter.py new file mode 100644 index 0000000000..b367f1a305 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/history_filter.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Exact cumulative destination-history filter for49 source-span MOVEs. +Historical values across different cuts are only an exclusion relaxation. +""" +from collections import Counter,defaultdict +from fractions import Fraction as F +from pathlib import Path +import argparse,gzip,hashlib,importlib.util,json,sys,time +ROOT=Path(__file__).resolve().parent;HERE=ROOT +WORD=ROOT/'inputs/WORD.json.gz' +sys.dont_write_bytecode=True +sp=importlib.util.spec_from_file_location('K',ROOT/'kernel_screen.py') +K=importlib.util.module_from_spec(sp);sp.loader.exec_module(K) +PIN=K.PIN + +def need(ok,label): + if not ok:raise ValueError(label) + +def insert(basis,row,representative): + value,rep=row.copy(),representative.copy() + while value: + p=max(value) + if p not in basis: + q=1/value[p];basis[p]=({i:v*q for i,v in value.items()}, + {i:v*q for i,v in rep.items()});return True + old,mask=basis[p];q=-value[p];K.add(value,old,q);K.add(rep,mask,q) + return False + +def solve(basis,row): + value,rep=row.copy(),{} + while value: + p=max(value) + if p not in basis:return None + old,mask=basis[p];q=value[p];K.add(value,old,-q);K.add(rep,mask,q) + return rep + +def run(source=WORD,prior=None,seconds=60,output=None): + started=time.monotonic();deadline=started+seconds + raw=source.read_bytes() + need(hashlib.sha256(raw).hexdigest()==PIN,'source pin') + w=json.loads(gzip.decompress(raw));n=w['public'];classes=[K.span(f) for f in w['frames']] + need(prior is not None and prior.get('source_sha256')==PIN,'complete source census input') + candidates={z['event']:z for z in prior['records'] if z['source']['inside']} + need(len(candidates)==49,'complete source-span candidate set') + target_charts={classes[w['program'][i][3]] for i in candidates} + history={f:{} for f in target_charts};generators=[] + rows=[{i:F(1)} if ideadline:raise TimeoutError + op,a=e[:2] + if op=='MOVE': + need(charts[a]==e[2],'MOVE entrance') + if event in candidates: + check={} + for i,q in candidates[event]['source']['witness'].items():K.add(check,rows[int(i)],F(q)) + need(check==rows[a],'independent exact source witness replay') + f=classes[e[3]];rep=solve(history[f],rows[a]) + r=dict(event=event,owner=a,owned=bool(e[4]),rank=candidates[event]['rank'], + destination=e[3],historical_rank=len(history[f]),cumulative_span_hit=rep is not None) + if rep is not None: + r['target_row']={str(i):str(v) for i,v in rows[a].items()} + r['history_witness']={str(i):str(v) for i,v in rep.items()} + records.append(r) + charts[a]=e[3];observe(event,a,e[3]) + elif op=='INIT':charts[a]=e[2];rows[a]={} + elif op=='CLEAR':need(charts[a]==e[2],'CLEAR chart');charts[a]=None;rows[a]={} + elif op=='SCALE': + q=K.rational(e[2]);rows[a]={i:q*v for i,v in rows[a].items() if q*v} + elif op in ('ADD','COPY'): + need(charts[a]==charts[e[2]]==e[-1],'scalar cochart') + if op=='COPY':need(not rows[a],'COPY zero');rows[a]={} + K.add(rows[a],rows[e[2]],K.rational(e[3])) + else:raise ValueError(op) + complete=True;need(charts==w['final']+[None]*w['owned_fields'],'all endpoints') + except TimeoutError:pass + hits=[z for z in records if z['cumulative_span_hit']] + result=dict(status='COMPLETE_EXACT_CUMULATIVE_HISTORY_FILTER' if complete else 'TIME_LIMIT_PARTIAL_HISTORY_FILTER',source_sha256=PIN,checked_candidates=len(records),expected_candidates=49,last_event=last,destination_classes=len(target_charts),independent_history_generators=len(generators),cumulative_hits=len(hits),hit_ranks=dict(Counter(z['rank'] for z in hits)),records=records,generators=generators,seconds=time.monotonic()-started, + scope='Generous cumulative span of all earlier destination-chart values. No simultaneous availability or one-cache construction follows from a hit; actual earlier bank cut must be proved.') + if output is not None:output.write_text(json.dumps(result,indent=2)+'\n') + print(json.dumps({k:v for k,v in result.items() if k not in ('records','generators')},indent=2)) + print('hits',[(z['event'],z['owner'],z['rank']) for z in hits]) + return result + +if __name__=='__main__': + p=argparse.ArgumentParser() + p.add_argument('--source',type=Path,default=WORD) + p.add_argument('--kernel-result',type=Path,required=True) + p.add_argument('--output',type=Path) + p.add_argument('--seconds',type=float,default=60) + a=p.parse_args() + run(a.source,json.loads(a.kernel_result.read_text()),a.seconds,a.output) diff --git a/research/p104-earlier-destination-cache-bound/inputs/WORD.json.gz b/research/p104-earlier-destination-cache-bound/inputs/WORD.json.gz new file mode 100644 index 0000000000..77df4ad624 Binary files /dev/null and b/research/p104-earlier-destination-cache-bound/inputs/WORD.json.gz differ diff --git a/research/p104-earlier-destination-cache-bound/inputs/pr6069-info.json b/research/p104-earlier-destination-cache-bound/inputs/pr6069-info.json new file mode 100644 index 0000000000..ec160c872f --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/inputs/pr6069-info.json @@ -0,0 +1,38 @@ +{ + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6069", + "number": 6069, + "state": "closed", + "merged": true, + "mergeable": false, + "draft": false, + "body": "PR6045 leaves combinations of carrier sources open, and the earlier endpoint screen tested individual donor availability. This package supplies reproducible, scoped negative results on the unchanged PR6030 word so those searches need not be repeated.\n\n### Results\n\n- **4,033 leaking unit-injection classes:** an exact global dependency filter excludes 4,009. Of the remaining 24, 22 have no first same-chart combination carrier. Dynamic affine closure excludes both survivors, including opportunities enabled by earlier corrections.\n- **764 incoming-only MOVE intervals:** the exact net incoming contribution fails the combined rational spans of both full legal endpoint windows. This includes split replacements and cancellation among incoming ADDs: 693 coordinate exclusions and 71 exact elimination exclusions.\n- **Five private rank-four query outputs:** none can be reconstructed from other live destination-chart values at its immediate output seam, even granting equivalent frame presentations.\n\nFor the two dynamic cases, the final correction space and protected-output projection both have rank five. Independently implemented dense suffix, determinant and affine checks confirm that clearing protected outputs erases the whole new-helper signal.\n\n### Scope and reproducibility\n\nAll changes are in `research/p104-fixed-word-negative-screens/`. The selected result remains conditional κ = 0.003125804. These exclusions concern the pinned fixed word, specified cuts/windows, and unchanged lifetimes. They do not exclude corrections that temporarily change the original scalar map, changed injections or continuations, new MOVEs/storage, receiver scaling in the endpoint model, or other architectures.\n\nThe PR6040/6045 dependencies are retained byte-for-byte with source hashes and attribution. The unchanged PR6030 word is the sole external live input. Replay requires Python 3.12 and its standard library; it needs no pending predecessor commit or network fetch.\n\n### Validation\n\nPassed on CPython 3.12.3 under Linux:\n\n- Registered normal and optimized isolated replay; both produce semantic SHA-256 `e9de43aef960895096b75c5e057ee0119276cdbdbbbc81fe698be60dae61f683`.\n- 27 module controls, independently implemented terminal certificates, adversarial boundary controls, and five explicit dual separating certificates.\n- Clean exported-package replay and rejection of changed word bytes, changed frozen vendor bytes, and a forged semantic receipt.\n- Metadata/source pins and exact committed-byte preflight for commit `b3f5aabddbae2d65f80bb8356e6993e0a65cd245`.\n\n```sh\npython3.12 -B scripts/research_package.py --package research/p104-fixed-word-negative-screens\npython3.12 -B scripts/check_research_commit.py --package research/p104-fixed-word-negative-screens\n```\n\nThe optional full-Git-history audit was not run in the shallow checkout; the self-contained export passed. No full native/compiler/caller/outer replay or new κ is claimed.\n\nPredecessors: #6045, #6040, #5994, #5718, #6030 and #5827; related chronological repair theory: #6019. Exact credit and source notices are retained in NOTICE.md and VENDOR.json.\n\nPrepared for Jonathan Capalbo (jon314159) with substantial OpenAI Codex assistance, including separate implementation and review agents. This is AI-assisted research and review, not independent human approval or formal verification.\n", + "title": "P104: certify fixed-word carrier and endpoint exclusions (no new κ)", + "base": "main", + "base_sha": "721c03822c421b7f7fcbb2598993b947c4d88419", + "head": "research/p104-negative-screens", + "head_sha": "b3f5aabddbae2d65f80bb8356e6993e0a65cd245", + "head_repo_id": 1411542451, + "head_repo_full_name": "jon314159/integer-mult-bounds", + "merge_commit_sha": "c62bc64ea5e349d6d527415be15106f9b2f7631c", + "user": { + "login": "jon314159", + "name": "jon314159", + "email": null, + "avatar_url": "https://avatars.githubusercontent.com/u/12190500?v=4", + "id": 12190500 + }, + "requested_reviewers": null, + "requested_team_reviewers": null, + "diff": null, + "comments": null, + "created_at": "2026-10-28T04:37:29Z", + "updated_at": "2026-10-28T17:36:28Z", + "closed_at": "2026-10-28T17:36:28Z", + "merged_at": "2026-10-28T17:36:28Z", + "commits": 1, + "changed_files": 18, + "additions": 58516, + "deletions": 0, + "display_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6069", + "display_title": "P104: certify fixed-word carrier and endpoint exclusions (no new κ)" +} diff --git a/research/p104-earlier-destination-cache-bound/kernel_screen.py b/research/p104-earlier-destination-cache-bound/kernel_screen.py new file mode 100644 index 0000000000..91c553f141 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/kernel_screen.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python3 +"""Exact coframed span census using the global rational relation kernel. +The kernel is propagated through every literal scalar operation; no prime +or inferred modular zero is used. Source/destination spans exclude mover. +""" +from collections import Counter,defaultdict +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +import argparse,gzip,hashlib,json,time +ROOT=Path(__file__).resolve().parent;HERE=ROOT +SOURCE=ROOT/'inputs/WORD.json.gz' +PIN='acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' + +def need(ok,label): + if not ok:raise ValueError(label) + +@lru_cache(None) +def rational(text):return F(text) + +def add(dst,src,q): + need(dst is not src,'separate row objects') + for i,v in src.items(): + z=dst.get(i,0)+q*v + if z:dst[i]=z + else:dst.pop(i,None) + +def span(vectors): + values={0} + for v in vectors:values|={x^v for x in values} + return sum(1<deadline:raise TimeoutError + value={j:v for j,v in relation.items() if j not in allowed} + full=relation.copy() + while value: + p=max(value) + if p not in basis: + q=1/value[p] + basis[p]=({j:v*q for j,v in value.items()}, {j:v*q for j,v in full.items()}) + break + old,rep=basis[p];q=-value[p] + add(value,old,q);add(full,rep,q) + if not value and full.get(a): + q=-1/full[a] + return dict(inside=True,method='exact_kernel_projection', + witness={str(j):str(v*q) for j,v in full.items() if j!=a}, + global_kernel_dim=len(kernel),projected_rank=len(basis)) + return dict(inside=False,method='exact_kernel_projection', + global_kernel_dim=len(kernel),projected_rank=len(basis)) + +def controls(): + kernel=[{2:F(1)}] + scalar_add(kernel,2,0,F(1)) + need(bank_relation(kernel,2,{0},float('inf'))['witness']=={'0':'1'},'COPY relation') + scalar_add(kernel,0,1,F(1)) + for row in kernel: + if row.get(0):row[0]/=2 + hit=bank_relation(kernel,2,{0,1},float('inf')) + need(hit['witness']=={'0':'1/2','1':'-1'},'contragredient ADD/SCALE') + need(not bank_relation(kernel,2,{0},float('inf'))['inside'],'dirty coordinate cannot disappear') + clear(kernel,2);need(not kernel,'CLEAR kernel elimination') + singular=[{2:F(1)}];scalar_add(singular,2,0,F(1));scalar_add(singular,0,2,F(-1)) + need(bank_relation(singular,0,set(),float('inf'))['inside'],'singular public-prefix support') + clear(singular,2) + need(bank_relation(singular,0,set(),float('inf'))['inside'],'independent CLEAR rank-loss support') + return dict(copy_relation=True,add_scale_relation=True,dirty_coordinate_rejected=True,clear_elimination=True,singular_public_prefix=True,independent_clear_rank_loss=True) + +def run(seconds,source=SOURCE,output=None): + started=time.monotonic();deadline=started+seconds;tested=controls() + raw=source.read_bytes();need(hashlib.sha256(raw).hexdigest()==PIN,'literal source pin') + w=json.loads(gzip.decompress(raw));n=w['public'];classes=[span(f) for f in w['frames']] + charts=w['initial']+[None]*w['owned_fields'];banks=defaultdict(set) + for i,f in enumerate(charts): + if f is not None:banks[classes[f]].add(i) + kernel=[];maximum=0;records=[];hits=[];counts=Counter();last=-1;complete=False + try: + for event,e in enumerate(w['program']): + last=event + if event%128==0 and time.monotonic()>deadline:raise TimeoutError + op,a=e[:2] + if op=='INIT': + need(charts[a] is None and all(not k.get(a) for k in kernel),'fresh owned INIT') + charts[a]=e[2];banks[classes[e[2]]].add(a);kernel.append({a:F(1)}) + maximum=max(maximum,len(kernel)) + elif op=='CLEAR': + need(charts[a]==e[2],'CLEAR chart');clear(kernel,a) + banks[classes[e[2]]].remove(a);charts[a]=None + elif op in ('ADD','COPY'): + b=e[2];need(charts[a]==charts[b]==e[-1],'cocharted scalar contact') + if op=='COPY':need(bank_relation(kernel,a,set(),deadline)['inside'],'COPY into exact zero') + scalar_add(kernel,a,b,rational(e[3])) + elif op=='SCALE': + need(charts[a]==e[-1],'SCALE chart');q=rational(e[2]);need(q!=0,'invertible source scalar') + for relation in kernel: + if relation.get(a):relation[a]/=q + elif op=='MOVE': + need(charts[a]==e[2],'MOVE chart');old,new=classes[e[2]],classes[e[3]] + source=bank_relation(kernel,a,banks[old]-{a},deadline) + record=dict(event=event,owner=a,owned=bool(e[4]),rank=abs(dimension(old)-dimension(new)),source_fields=len(banks[old])-1,destination_fields=len(banks[new]),source=source) + kind='owned' if e[4] else 'public';counts[kind+'_source_'+str(source['inside'])]+=1 + if source['inside']: + destination=bank_relation(kernel,a,banks[new]-{a},deadline) + record['destination']=destination;counts[kind+'_destination_'+str(destination['inside'])]+=1 + if destination['inside']:hits.append(record) + records.append(record) + banks[old].remove(a);banks[new].add(a);charts[a]=e[3] + else:raise ValueError(op) + complete=True;need(charts==w['final']+[None]*w['owned_fields'],'all endpoint/lifetime charts') + except TimeoutError:pass + result=dict(status='COMPLETE_EXACT_GLOBAL_KERNEL_RELOCATION_CENSUS' if complete else 'TIME_LIMIT_PARTIAL_KERNEL_CENSUS',source_sha256=PIN,instructions=len(w['program']),last_event=last,checked_moves=len(records),total_MOVEs=sum(e[0]=='MOVE' for e in w['program']),maximum_relation_dimension=maximum,final_relation_dimension=len(kernel),counts=dict(counts),two_sided_hits=hits,ideal_removed_paid_profile=dict(Counter(h['rank'] for h in hits)),records=records,controls=tested,seconds=time.monotonic()-started, + coframe_model='Equal GF2 subspaces, including one duplicate source-space ID pair with ordinary rank0 normalization granted.',scope='Exact global row-relation kernel overQ. Each MOVE separately; source excludes mover; all public inputs arbitrary. A hit requires physical slot/ownership/lifetime and full invoice review. No emitted source or summed-gain admission.') + if output is not None:output.write_text(json.dumps(result,indent=2)+'\n') + print(json.dumps({k:v for k,v in result.items() if k not in ('records','two_sided_hits')},indent=2)) + for h in hits:print('HIT',h['event'],h['owner'],h['rank']) + return result + +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--seconds',type=float,default=60) + p.add_argument('--source',type=Path,default=SOURCE) + p.add_argument('--output',type=Path) + args=p.parse_args();run(args.seconds,args.source,args.output) diff --git a/research/p104-earlier-destination-cache-bound/main_probes.py b/research/p104-earlier-destination-cache-bound/main_probes.py new file mode 100644 index 0000000000..c636a05912 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/main_probes.py @@ -0,0 +1,198 @@ +#!/usr/bin/env python3 +"""Verify main-only separators by literal scalar replay, without elimination.""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import gzip +import json + +HERE = Path(__file__).resolve().parent +WORD = HERE / 'inputs/WORD.json.gz' +PROBES = HERE / 'MAIN-PROBES.json' +WORD_PIN = 'acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' +PROBE_PIN = '440b45249eb28596d2dbcfcff5e13dd9c9f435c6f6303aff22e2207a6b1a5aa5' +EXPECTED = (30529,30537,30551,32939,33125,33133,33140,33142,33149, + 34524,34528,35443,36324,36328,36336,39553,39581,39727, + 39785,39814,39820,39853,40538,40556,40563,40567,41491, + 42005,42477,42482,44244,44251,45638) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def frame_key(vectors): + """Canonical GF(2) row space; high-pivot Gauss-Jordan, not source IDs.""" + rows = [int(v) for v in vectors if int(v)] + k = 0 + for bit in range(8, -1, -1): + hit = next((j for j in range(k, len(rows)) if rows[j] >> bit & 1), None) + if hit is None: + continue + rows[k], rows[hit] = rows[hit], rows[k] + for j in range(len(rows)): + if j != k and rows[j] >> bit & 1: + rows[j] ^= rows[k] + k += 1 + need(all(0 <= v < 512 for v in vectors), 'frame outside nine axes') + return tuple(sorted(rows[:k])) + + +def bind(word, probes, complete=True): + need(word['public'] == 1501 and len(word['program']) == 76475, + 'literal source dimensions') + mains = set(word['live']) | {i + 112 for i in word['live']} + mains |= set(word['hosted']['X2']) | set(word['hosted']['Y2']) + need(len(mains) == 400 and mains <= set(range(word['public'])), + 'actual 400-main partition') + keys = [frame_key(v) for v in word['frames']] + need(all(len(keys[i]) == len(v) for i, v in enumerate(word['frames'])), + 'independent source frame bases') + ids = [p['event'] for p in probes] + need(len(set(ids)) == len(ids), 'duplicate probe cut') + if complete: + need(tuple(sorted(ids)) == EXPECTED, 'complete 33-cut coverage') + else: + need(set(ids) <= set(EXPECTED), 'control cut is in certificate scope') + for p in probes: + e = word['program'][p['event']] + need(e[0] == 'MOVE' and e[4] is True and e[1] >= word['public'], + 'probe must bind actual owned MOVE') + need((p['owner'], p['source_frame'], p['destination_frame']) == tuple(e[1:4]), + 'probe owner/source/destination binding') + need(tuple(p['destination_key']) == keys[e[3]], 'actual destination coframe binding') + indices = [h for h, _ in p['main_separator']] + need(len(indices) == len(set(indices)) and set(indices) <= mains, + 'separator has unique main-only coordinates') + need(all(Q(c).denominator == 1 for _, c in p['main_separator']), + 'integer main separator') + need(Q(p['target_dot']) != 0, 'advertised target must be nonzero') + return keys, mains + + +def replay(word, probes, *, complete=True, include_candidate_arrival=False): + keys, mains = bind(word, probes, complete) + count = len(probes) + by_event = {p['event']: q for q, p in enumerate(probes)} + by_frame = {} + inputs = {} + for q, p in enumerate(probes): + by_frame.setdefault(keys[p['destination_frame']], []).append((p['event'], q)) + for h, coefficient in p['main_separator']: + inputs.setdefault(h, [Q(0)] * count)[q] = Q(coefficient) + vals = [inputs.get(h, [Q(0)] * count) for h in range(word['public'])] + vals += [None] * word['owned_fields'] + charts = word['initial'].copy() + [None] * word['owned_fields'] + stats = Counter() + observations = [0] * count + targets = [None] * count + + def check_bank(owner, frame, clock, label, arrival=False): + for event, q in by_frame.get(keys[frame], ()): + before = clock < event or (include_candidate_arrival and arrival and clock == event) + if before: + need(vals[owner][q] == 0, 'nonzero history observation: ' + label) + stats['bank_checks'] += 1 + if arrival: + observations[q] += 1 + + for h, f in enumerate(word['initial']): + check_bank(h, f, -1, 'initial', arrival=True) + for clock, e in enumerate(word['program']): + op, a = e[:2] + stats[op] += 1 + if op == 'MOVE': + old, new = e[2:4] + need(vals[a] is not None and charts[a] == old, 'literal MOVE chronology') + need(e[4] == (a >= word['public']), 'literal MOVE owner flag') + check_bank(a, old, clock, 'departure') + if clock in by_event: + q = by_event[clock] + targets[q] = vals[a][q] + need(targets[q] == Q(probes[q]['target_dot']) and targets[q] != 0, + 'nonzero target replay') + # In normalized coordinates a completed MOVE preserves the row. + # The physical whole-array frame map is invertible and common to B. + check_bank(a, new, clock, 'arrival', arrival=True) + charts[a] = new + elif op == 'INIT': + need(a >= word['public'] and charts[a] is None and vals[a] is None, + 'literal fresh INIT') + charts[a], vals[a] = e[2], [Q(0)] * count + check_bank(a, e[2], clock, 'INIT') + elif op == 'CLEAR': + need(a >= word['public'] and charts[a] == e[2] and vals[a] is not None, + 'literal owned CLEAR') + check_bank(a, e[2], clock, 'CLEAR') + charts[a], vals[a] = None, None + elif op == 'SCALE': + need(vals[a] is not None and charts[a] == e[-1], 'literal SCALE coframe') + check_bank(a, e[-1], clock, 'SCALE before') + coefficient = Q(e[2]) + need(coefficient != 0, 'literal nonzero SCALE') + vals[a] = [coefficient * v for v in vals[a]] + check_bank(a, e[-1], clock, 'SCALE after') + elif op in ('COPY', 'ADD'): + b = e[2] + need(a != b and vals[a] is not None and vals[b] is not None and + charts[a] == charts[b] == e[-1], 'literal scalar coframe') + check_bank(a, e[-1], clock, op + ' destination') + check_bank(b, e[-1], clock, op + ' source') + if op == 'COPY': + need(a >= word['public'] and not any(vals[a]), 'fresh-zero COPY under probes') + coefficient = Q(e[3]) + vals[a] = [x + coefficient * y for x, y in zip(vals[a], vals[b])] + check_bank(a, e[-1], clock, op + ' result') + else: + raise ValueError('unknown native opcode') + need(charts == word['final'] + [None] * word['owned_fields'], 'literal final charts') + need(all(x is not None and x != 0 for x in targets), 'all advertised targets reached') + need(all(x > 0 for x in observations), 'nonempty earlier histories') + return {'cuts': len(probes), 'events': len(word['program']), + 'main_coordinates': len(mains), 'bank_checks': stats['bank_checks'], + 'earlier_arrivals': observations, 'target_values': [str(x) for x in targets]} + + +def run(source=WORD, probes_path=PROBES): + raw = source.read_bytes() + need(sha256(raw).hexdigest() == WORD_PIN, 'main-probe source hash pin') + data = probes_path.read_bytes() + need(sha256(data).hexdigest() == PROBE_PIN, 'main-probe certificate hash pin') + word = json.loads(gzip.decompress(raw)) + doc = json.loads(data) + need(doc['source_sha256'] == WORD_PIN, 'certificate source identity') + probes = doc['candidate_probes'] + result = replay(word, probes) + bad_cases = [] + one = deepcopy(probes[:1]); one[0]['destination_frame'] = one[0]['source_frame'] + bad_cases.append(('wrong destination', one, False, 'probe owner/source/destination binding')) + one = deepcopy(probes[:1]); one[0]['destination_key'] = [] + bad_cases.append(('wrong coframe', one, False, 'actual destination coframe binding')) + _, mains = bind(word, probes) + helper = min(set(range(word['public'])) - mains) + one = deepcopy(probes[:1]); one[0]['main_separator'] = [[helper, 1]] + bad_cases.append(('helper-supported probe', one, False, 'separator has unique main-only coordinates')) + one = deepcopy(probes[:1]); one[0]['main_separator'] = [[one[0]['main_separator'][0][0], 0]] + bad_cases.append(('zero separator', one, False, 'nonzero target replay')) + bad_cases.append(('own arrival incorrectly earlier', deepcopy(probes[:1]), True, + 'nonzero history observation: arrival')) + rejected = [] + for label, mutant, inclusive, message in bad_cases: + try: + replay(word, mutant, complete=False, include_candidate_arrival=inclusive) + except ValueError as exc: + need(str(exc) == message, 'specific failure control: ' + label + ': ' + str(exc)) + rejected.append(label) + else: + raise ValueError('accepted mutant: ' + label) + result.update(status='PASS_MAIN_ONLY_HISTORY_SEPARATORS', source_sha256=WORD_PIN, + certificate_sha256=PROBE_PIN, negative_controls=rejected, + method='direct simultaneous rational scalar inputs; no span elimination') + return result + + +if __name__ == '__main__': + print(json.dumps(run(), indent=2, sort_keys=True)) diff --git a/research/p104-earlier-destination-cache-bound/prefilter_controls.py b/research/p104-earlier-destination-cache-bound/prefilter_controls.py new file mode 100644 index 0000000000..ee8b8abb33 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/prefilter_controls.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +"""Bounded exact synthetic audit of kernel_scan.py's source-span predicate.""" +from fractions import Fraction as F +from itertools import combinations +from pathlib import Path +import hashlib +import importlib.util +import json +import sys + +ROOT = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +spec = importlib.util.spec_from_file_location( + 'kernel_scan_under_review', ROOT / 'kernel_screen.py') +K = importlib.util.module_from_spec(spec) +spec.loader.exec_module(K) + + +def require(ok, label): + if not ok: + raise AssertionError(label) + + +def row_add(dst, src, q): + for i, x in src.items(): + y = dst.get(i, F(0)) + q * x + if y: + dst[i] = y + else: + dst.pop(i, None) + + +def row_scale(row, q): + for i in list(row): + row[i] *= q + if not row[i]: + del row[i] + + +def direct_nullspace(rows, active): + """Independent RREF nullspace of row columns, over exact Q.""" + fields = sorted(active) + width = len(fields) + coords = sorted({i for a in fields for i in rows[a]}) + mat = [[rows[a].get(c, F(0)) for a in fields] for c in coords] + pivots = [] + r = 0 + for c in range(width): + q = next((i for i in range(r, len(mat)) if mat[i][c]), None) + if q is None: + continue + mat[r], mat[q] = mat[q], mat[r] + d = mat[r][c] + mat[r] = [x / d for x in mat[r]] + for i in range(len(mat)): + if i != r and mat[i][c]: + d = mat[i][c] + mat[i] = [x - d * y for x, y in zip(mat[i], mat[r])] + pivots.append(c) + r += 1 + if r == len(mat): + break + free = [c for c in range(width) if c not in pivots] + out = [] + for c in free: + v = {fields[c]: F(1)} + for i, p in enumerate(pivots): + if mat[i][c]: + v[fields[p]] = -mat[i][c] + out.append(v) + return out + + +def in_vector_span(target, vectors): + basis = {} + for raw in vectors: + v = raw.copy() + while v: + p = min(v) + if p not in basis: + q = 1 / v[p] + basis[p] = {i: x * q for i, x in v.items()} + break + row_add(v, basis[p], -v[p]) + v = target.copy() + while v: + p = min(v) + if p not in basis: + return False + row_add(v, basis[p], -v[p]) + return True + + +def kernel_equal(kernel, expected, active): + actual = [r.copy() for r in kernel] + require(len(actual) == len(expected), 'synthetic relation rank') + require(all(in_vector_span(r, expected) for r in actual), + 'kernel update sound against direct rows') + require(all(in_vector_span(r, actual) for r in expected), + 'kernel update complete against direct rows') + require(all(not any(a not in active and q for a, q in r.items()) + for r in actual), 'active coordinate support') + + +def check_all_bank_predicates(kernel, rows, active): + checked = 0 + witnesses = 0 + fields = sorted(active) + for a in fields: + others = [x for x in fields if x != a] + for size in range(len(others) + 1): + for donor_tuple in combinations(others, size): + donors = set(donor_tuple) + expected = in_vector_span(rows[a], [rows[d] for d in donors]) + got = K.bank_relation(kernel, a, donors, float('inf')) + require(got['inside'] == expected, + f'projection predicate for owner={a}, donors={donors}') + if got['inside']: + witness = {int(i): F(q) for i, q in got['witness'].items()} + require(set(witness) <= donors, + 'owner excluded from emitted donor witness') + rebuild = {} + for d, q in witness.items(): + row_add(rebuild, rows[d], q) + require(rebuild == rows[a], 'exact synthetic donor witness') + witnesses += 1 + checked += 1 + return checked, witnesses + + +def run(): + # Public inputs begin independent; INIT adds a fresh zero row. + rows = {0: {0: F(1)}, 1: {1: F(1)}} + active = {0, 1} + kernel = [] + kernel_equal(kernel, direct_nullspace(rows, active), active) + + rows[2] = {} + active.add(2) + kernel.append({2: F(1)}) # INIT + kernel_equal(kernel, direct_nullspace(rows, active), active) + + # ADD from the zero row, then SCALE by a negative nonzero rational. + rows[2] = {0: F(1)} + K.scalar_add(kernel, 2, 0, F(1)) + kernel_equal(kernel, direct_nullspace(rows, active), active) + row_scale(rows[2], F(-3, 2)) + for rel in kernel: + if rel.get(2): + rel[2] /= F(-3, 2) + kernel_equal(kernel, direct_nullspace(rows, active), active) + + # Fresh INIT plus COPY into exact zero, followed by a dirty-coordinate case. + rows[3] = {} + active.add(3) + kernel.append({3: F(1)}) + kernel_equal(kernel, direct_nullspace(rows, active), active) + require(K.bank_relation(kernel, 3, set(), float('inf'))['inside'], + 'the freshly initialized COPY target is exactly zero') + rows[3] = {1: F(2), 0: F(-1)} + K.scalar_add(kernel, 3, 1, F(2)) + K.scalar_add(kernel, 3, 0, F(-1)) + kernel_equal(kernel, direct_nullspace(rows, active), active) + checked, witnesses = check_all_bank_predicates(kernel, rows, active) + require(not K.bank_relation(kernel, 3, {1}, float('inf'))['inside'], + 'reject a local relation with missing dirty donor') + + # COPY guard: only the exact-zero owned destination is admissible. + fresh = [{2: F(1)}] + require(K.bank_relation(fresh, 2, set(), float('inf'))['inside'], + 'exact-zero COPY destination accepted') + require(not K.bank_relation(kernel, 0, set(), float('inf'))['inside'], + 'nonzero COPY destination rejected') + + # CLEAR intersects the relation space with c_a=0 and drops that coordinate. + K.clear(kernel, 2) + active.remove(2) + del rows[2] + kernel_equal(kernel, direct_nullspace(rows, active), active) + checked2, witnesses2 = check_all_bank_predicates(kernel, rows, active) + + # Singular public prefix / dependent CLEAR control from the source helper. + singular = [{2: F(1)}] + K.scalar_add(singular, 2, 0, F(1)) + K.scalar_add(singular, 0, 2, F(-1)) + require(K.bank_relation(singular, 0, set(), float('inf'))['inside'], + 'singular prefix yields zero target') + K.clear(singular, 2) + require(K.bank_relation(singular, 0, set(), float('inf'))['inside'], + 'CLEAR retains independent zero relation') + + # Equal GF(2) subspaces share a bank key, even with a redundant generator. + require(K.span([1, 2]) == K.span([1, 2, 3]), + 'GF(2) redundant frame generator merges') + require(K.span([1, 2]) != K.span([1]), 'distinct GF(2) subspaces stay apart') + + result = dict(status='PASS', source_helper_sha256=hashlib.sha256( + (ROOT / 'kernel_screen.py').read_bytes()).hexdigest(), + synthetic_direct_kernel_comparisons=7, + exact_bank_predicates_checked=checked + checked2, + exact_witnesses_verified=witnesses + witnesses2, + controls=dict(init_zero=True, add=True, negative_scale=True, + copy_zero_guard=True, dirty_coordinate_rejection=True, + clear_intersection=True, singular_prefix=True, + dependent_clear=True, owner_exclusion=True, + exact_rational_witnesses=True, + gf2_redundant_frame_alias=True)) + return result + + +if __name__ == '__main__': + print(json.dumps(run(), indent=2)) diff --git a/research/p104-earlier-destination-cache-bound/temporal_author.py b/research/p104-earlier-destination-cache-bound/temporal_author.py new file mode 100644 index 0000000000..00444a1618 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/temporal_author.py @@ -0,0 +1,86 @@ +#!/usr/bin/env python3 +"""Cumulative earlier-B and later-A filters for16 owned source-nonspan cuts. +No actual single-cut provider or physical two-cache word is asserted here. +""" +from collections import defaultdict,Counter +from fractions import Fraction as F +from pathlib import Path +import gzip,hashlib,importlib.util,json,sys,time +ROOT=Path(__file__).resolve().parent;HERE=ROOT +sys.dont_write_bytecode=True +sp=importlib.util.spec_from_file_location('H',ROOT/'history_filter.py') +H=importlib.util.module_from_spec(sp);sp.loader.exec_module(H);K=H.K +def need(ok,label): + if not ok:raise ValueError(label) +def run(source=ROOT/'inputs/WORD.json.gz', prior=None, seconds=60): + started=time.monotonic();deadline=started+seconds + raw=source.read_bytes() + need(hashlib.sha256(raw).hexdigest()==K.PIN,'source pin') + w=json.loads(gzip.decompress(raw));n=w['public'];classes=[K.span(f) for f in w['frames']] + need(prior is not None and prior['source_sha256']==K.PIN,'complete pinned source census') + targets={r['event']:r for r in prior['records'] if r['owned'] and not r['source']['inside']} + need(len(targets)==16,'owned source-nonspan set') + Bs={classes[w['program'][e][3]] for e in targets};As={classes[w['program'][e][2]] for e in targets} + past={f:{} for f in Bs};pastgens=[];reverse=[];records={} + rows=[{i:F(1)} if ideadline:raise TimeoutError + op,a=e[:2] + if op=='MOVE': + need(charts[a]==e[2],'MOVE chart') + if event in targets: + rep=H.solve(past[classes[e[3]]],rows[a]) + records[event]=dict(event=event,owner=a,rank=targets[event]['rank'],source=e[2],destination=e[3], + target_row={str(i):str(v) for i,v in rows[a].items()},earlier_B_hit=rep is not None, + earlier_B_rank=len(past[classes[e[3]]]),earlier_witness=None if rep is None else {str(i):str(v) for i,v in rep.items()}) + if classes[e[2]] in As:reverse.append((event,a,e[2],rows[a].copy(),'departure')) + charts[a]=e[3];observe(past,pastgens,event,a,e[3],rows[a],'arrival') + elif op=='INIT':need(charts[a] is None,'fresh INIT');charts[a]=e[2];rows[a]={} + elif op=='CLEAR': + need(charts[a]==e[2],'CLEAR chart') + if classes[e[2]] in As:reverse.append((event,a,e[2],rows[a].copy(),'retirement')) + charts[a]=None;rows[a]={} + elif op=='SCALE': + need(charts[a]==e[-1],'SCALE chart');q=K.rational(e[2]);need(q!=0,'invertible SCALE') + rows[a]={i:q*v for i,v in rows[a].items()} + elif op in ('ADD','COPY'): + need(a!=e[2] and charts[a]==charts[e[2]]==e[-1],'invertible coframed scalar contact') + if op=='COPY':need(not rows[a],'COPY zero');rows[a]={} + K.add(rows[a],rows[e[2]],K.rational(e[3])) + else:raise ValueError(op) + need(charts==w['final']+[None]*w['owned_fields'],'all endpoints') + future={f:{} for f in As};futuregens=[] + for a,f in enumerate(w['final']):observe(future,futuregens,len(w['program']),a,f,rows[a],'final') + reverse.sort(reverse=True,key=lambda z:z[0]);cursor=0 + for event in sorted(records,reverse=True): + if time.monotonic()>deadline:raise TimeoutError + while cursorevent: + j,a,f,row,kind=reverse[cursor];observe(future,futuregens,j,a,f,row,kind);cursor+=1 + rec=records[event];row={int(i):F(v) for i,v in rec['target_row'].items()} + rep=H.solve(future[classes[rec['source']]],row) + rec.update(later_A_hit=rep is not None,later_A_rank=len(future[classes[rec['source']]]), + later_witness=None if rep is None else {str(i):str(v) for i,v in rep.items()}) + rec['survives_both']=rec['earlier_B_hit'] and rec['later_A_hit'] + complete=True + except TimeoutError:futuregens=[] + result=dict(status='COMPLETE_EXACT_TEMPORAL_TWO_CACHE_FILTER' if complete else 'TIME_LIMIT_PARTIAL_TWO_CACHE_FILTER', + source_sha256=K.PIN,expected_candidates=16,forward_candidates=len(records),future_candidates=sum('later_A_hit' in r for r in records.values()), + last_event=last,earlier_B_hits=sum(r['earlier_B_hit'] for r in records.values()), + later_A_hits=sum(r.get('later_A_hit',False) for r in records.values()), + survivors=[r for r in records.values() if r.get('survives_both')],records=list(records.values()), + earlier_generators=pastgens,later_generators=futuregens,seconds=time.monotonic()-started, + scope='Generous cumulative earlier destination and strictly later source spans on unchanged arbitrary-input native history. A survivor is not a single-cut provider or physical word.') + print(json.dumps({k:v for k,v in result.items() if k not in ('records','earlier_generators','later_generators','survivors')},indent=2)) + print('survivors',[(r['event'],r['owner'],r['rank']) for r in result['survivors']]) + return result +# Called read-only by verify.py with a fresh complete source census. diff --git a/research/p104-earlier-destination-cache-bound/temporal_exact.py b/research/p104-earlier-destination-cache-bound/temporal_exact.py new file mode 100644 index 0000000000..720d7a525f --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/temporal_exact.py @@ -0,0 +1,184 @@ +#!/usr/bin/env python3 +"""Independent exact past/future coframe history check at every owned MOVE. + +Research checkpoint, not a new supplier. All public input rows remain arbitrary. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import gzip +import json +import time + +ROOT = Path(__file__).resolve().parent +PIN = "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" + + +def need(ok, label): + if not ok: + raise ValueError(label) + + +def add(a, b, c): + need(a is not b, "row alias") + for k, x in b.items(): + y = a.get(k, 0) + c * x + if y: + a[k] = y + else: + a.pop(k, None) + + +def key(frame): + # Enumerating at most 512 addresses gives an independent canonical key. + span = {0} + for v in frame: + span |= {x ^ v for x in span} + return tuple(sorted(span)) + + +def reduce(row, basis): + row = row.copy() + while row: + pivot = min(row) + if pivot not in basis: + return row + add(row, basis[pivot], -row[pivot]) + return row + + +def put(basis, row): + row = reduce(row, basis) + if not row: + return False + p = min(row) + a = row[p] + basis[p] = {k: v / a for k, v in row.items()} + return True + + +def run(source=ROOT / "inputs/WORD.json.gz", author=None, kernel=None): + start = time.monotonic() + raw = source.read_bytes() + need(sha256(raw).hexdigest() == PIN, "source byte pin") + word = json.loads(gzip.decompress(raw)) + frames = list(map(key, word["frames"])) + events = word["program"] + cuts = {i: e for i, e in enumerate(events) if e[0] == "MOVE" and e[4]} + need(len(cuts) == 47, "complete owned-MOVE set") + past = {frames[e[3]]: {} for e in cuts.values()} + future = {frames[e[2]]: {} for e in cuts.values()} + public = word["public"] + rows = [{i: Q(1)} for i in range(public)] + [None] * word["owned_fields"] + chart = word["initial"].copy() + [None] * word["owned_fields"] + departures = [] + answers = {} + counts = Counter() + past_controls = 0 + + for owner, f in enumerate(word["initial"]): + if frames[f] in past: + put(past[frames[f]], rows[owner]) + + for i, e in enumerate(events): + if i % 128 == 0: + need(time.monotonic() - start < 60, "bounded first-stage runtime") + op, a = e[:2] + counts[op] += 1 + if op == "MOVE": + old, new = e[2:4] + need(chart[a] == old and rows[a] is not None, "MOVE live source") + if i in cuts: + h = past[frames[new]] + remainder = reduce(rows[a], h) + trial = {p: r.copy() for p, r in h.items()} + if remainder: + need(put(trial, rows[a]), "inserted target raises rank") + need(not reduce(rows[a], trial), "inserted target becomes member") + need(not h or not reduce(h[min(h)], h), "existing history member") + past_controls += 1 + answers[i] = { + "event": i, "owner": a, "source": old, "destination": new, + "rank": abs(len(word["frames"][old]) - len(word["frames"][new])), + "target": rows[a].copy(), "earlier_B_hit": not remainder, + "earlier_B_rank": len(h), + } + if frames[old] in future: + departures.append((i, frames[old], rows[a].copy())) + chart[a] = new + if frames[new] in past: + put(past[frames[new]], rows[a]) + elif op == "INIT": + need(a >= public and chart[a] is None and rows[a] is None, "owned INIT") + chart[a], rows[a] = e[2], {} + elif op == "CLEAR": + need(a >= public and chart[a] == e[2], "owned CLEAR") + if frames[e[2]] in future: + departures.append((i, frames[e[2]], rows[a].copy())) + chart[a], rows[a] = None, None + elif op == "SCALE": + need(chart[a] == e[-1], "scalar chart") + q = Q(e[2]) + need(q, "nonzero scale") + rows[a] = {k: q * v for k, v in rows[a].items()} + elif op in ("ADD", "COPY"): + b = e[2] + need(a != b and chart[a] == chart[b] == e[-1], "coframed contact") + if op == "COPY": + need(a >= public and not rows[a], "fresh zero COPY") + add(rows[a], rows[b], Q(e[3])) + else: + raise ValueError(op) + need(chart == word["final"] + [None] * word["owned_fields"], "all endpoints") + for a, f in enumerate(word["final"]): + if frames[f] in future: + put(future[frames[f]], rows[a]) + # Strictly later: never insert a candidate's own outgoing row before its query. + departures.sort(key=lambda z: z[0], reverse=True) + j = 0 + future_controls = 0 + for i in sorted(cuts, reverse=True): + while j < len(departures) and departures[j][0] > i: + _, f, row = departures[j] + put(future[f], row) + j += 1 + h = future[frames[cuts[i][2]]] + rec = answers[i] + rec["later_A_hit"] = not reduce(rec["target"], h) + rec["later_A_rank"] = len(h) + future_controls += int(rec["later_A_hit"]) + rec["target"] = {str(k): str(v) for k, v in sorted(rec["target"].items())} + + need(author is not None, "fresh author temporal replay supplied") + old = author + need(old["source_sha256"] == PIN, "author source pin") + for r in old["records"]: + got = answers[r["event"]] + for name in ("owner", "source", "destination", "rank", "earlier_B_hit", + "earlier_B_rank", "later_A_hit", "later_A_rank"): + need(got[name] == r[name], "independent temporal comparison " + name) + need(got["target"] == r["target_row"], "independent complete target row") + need(kernel is not None and kernel["source_sha256"] == PIN, "fresh source census supplied") + for r in kernel["records"]: + if r["owned"]: + # A live source witness remains available immediately after the MOVE. + need(answers[r["event"]]["later_A_hit"] == r["source"]["inside"], + "later source hits exactly the 31 live-source controls") + need(not any(r["earlier_B_hit"] for r in answers.values()), "all earlier B misses") + need(future_controls == 31, "31 genuine later-source positive controls") + out = { + "status": "INDEPENDENT_EXACT_ALL_47_OWNED_TEMPORAL_FILTERS", + "source_sha256": PIN, "instructions": len(events), "owned_MOVEs": len(cuts), + "earlier_hits": sum(r["earlier_B_hit"] for r in answers.values()), + "later_hits": future_controls, "independent_author_cases": len(old["records"]), + "inserted_arrival_controls": past_controls, "past_subspaces": len(past), + "future_subspaces": len(future), "event_counts": dict(counts), + "seconds": time.monotonic()-start, "records": list(answers.values()), + "scope": "Unchanged native history, arbitrary public inputs, coframed ordinary caches. No physical supplier or kappa claim.", + } + print(json.dumps({k:v for k,v in out.items() if k!="records"}, indent=2)) + return out + + +# Called read-only by verify.py with fresh author and source-census results. diff --git a/research/p104-earlier-destination-cache-bound/verify.py b/research/p104-earlier-destination-cache-bound/verify.py new file mode 100644 index 0000000000..cc07f6b657 --- /dev/null +++ b/research/p104-earlier-destination-cache-bound/verify.py @@ -0,0 +1,172 @@ +#!/usr/bin/env python3 +"""Read-only self-contained replay; emits one semantic receipt to stdout.""" +from contextlib import redirect_stdout +from pathlib import Path +import gzip +import hashlib +import importlib.util +import io +import json +import sys +import tempfile + +ROOT = Path(__file__).resolve().parent +WORD = ROOT / 'inputs/WORD.json.gz' +WORD_SHA256 = 'acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' +NOTICE = ROOT / 'NOTICE' +NOTICE_SHA256 = '78e060cbd33ebc4078cabf39e50191a977fb9eb5c41104533079e22da1d9d248' + + +def load(name, filename): + spec = importlib.util.spec_from_file_location(name, ROOT / filename) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def need(condition, label): + if not condition: + raise AssertionError(label) + + +def main(): + raw = WORD.read_bytes() + need(hashlib.sha256(raw).hexdigest() == WORD_SHA256, 'exact native WORD pin') + need(hashlib.sha256(NOTICE.read_bytes()).hexdigest() == NOTICE_SHA256, + 'retained NOTICE pin') + word = json.loads(gzip.decompress(raw)) + + screen = load('cache_kernel_screen', 'kernel_screen.py') + history_filter = load('cache_history_filter', 'history_filter.py') + history_exact = load('cache_history_exact', 'history_exact.py') + prefilter_controls = load('cache_prefilter_controls', 'prefilter_controls.py') + temporal_author = load('cache_temporal_author', 'temporal_author.py') + temporal_exact = load('cache_temporal_exact', 'temporal_exact.py') + main_probes = load('cache_main_probes', 'main_probes.py') + all_author = load('cache_all_history_author', 'all_history_author.py') + all_independent = load('cache_all_history_independent', 'all_history_independent.py') + + # All parsers must reject changed source bytes before scientific work. + changed = bytearray(raw) + changed[len(changed)//2] ^= 1 + with tempfile.TemporaryDirectory(prefix='cache-source-control-') as td: + bad = Path(td)/'changed.gz' + bad.write_bytes(changed) + for name, call in [ + ('kernel', lambda: screen.run(seconds=1, source=bad, output=None)), + ('streaming', lambda: history_filter.run(source=bad, prior=None)), + ('independent', lambda: history_exact.run(source=bad, kr=None)), + ('temporal_author', lambda: temporal_author.run(source=bad, prior=None)), + ('temporal_exact', lambda: temporal_exact.run(source=bad, author=None, kernel=None)), + ('main_probes', lambda: main_probes.run(source=bad)), + ('all_history_author', lambda: all_author.run(source=bad)), + ('all_history_independent', lambda: all_independent.verify(bad)), + ]: + caught = False + try: + call() + except (ValueError, AssertionError) as exc: + need('pin' in str(exc) or 'hash' in str(exc), 'source mutation rejected at binding') + caught = True + need(caught, name+' rejects changed source') + + quiet = io.StringIO() + with redirect_stdout(quiet): + kernel = screen.run(seconds=60, source=WORD, output=None) + need(kernel['status'] == 'COMPLETE_EXACT_GLOBAL_KERNEL_RELOCATION_CENSUS', + 'full source candidate census completed') + filtered = history_filter.run(source=WORD, prior=kernel, + seconds=60, output=None) + direct = history_exact.run(source=WORD, kr=kernel) + controls = prefilter_controls.run() + temporal_a = temporal_author.run(source=WORD, prior=kernel, seconds=60) + need(temporal_a["status"] == "COMPLETE_EXACT_TEMPORAL_TWO_CACHE_FILTER", + "additional temporal cuts completed") + temporal_b = temporal_exact.run(source=WORD, author=temporal_a, kernel=kernel) + + need(controls['status'] == 'PASS', 'source-kernel synthetic controls') + need(filtered['status'] == 'COMPLETE_EXACT_CUMULATIVE_HISTORY_FILTER', + 'history filter completed') + need(filtered['checked_candidates'] == direct['source_span_survivors'] == 49, + 'both history engines cover all 49 source survivors') + need(filtered['cumulative_hits'] == direct['candidate_history_hits'] == 0, + 'both history engines reject all candidates') + need(filtered['destination_classes'] == direct['coframed_destination_subspaces'] == 40, + 'frame-class coverage agrees') + need(filtered['independent_history_generators'] == + direct['independent_history_generators'] == 1465, + 'history rank coverage agrees') + b_records = {r['event']: r for r in filtered['records']} + c_records = {r['event']: r for r in direct['records']} + need(set(b_records) == set(c_records), 'same exact candidate cuts') + need(all(not b_records[e]['cumulative_span_hit'] and + not c_records[e]['member_before_arrival'] and + b_records[e]['historical_rank'] == c_records[e]['destination_history_rank'] + for e in b_records), 'per-cut exact history decisions and ranks agree') + need(kernel['counts'] == { + 'public_source_False': 6214, + 'public_source_True': 18, + 'public_destination_False': 18, + 'owned_source_True': 31, + 'owned_destination_False': 31, + 'owned_source_False': 16, + }, 'complete prefilter source/destination counts') + + probe_result = main_probes.run() + need(probe_result['cuts'] == 33, '33 main-only history certificates') + all_a = all_author.run(WORD) + all_b = all_independent.verify(WORD, max_seconds=120) + all_controls = all_independent.controls() + need(all_a['unrestricted']['rational_nonmembership_certified'] == + all_b['MOVE_arrivals'] == 6279, 'all original history innovations agree') + need(all_a['maximal_neutral']['rational_nonmembership_certified'] == + all_b['nonzero_projected_MOVEs'] == 6207, 'all projected nonzero innovations agree') + need(all_a['unrestricted']['final_total_history_rank'] == + all_b['original_total_row_rank'] == 7780, 'unrestricted complete generator rank') + need(all_a['maximal_neutral']['final_total_history_rank'] == + all_b['max_neutral_nonzero_row_rank'] == 7636, 'projected complete generator rank') + for key in ('neutral_helpers', 'zero_MOVE_events', 'neutral_target_histogram', 'neutral_paid_histogram'): + need(all_a[key] == all_b[key], 'fresh independently derived neutral source data: '+key) + compact_b = {k:v for k,v in all_b.items() + if k not in ('records', 'seconds', 'replay_seconds', 'primary_input_only')} + compact_b['full_per_coframe_certificates_sha256'] = hashlib.sha256( + json.dumps(all_b['records'], sort_keys=True, separators=(',', ':')).encode()).hexdigest() + receipt = dict( + status='PASS_P104_EARLIER_DESTINATION_CACHE_EXCLUSION', + source_mutation_rejected_by_eight_engines=True, + source_sha256=WORD_SHA256, + notice_sha256=NOTICE_SHA256, + instructions=len(word['program']), + moves=kernel['checked_moves'], + source_prefilter=dict(public_misses=6214, public_survivors=18, + owned_misses=16, owned_survivors=31), + candidate_ranks={str(k): v for k, v in sorted( + __import__('collections').Counter(r['rank'] for r in direct['records']).items())}, + destination_subspaces=direct['coframed_destination_subspaces'], + initial_public_history_generators=direct['initial_public_rows_inserted'], + nonzero_move_arrivals=direct['nonzero_MOVE_arrivals_to_target_subspaces'], + independent_history_generators=direct['independent_history_generators'], + coframed_scalar_operations=direct['coframed_scalar_events_using_target_history'], + candidate_source_witnesses_reconstructed=direct['all_49_exact_source_witnesses_reconstructed'], + history_hits=0, + all_owned_temporal=dict(cuts=temporal_b['owned_MOVEs'], + earlier_destination_hits=temporal_b['earlier_hits'], + later_source_hits=temporal_b['later_hits'], + separately_checked_new_cuts=temporal_b['independent_author_cases'], + inserted_arrival_controls=temporal_b['inserted_arrival_controls'], + past_subspaces=temporal_b['past_subspaces'], + future_subspaces=temporal_b['future_subspaces']), + union_earlier_destination_exclusions=65, + all_original_earlier_destination_exclusions=6279, + all_history_and_neutral_subsets=dict(author=all_a, independent=compact_b, + independent_controls=all_controls, + all_subsets='Every subset of the 72 derived neutral helpers, by the written unit-extension proof.'), + main_only_history_separators=probe_result, + history_engines='exact Fraction streaming filter and independent direct Fraction replay agree at all 49 strict-before cuts', + prefilter_controls=controls, + output='stdout only; no package files written') + print(json.dumps(receipt, indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main()