From 53e716e640d998c81886aed7bae3c71e20985c36 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 07:10:42 -0500 Subject: [PATCH 1/2] Research shared-core dirty fan-in construction --- .../common-core-fanin-seed93550f9f/LICENSE | 201 +++++++++++++ .../common-core-fanin-seed93550f9f/NOTICE.md | 5 + .../common-core-fanin-seed93550f9f/README.md | 58 ++++ .../RESULT.json | 1 + .../SOURCES.json | 98 +++++++ .../common-core-fanin-seed93550f9f/TASK.json | 112 ++++++++ .../common-core-fanin-seed93550f9f/TASK.md | 56 ++++ .../VERIFY.json | 22 ++ .../common-core-fanin-seed93550f9f/verify.py | 264 ++++++++++++++++++ 9 files changed, 817 insertions(+) create mode 100644 research/common-core-fanin-seed93550f9f/LICENSE create mode 100644 research/common-core-fanin-seed93550f9f/NOTICE.md create mode 100644 research/common-core-fanin-seed93550f9f/README.md create mode 100644 research/common-core-fanin-seed93550f9f/RESULT.json create mode 100644 research/common-core-fanin-seed93550f9f/SOURCES.json create mode 100644 research/common-core-fanin-seed93550f9f/TASK.json create mode 100644 research/common-core-fanin-seed93550f9f/TASK.md create mode 100644 research/common-core-fanin-seed93550f9f/VERIFY.json create mode 100644 research/common-core-fanin-seed93550f9f/verify.py diff --git a/research/common-core-fanin-seed93550f9f/LICENSE b/research/common-core-fanin-seed93550f9f/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/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/common-core-fanin-seed93550f9f/NOTICE.md b/research/common-core-fanin-seed93550f9f/NOTICE.md new file mode 100644 index 0000000000..3d3765a315 --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/NOTICE.md @@ -0,0 +1,5 @@ +This package is original work prepared with substantial OpenAI Codex assistance in algebra, cost accounting, implementation, and verification. No predecessor code was imported. No independent human review is claimed. + +Predecessor credit: Ross Richardson's universal dirty-connector model (PR #943 lineage); PR #1531 for the arbitrary-map DUO; PR #1518 for the atomic TRIO; PR #1524 and Discussion #1579 for the equal-common-map mutable connector; PR #1739 for a rank-one map transition across consecutive source-updated calls. These works are pinned and distinguished in TASK.json and SOURCES.json. + +The package is licensed under the repository's Apache-2.0 license. It does not modify upstream sources or the selected certificate. diff --git a/research/common-core-fanin-seed93550f9f/README.md b/research/common-core-fanin-seed93550f9f/README.md new file mode 100644 index 0000000000..cf82a436dc --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/README.md @@ -0,0 +1,58 @@ +# Shared-core fan-in with simultaneous rank-one deviations + +This package gives an exact local connector construction for three distinct source maps that share one rank-48 core and differ from it by rank-one maps. It preserves arbitrary dirty source, target, and scratch rows. The code checks every F2 basis column of the full five-row interface and an integer-valued mixed-state fixture. + +The construction is + + B_j = B + D_j + z += B_1*x_1 + B_2*x_2 + B_3*x_3 + +with B = diag(I_48,0) on 49 coordinates and D_j = e_49*v_j^T. Each v_j is distinct and has final coordinate 1, so each B_j has rank 49. + +Let d be the arbitrary starting value of scratch t and S=x_1+x_2+x_3. The paid sequence is + + z -= B*d + t += x_1+x_2+x_3 + z += B*t + t -= x_1+x_2+x_3 + z += D_1*x_1 + z += D_2*x_2 + z += D_3*x_3 + +The signed core outputs add to -B*d+B*(d+S)=B*S. Over F2 the minus sign is the same as plus; over integer-valued rows the exact inverse sign cancels the arbitrary dirty term. The scratch returns to d; every source is unchanged. The three deviations contribute their own outputs. This establishes the requested map on arbitrary dirty rows without a clean vector. The local rank tariff prices both orientations of B at their larger complete-call cost; any orientation asymmetry in an actual supplier belongs in the remaining overhead budget. + +## Complete local cost + +The direct plan uses three complete rank-49 calls. The shared-core plan uses two rank-48 calls, three rank-one deviation calls, and six rank-one gather/restore calls. Every one of its 11 calls is charged one extra rank-one-equivalent dispatch unit; the direct plan's 3 calls are charged the same way. Thus the compared profiles are + +| Plan | Paid profile including dispatch | +| --- | --- | +| Direct | 3 rank-49 calls, 3 rank-one dispatch units | +| Shared core | 2 rank-48 calls, 20 rank-one units (9 complete rank-one operations and 11 dispatch units) | + +For q=1-a at the selected a=836330098538459/500000000000000000, the local moment difference is + + direct - shared = 3*49^q - 2*48^q - 17 > 28. + +The strict inequality is certified without floating point: a<1/100, 49^0.99>47 because 49^99>47^100, and 48^q<48. The construction therefore has a 28-unit budget for any remaining parent program, interface, hosting, or precision overhead measured in the same normalized units. + +The interface requires one 49-coordinate dirty scratch row. Summing three integer-valued sources can require two extra guard bits; these resources are stated explicitly and must fit the remaining overhead and live supplier stock. The F2 construction has no rounding or precision error. It changes no frame and hides no source map, recursive child, gather, correction, dispatch, or restoration call. + +This is a local construction under an explicit rank-class call tariff. It has not been matched to actual maps in the selected supplier. It does not establish a new supplier, new selected profile, or new kappa. Its direct relevance is conditional: an actual three-map seam must expose one common rank-48 core and three rank-one residuals, and its added dirty-row and guard-bit charges must fit the 28-unit budget. + +## Reproduce + +From the repository root: + + python3 -I -O -B research/common-core-fanin-seed93550f9f/verify.py + +Expected status: PASS_COMMON_CORE_FANIN_DIRTY_BOUNDARY. The verifier checks ranks 48/1/49, all 245 basis columns, an exact integer-valued fixture, four negative controls, the selected exponent pin, and the rational cost bound. + +## Source and predecessor pins + +The accepted selected record is pinned by its SHA-256 in SOURCES.json, alongside the maintainer review, integration receipt, selected source manifest, assembly certificate, current task catalogue, current autoresearch instructions, and universal connector model. Nearest open predecessors and exact heads are listed in TASK.json and SOURCES.json. + +## Open next questions + +- Does any live selected-supplier interface contain three simultaneous source maps with one shared high-rank core and rank-one residuals? This determines whether the local mechanism can change a paid profile. First step: extract one exact multi-source seam from the source manifest and compare its three map matrices over F2. Blocker: the selected construction has not yet been mapped to this multi-source interface. +- Can the required dirty 49-coordinate row and two guard bits be hosted within the 28-unit overhead cap? This decides whether the local cost screen survives supplier admission. First step: bind the scratch and precision requirements to one named selected call. Blocker: no such call has been identified. diff --git a/research/common-core-fanin-seed93550f9f/RESULT.json b/research/common-core-fanin-seed93550f9f/RESULT.json new file mode 100644 index 0000000000..3041225e50 --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/RESULT.json @@ -0,0 +1 @@ +{"basis_columns":245,"core_rank":48,"cost":{"a_lt_1_over_100":true,"baseline_core_and_correction_calls":3,"baseline_dispatch_units":3,"baseline_profile_including_dispatch":{"1":3,"49":3},"extra_dirty_scratch_rows":1,"factored_core_calls":2,"factored_dispatch_units":11,"factored_profile_including_dispatch":{"1":20,"48":2},"factored_rank_one_deviation_calls":3,"factored_rank_one_gather_restore_calls":6,"integer_lift_guard_bits":2,"lower_bound_saving_before_remaining_overhead":">28 rank-one-equivalent units","remaining_overhead_gate":"all extra interface, hosting, precision, and program costs must total < 28 units","scratch_coordinates":49,"selected_a":"836330098538459/500000000000000000","selected_supplier_or_kappa_claim":false},"deviation_ranks":[1,1,1],"dimension":49,"integer_replay":"PASS","negative_controls":4,"scope":"Exact local connector construction only; no supplier realization or new kappa.","source_map_ranks":[49,49,49],"sources":3,"status":"PASS_COMMON_CORE_FANIN_DIRTY_BOUNDARY"} diff --git a/research/common-core-fanin-seed93550f9f/SOURCES.json b/research/common-core-fanin-seed93550f9f/SOURCES.json new file mode 100644 index 0000000000..51dd7e610f --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/SOURCES.json @@ -0,0 +1,98 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", + "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "docs/research/community-batch1099-integration.json", + "usage": "provenance", + "git_blob": "9d60e86c0e494d17bec5e28eda41b275c9ede64e", + "sha256": "684c50d1ac69863e1fcc0a34bf76c54bac576f6bbde79b3c67d8432a495c8c1c" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "provenance", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/universal-connector-boundary/README.md", + "usage": "provenance", + "git_blob": "d277f7c5830b1f2bc42e1ff41ab86e7d7564929f", + "sha256": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476" + }, + { + "path": "research/complex-local-word-ceiling/README.md", + "usage": "provenance", + "git_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "sha256": "b60be039cb0e03e064a27407d0bce9e58908d793da5ee405c876de5aebfa5f81" + } + ], + "selected_record": { + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "integration": "docs/research/community-batch1099-integration.json", + "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "reproduction": "make frontier1094-verify" + }, + "predecessors": [ + { + "number": 1518, + "head": "0c6a58aaf22e0fc1b34497f8f6f80db6212b4621", + "title": "Atomic triple-sum connector; all source maps charged", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1518" + }, + { + "number": 1524, + "head": "5c1f39788a0fc669b7e37e27785c63e85788c350", + "title": "Uniform tariff for common-B mutable-source connector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1524" + }, + { + "number": 1531, + "head": "892b28a3358b16c9083036f71e1ef505ccf5d20a", + "title": "Two-source DUO; both source maps charged", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1531" + }, + { + "number": 1739, + "head": "e33645b34521460bce61f9fb913f98f506d34d4d", + "title": "Rank-one connector transition across consecutive source updates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1739" + } + ], + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18923279" +} diff --git a/research/common-core-fanin-seed93550f9f/TASK.json b/research/common-core-fanin-seed93550f9f/TASK.json new file mode 100644 index 0000000000..1f338c7fe7 --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/TASK.json @@ -0,0 +1,112 @@ +{ + "schema_version": 1, + "task_id": "connector-alphabet-change", + "priority_revision": 3, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "original_card": { + "id": "connector-alphabet-change", + "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?", + "starting_points": [ + "research/universal-connector-boundary/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct and charge a legal extra operation on a minimal instance.", + "Prove a target-specific bound after adding one specified operation family." + ], + "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free.", + "first_step": { + "command": [ + "python3", + "-B", + "research/universal-connector-boundary/verify.py" + ], + "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY", + "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.", + "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.", + "allowed_variations": [ + "Choose one additional operation and a small source count for its first counterexample." + ], + "scope_change_triggers": [ + "Keeping the alphabet and only increasing the source count; record this as a changed assignment." + ], + "overlap_terms": [ + "universal connector", + "source-toggle", + "connector alphabet" + ] + }, + "scope_status": "refined", + "actual_scope": "Exact three-source rank-48 common-core fan-in with three simultaneous rank-one source-map deviations; 49-coordinate arbitrary-dirty interface and complete local rank-moment invoice.", + "scope_change_reason": "The generic DUO/TRIO and equal-common-map connector scopes already have open results. This refines the accepted operation-extension task to one shared high-rank core plus distinct simultaneous rank-one deviations, which are not the same as a common map or a map update between calls.", + "bottleneck_link": "If three complete rank-49 source maps share one rank-48 core plus rank-one residuals, two core calls and charged dirty scratch restoration can replace three direct calls while lowering the local recursive moment.", + "budget_minutes": 60, + "stop_rule": "Stop at the exact three-source, rank-48/1/49 construction. Keep it only if all 245 F2 basis columns, the integer-valued replay, four negative controls, rank checks and strict fully charged local moment inequality pass. No source-count or rank sweep and no selected-kappa claim without a supplier map.", + "outcome": "completed", + "evidence": "README proof and complete cost table; verify.py exact matrix/rank replay on all 245 dirty-interface basis columns, integer-valued mixed fixture, four negative controls, selected exponent pin, and exact rational moment margin >28 before remaining overhead.", + "author": "OpenAI Codex research agent for Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in algebra, design, implementation, exact verification and writing. No independent human review or subagents.", + "open_questions": [ + { + "question": "Does a live selected-supplier call expose three simultaneous maps with one common high-rank core and rank-one residuals?", + "why_it_matters": "Without an exact supplier seam, the local construction cannot alter a paid recursive profile or the selected conditional exponent.", + "first_step": "Extract one exact three-source seam from the pinned source manifest and compare each map against a common rank-48 core over F2.", + "blocked_by": "No such multi-source selected-supplier interface is currently identified." + }, + { + "question": "Can the dirty 49-coordinate row and two-bit integer guard fit the remaining 28-unit normalized overhead budget?", + "why_it_matters": "These are required resources for the dirty-safe construction and could consume its full local moment margin.", + "first_step": "Bind the scratch row, call directions, dispatch records and guard-bit allowance to one named supplier call and evaluate its complete invoice.", + "blocked_by": "The construction has not been mapped to a live supplier seam; physical row stock and precision costs are therefore not yet measurable." + } + ], + "assignment_seed": "93550f9f7a77e57c8be488f86df218cc", + "external_track": "recursive-interfaces", + "coordination": { + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18923279", + "claim_created_at_utc": "2026-10-14T11:57:44Z", + "claim_expires_at_utc": "2026-10-14T13:55:00Z", + "final_overlap_refresh_required": true, + "pr_snapshot": "Complete pagination; 497 open PRs, snapshot fetched 2026-10-14T11:46:58Z.", + "discussion_snapshot": "Complete 478-record cached snapshot fetched 2026-10-14T11:37:27Z; refresh warned on GraphQL transport. Discussion #1163 was separately fetched through REST at 11:49Z.", + "nearest_prs": [ + { + "number": 1518, + "head": "0c6a58aaf22e0fc1b34497f8f6f80db6212b4621", + "title": "Atomic triple-sum connector; all source maps charged", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1518" + }, + { + "number": 1524, + "head": "5c1f39788a0fc669b7e37e27785c63e85788c350", + "title": "Uniform tariff for common-B mutable-source connector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1524" + }, + { + "number": 1531, + "head": "892b28a3358b16c9083036f71e1ef505ccf5d20a", + "title": "Two-source DUO; both source maps charged", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1531" + }, + { + "number": 1739, + "head": "e33645b34521460bce61f9fb913f98f506d34d4d", + "title": "Rank-one connector transition across consecutive source updates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1739" + } + ], + "distinction": "Simultaneous heterogeneous maps with a shared core and three rank-one differences; unlike DUO/TRIO charged per-source maps, equal-map mutable connector, or a sequential rank-one source-map update.", + "final_checks_at_utc": "2026-10-14T12:07:13Z", + "final_overlap_refresh_complete": false, + "final_overlap_note": "Live REST PR pagination/body filter found no relevant new shared-core or simultaneous low-rank source-map PR; only unrelated PR #148 matched. REST on Discussion #1163 was current through 12:07Z and showed no matching claim; #1579 and #1504 were rechecked. The full find_overlap Discussion GraphQL refresh stalled for 90 seconds; the latest complete cached Discussion snapshot is 478 records from 11:37:27Z. This limitation is retained rather than described as a complete global refresh.", + "final_rest_discussion_threads": { + "1163": "comments fetched through 2026-10-14T12:07:13Z", + "1579": "discussion body timestamp 2026-10-14T03:16:41Z; no comments returned", + "1504": "latest comment 2026-10-14T02:09:06Z" + }, + "final_rest_pr_filter": "Complete open-PR pagination and title/body filter for common-core, simultaneous-source, low-rank source, and rank-one-deviation wording; only unrelated #148 matched." + } +} diff --git a/research/common-core-fanin-seed93550f9f/TASK.md b/research/common-core-fanin-seed93550f9f/TASK.md new file mode 100644 index 0000000000..e74339d5ea --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/TASK.md @@ -0,0 +1,56 @@ +# Cycle I task card + +- Track: `recursive-interfaces`. +- Seed: `93550f9f7a77e57c8be488f86df218cc` (OS random; accepted eligible draw). +- Task ID: `connector-alphabet-change`; scope refined to a common-core, low-rank-correction fan-in. +- Catalogue priority revision: 3; catalogue SHA-256: `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`. +- Drawn scope key: `0c9f43f3c7d61edb36fe`. +- Exact base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`. +- Selected-result SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Authoritative selected conditional exponent: `836330098538459/500000000000000000` (`0.001672660197076918`). + +## Object and question + +For three arbitrary dirty sources `x1,x2,x3`, an arbitrary dirty target `z`, and an arbitrary dirty scratch row `t`, can the simultaneous operation + + z += B1*x1 + B2*x2 + B3*x3 + +be implemented more cheaply when `B_j = B + D_j`, the shared core `B` has rank 48, and each `D_j` has rank one, than three separate rank-49 map calls? + +The bounded instance has 49 coordinates, `B = diag(I_48, 0)`, and `D_j = e_49 v_j^T` for three distinct rows `v_j` whose last entry is 1. Thus each `B_j` has rank 49. The exact F2-linear map is also checked over integer-valued rows. All five rows may start dirty. + +## Changed premise and method + +The ordinary DUO/TRIO operations charge each distinct source map in full. This scope permits one shared rank-48 core plus three rank-one source-specific deviations. The proposed implementation subtracts `B*t` for the arbitrary dirty starting value, gathers the three sources into `t`, adds `B*t`, and then restores the scratch with six charged rank-one additions. It applies each `D_j` once and does not assume a clean vector or discard any source. The rank-48 tariff charges both core orientations at the larger complete-call cost. + +## Nearest overlap and distinction + +- PR #1531, head `892b28a3358b16c9083036f71e1ef505ccf5d20a`: arbitrary-map DUO, fully charges both source-map traversals. +- PR #1518, head `0c6a58aaf22e0fc1b34497f8f6f80db6212b4621`: atomic TRIO, charges every source map. +- PR #1524, head `5c1f39788a0fc669b7e37e27785c63e85788c350`, and Discussion #1579: common-B tariff where source maps are identical; this task permits distinct rank-one deviations. +- PR #1739, head `e33645b34521460bce61f9fb913f98f506d34d4d`: a rank-one map transition between consecutive calls after a source update; this task combines three maps simultaneously. +- Recent claims on Discussion #1163 cover C5 restoration and a heterogeneous two-type boundary, not this shared-core fan-in. + +The initial overlap scan used complete PR pagination and a complete 478-record Discussion snapshot from 11:37 UTC; its Discussion refresh had a GitHub GraphQL transport warning. Before handoff, the live PR list was filtered through REST for common-core, simultaneous-source, low-rank, and rank-one-deviation wording; only unrelated PR #148 matched. Discussion #1163 was fetched through REST through 12:07 UTC, and the common-B claim in #1579 plus the connector thread #1504 were rechecked. No exact shared-core/rank-one simultaneous-source claim appeared. A later full `find_overlap --refresh` fetched PRs but its global Discussion scan hung in the GraphQL client for 90 seconds, so the final global Discussion snapshot remains the complete 11:37 UTC cache plus these direct thread checks. + +## Optimistic complete-cost screen + +Write `q = 1 - a`, with `a` the selected exponent. The direct plan pays three rank-49 calls plus one unit of root dispatch per call: `3*49^q + 3`. + +The factored plan pays two rank-48 core calls, three rank-one deviations, six rank-one source gather/restore operations, and one dispatch unit for each of its eleven calls: `2*48^q + 9 + 11`. + +The optimistic saving before any additional interface overhead is therefore + + 3*49^q - 2*48^q - 17. + +The selected exponent satisfies `a < 1/100`; the exact integer inequality `49^99 > 47^100` gives `49^q > 47`, while `q < 1` gives `48^q < 48`. The saving is consequently greater than 28 rank-one-equivalent units. All additional root program, scratch hosting, and integer-lift precision cost must be charged inside this remaining 28-unit budget. The implementation requires one 49-coordinate dirty row; the integer lift needs at most two extra guard bits for summing three source rows. If these costs cannot be placed within the budget and the supplier's available row stock, the construction does not transfer to the selected bound. + +No frame changes or source/target copies are omitted. The six scratch toggles and all three deviations are included above; scratch restoration is exact. The screen is local to this rank-class interface and does not claim supplier realization, a new paid profile, or a new `kappa`. + +## Domain, stop rule, deliverable + +- Domain: exactly three source maps, one rank-48 shared core, three rank-one deviations, 49 coordinates, arbitrary dirty sources/target/scratch. +- Method: explicit factorized construction plus exact matrix/rank replay; no unbounded search. +- Stop: retain the construction only if the dirty-state identity, map ranks, negative controls, and the strict cost inequality all pass. Do not expand to more sources or other ranks in this cycle. +- Expected artifact: this task card, exact verifier, literal maps and cost certificate, reproducible from the repository root. Local result only unless the physical row/precision overhead can be matched to a live supplier interface. +- Predecessors retain attribution. This work uses no predecessor implementation code. Prepared with substantial OpenAI Codex assistance. diff --git a/research/common-core-fanin-seed93550f9f/VERIFY.json b/research/common-core-fanin-seed93550f9f/VERIFY.json new file mode 100644 index 0000000000..18cdf390bc --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/VERIFY.json @@ -0,0 +1,22 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Exact rank-48/rank-one/rank-49 maps, arbitrary-dirty 245-column boundary replay, integer-valued exact replay, four semantic failure controls, selected exponent binding, and strict rational moment margin." + } + ] +} diff --git a/research/common-core-fanin-seed93550f9f/verify.py b/research/common-core-fanin-seed93550f9f/verify.py new file mode 100644 index 0000000000..0c6f824232 --- /dev/null +++ b/research/common-core-fanin-seed93550f9f/verify.py @@ -0,0 +1,264 @@ +#!/usr/bin/env python3 +"""Exact dirty-state replay for a shared-core, rank-one-correction fan-in.""" + +from fractions import Fraction +import json +from pathlib import Path + + +N = 49 +R = 48 +SOURCES = 3 +SELECTED_A = Fraction(836330098538459, 500000000000000000) + + +def require(condition, message): + if not condition: + raise AssertionError(message) + + +def rank_f2(matrix): + rows = [sum((value & 1) << col for col, value in enumerate(row)) + for row in matrix] + ncols = len(matrix[0]) if matrix else 0 + pivot_row = 0 + for col in range(ncols): + pivot = next((r for r in range(pivot_row, len(rows)) + if (rows[r] >> col) & 1), None) + if pivot is None: + continue + rows[pivot_row], rows[pivot] = rows[pivot], rows[pivot_row] + for r in range(len(rows)): + if r != pivot_row and ((rows[r] >> col) & 1): + rows[r] ^= rows[pivot_row] + pivot_row += 1 + if pivot_row == len(rows): + break + return pivot_row + + +def matvec(matrix, vector, mod2=False): + out = [sum(coefficient * value + for coefficient, value in zip(row, vector)) + for row in matrix] + return [value & 1 for value in out] if mod2 else out + + +def add_scaled(target, source, scale=1, mod2=False): + out = [left + scale * right for left, right in zip(target, source)] + return [value & 1 for value in out] if mod2 else out + + +def make_maps(): + core = [[0] * N for _ in range(N)] + for i in range(R): + core[i][i] = 1 + + deltas = [] + maps = [] + for extra_coordinate in (0, 1, 2): + row = [0] * N + row[extra_coordinate] = 1 + row[-1] = 1 + delta = [[0] * N for _ in range(N)] + delta[-1] = row + deltas.append(delta) + maps.append([[core[i][j] + delta[i][j] for j in range(N)] + for i in range(N)]) + return core, deltas, maps + + +CORE, DELTAS, MAPS = make_maps() + + +def baseline(sources, target, mod2=False): + out = target[:] + for matrix, source in zip(MAPS, sources): + out = add_scaled(out, matvec(matrix, source, mod2), mod2=mod2) + return out + + +def factored(sources, target, scratch, omit_first_core=False, + omit_delta=None, omit_restore_source=None, + omit_gather_restore_source=None, mod2=False): + out = target[:] + temp = scratch[:] + + # The first core call cancels the unknown initial contents of temp. + if not omit_first_core: + out = add_scaled(out, matvec(CORE, temp, mod2), -1, mod2) + + # These are six complete rank-one row additions in the 3-source case. + for index, source in enumerate(sources): + if index != omit_gather_restore_source: + temp = add_scaled(temp, source, mod2=mod2) + out = add_scaled(out, matvec(CORE, temp, mod2), mod2=mod2) + for index, source in enumerate(sources): + if index != omit_restore_source and index != omit_gather_restore_source: + temp = add_scaled(temp, source, -1, mod2) + + for index, (delta, source) in enumerate(zip(DELTAS, sources)): + if index != omit_delta: + out = add_scaled(out, matvec(delta, source, mod2), mod2=mod2) + return out, temp + + +def basis_replay(): + # The complete map is linear in all 5 arbitrary rows. Equality on this + # basis proves the identity for every F2 input and every dirty entry state. + for role in range(5): + for coordinate in range(N): + sources = [[0] * N for _ in range(SOURCES)] + target = [0] * N + scratch = [0] * N + if role < SOURCES: + sources[role][coordinate] = 1 + elif role == SOURCES: + target[coordinate] = 1 + else: + scratch[coordinate] = 1 + expected = baseline(sources, target, mod2=True) + actual, restored = factored(sources, target, scratch, mod2=True) + require(actual == expected, + f"binary basis mismatch role={role} coordinate={coordinate}") + require(restored == scratch, + f"scratch restoration mismatch role={role} coordinate={coordinate}") + + +def integer_replay(): + sources = [ + [((i * 17 + 3) % 11) - 5 for i in range(N)], + [((i * 29 + 8) % 13) - 6 for i in range(N)], + [((i * 31 + 1) % 17) - 8 for i in range(N)], + ] + target = [((i * 7 + 2) % 19) - 9 for i in range(N)] + scratch = [((i * 23 + 5) % 21) - 10 for i in range(N)] + initial_sources = [row[:] for row in sources] + initial_scratch = scratch[:] + actual, restored = factored(sources, target, scratch) + require(actual == baseline(sources, target), "integer-valued map mismatch") + require(restored == initial_scratch, "integer-valued scratch was not restored") + require(sources == initial_sources, "a source row was modified") + + +def negative_controls(): + zero_sources = [[0] * N for _ in range(SOURCES)] + zero_target = [0] * N + dirty = [0] * N + dirty[0] = 1 + correct, _ = factored(zero_sources, zero_target, dirty, mod2=True) + require(correct == zero_target, "positive dirty scratch control failed") + + # A one-core-call shortcut appears valid with clean scratch but leaks B*t + # for an arbitrary dirty scratch row. + faulty_one_core = add_scaled(zero_target, matvec(CORE, dirty, mod2=True), mod2=True) + require(faulty_one_core != correct, + "dirty-scratch control failed to reject a one-core shortcut") + + source3 = [[0] * N for _ in range(SOURCES)] + source3[2][-1] = 1 + expected = baseline(source3, zero_target, mod2=True) + missing_delta, restored = factored(source3, zero_target, zero_target, + omit_delta=2, mod2=True) + require(missing_delta != expected, + "omitted-correction control was not rejected") + require(restored == zero_target, + "omitted-correction control changed scratch") + + source2 = [[0] * N for _ in range(SOURCES)] + source2[1][4] = 1 + expected = baseline(source2, zero_target, mod2=True) + missing_source, restored = factored( + source2, zero_target, zero_target, + omit_gather_restore_source=1, mod2=True) + require(missing_source != expected, + "omitted-source control was not rejected") + require(restored == zero_target, + "omitted-source control changed scratch") + + leak_sources = [[0] * N for _ in range(SOURCES)] + leak_sources[1][4] = 1 + dirty2 = [0] * N + dirty2[3] = 1 + leaked_output, leaked_scratch = factored( + leak_sources, zero_target, dirty2, omit_restore_source=1, mod2=True) + require(leaked_scratch != dirty2, + "omitted-restore control was not rejected") + require(leaked_output == baseline(leak_sources, zero_target, mod2=True), + "restore omission changed the computed target") + + +def cost_screen(): + a = SELECTED_A + require(a < Fraction(1, 100), "selected exponent no longer fits the screen") + require(49 ** 99 > 47 ** 100, + "exact lower bound for 49^(0.99) > 47 failed") + + baseline_profile = {49: 3, 1: 3} # 3 maps plus one dispatch unit each. + factored_profile = {48: 2, 1: 20} # 9 child ops plus 11 dispatch units. + require(sum(r * n for r, n in baseline_profile.items()) == 150, + "baseline rank-mass receipt changed") + require(sum(r * n for r, n in factored_profile.items()) == 116, + "factored rank-mass receipt changed") + + # With q=1-a, 49^q > 49^0.99 > 47 and 48^q < 48. + # Hence old-new > 3*47 - 2*48 - 17 = 28. + # H is every additional parent/interface cost in rank-one equivalents. + return { + "selected_a": str(a), + "a_lt_1_over_100": True, + "baseline_profile_including_dispatch": {str(k): v for k, v in baseline_profile.items()}, + "factored_profile_including_dispatch": {str(k): v for k, v in factored_profile.items()}, + "baseline_core_and_correction_calls": 3, + "factored_core_calls": 2, + "factored_rank_one_deviation_calls": 3, + "factored_rank_one_gather_restore_calls": 6, + "baseline_dispatch_units": 3, + "factored_dispatch_units": 11, + "extra_dirty_scratch_rows": 1, + "scratch_coordinates": N, + "integer_lift_guard_bits": 2, + "lower_bound_saving_before_remaining_overhead": ">28 rank-one-equivalent units", + "remaining_overhead_gate": "all extra interface, hosting, precision, and program costs must total < 28 units", + "selected_supplier_or_kappa_claim": False, + } + + +def main(): + root = Path(__file__).resolve().parents[2] + selected = json.loads((root / "certificates/selected-result.json").read_text()) + require(selected["kappa"] == str(SELECTED_A), + "selected-result exponent changed from the task pin") + + core_rank = rank_f2(CORE) + delta_ranks = [rank_f2(delta) for delta in DELTAS] + map_ranks = [rank_f2(matrix) for matrix in MAPS] + require(core_rank == 48, f"core rank is {core_rank}, expected 48") + require(delta_ranks == [1, 1, 1], f"deviation ranks changed: {delta_ranks}") + require(map_ranks == [49, 49, 49], f"source-map ranks changed: {map_ranks}") + require(len({tuple(delta[-1]) for delta in DELTAS}) == SOURCES, + "source deviations must be distinct") + + basis_replay() + integer_replay() + negative_controls() + cost = cost_screen() + + result = { + "status": "PASS_COMMON_CORE_FANIN_DIRTY_BOUNDARY", + "dimension": N, + "sources": SOURCES, + "core_rank": core_rank, + "deviation_ranks": delta_ranks, + "source_map_ranks": map_ranks, + "basis_columns": 5 * N, + "integer_replay": "PASS", + "negative_controls": 4, + "cost": cost, + "scope": "Exact local connector construction only; no supplier realization or new kappa.", + } + print(json.dumps(result, sort_keys=True, separators=(",", ":"))) + + +if __name__ == "__main__": + main() From 1fa62d83ab02e21971cc8b9ef524e5a3ea584d58 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 07:12:24 -0500 Subject: [PATCH 2/2] Record shared-core fan-in handoff --- .../common-core-fanin-seed93550f9f/TASK.json | 19 +++++++++++++++++++ .../common-core-fanin-seed93550f9f/TASK.md | 7 +++++++ 2 files changed, 26 insertions(+) diff --git a/research/common-core-fanin-seed93550f9f/TASK.json b/research/common-core-fanin-seed93550f9f/TASK.json index 1f338c7fe7..73d827bd46 100644 --- a/research/common-core-fanin-seed93550f9f/TASK.json +++ b/research/common-core-fanin-seed93550f9f/TASK.json @@ -108,5 +108,24 @@ "1504": "latest comment 2026-10-14T02:09:06Z" }, "final_rest_pr_filter": "Complete open-PR pagination and title/body filter for common-core, simultaneous-source, low-rank source, and rank-one-deviation wording; only unrelated #148 matched." + }, + "publication": { + "pr_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1863", + "head_commit": "53e716e640d998c81886aed7bae3c71e20985c36", + "state": "open", + "mergeable": true, + "checks_at_handoff": { + "observed_at_utc": "2026-10-14T12:11:43Z", + "total": 61, + "status": "all queued" + }, + "discussion_handoff_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18923560", + "remaining_obligations": [ + "Map the local rank-class construction to a named selected-supplier seam.", + "Charge dirty-row hosting, two guard bits, orientation asymmetry, and all remaining interface overhead against the 28-unit budget.", + "Await registered Python 3.12 CI replay." + ], + "selected_frontier_changed": false, + "new_kappa_claimed": false } } diff --git a/research/common-core-fanin-seed93550f9f/TASK.md b/research/common-core-fanin-seed93550f9f/TASK.md index e74339d5ea..8f173f920f 100644 --- a/research/common-core-fanin-seed93550f9f/TASK.md +++ b/research/common-core-fanin-seed93550f9f/TASK.md @@ -54,3 +54,10 @@ No frame changes or source/target copies are omitted. The six scratch toggles an - Stop: retain the construction only if the dirty-state identity, map ranks, negative controls, and the strict cost inequality all pass. Do not expand to more sources or other ranks in this cycle. - Expected artifact: this task card, exact verifier, literal maps and cost certificate, reproducible from the repository root. Local result only unless the physical row/precision overhead can be matched to a live supplier interface. - Predecessors retain attribution. This work uses no predecessor implementation code. Prepared with substantial OpenAI Codex assistance. + +## Handoff + +- Focused PR: https://github.com/CrocSwap/integer-mult-bounds/pull/1863, head `53e716e640d998c81886aed7bae3c71e20985c36`. +- Original claim updated with the result: https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18923560. +- PR was open and mergeable at handoff; all 61 checks were queued at the latest poll. +- Remaining obligations: map the construction to a concrete selected-supplier seam and charge the dirty-row, guard-bit, and remaining interface costs. No selected-profile or `kappa` change is claimed.