diff --git a/research/bit-family-projector-algebra-seed10/CLAIM.md b/research/bit-family-projector-algebra-seed10/CLAIM.md new file mode 100644 index 0000000000..38b438df89 --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/CLAIM.md @@ -0,0 +1,23 @@ +# Local sprint claim + +- Track and seed: Bit supplier, OS seed 10 (`/dev/urandom`). +- Base: `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. +- Object: PR #1351's selected PR589 physical family `(pair=1, copy=0)`, children 0 and 7. +- Method: independently certify the q-perp and coordinate projectors, prove pairwise orthogonality and exact sums, then apply the block identity for D(P). This is distinct from PR #1351's 128-column replay; the audit is conditional on its pinned role map. +- Deliverable: exact rational verifier, source pins, interval certificate, and omitted-helper/wrong-axis/duplicate controls. No new kappa or supplier admission claim. +- Expected finish: 2026-10-14 00:00 UTC. +- Coordination: no pinned sprint coordination issue found, so this claim is recorded locally. + +Overlap checked against PR #1345 (fixed-word gate-order transports), #1334 +(revision-3 bit levers at a=1/99), #1351 (one-family matrix realization), +#1333 (binary-affine register model), and #1307 (all-family geometric census). +This is an explicitly different-method independent audit of #1351, allowed by +the sprint instruction. The PR #1351 source pin is head +`6060e62e9d42a16eff493aba74c8a617a12d8041`. + +## Result and handoff + +The rational verifier proves both pinned interval decompositions and rejects +all three mutated controls. It prints +`PASS_BIT_FAMILY_PROJECTOR_ALGEBRA children=0,7 factors=2+4 q_rank=7 controls=3 no_new_kappa`. +One focused pull request is open: [#1371](https://github.com/CrocSwap/integer-mult-bounds/pull/1371). diff --git a/research/bit-family-projector-algebra-seed10/LICENSE b/research/bit-family-projector-algebra-seed10/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/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/bit-family-projector-algebra-seed10/NOTICE.md b/research/bit-family-projector-algebra-seed10/NOTICE.md new file mode 100644 index 0000000000..477110ccca --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/NOTICE.md @@ -0,0 +1,6 @@ +This package is new work under the repository's Apache-2.0 license. The +retained `PR1351-RESULT.json` is a small result record from CrocSwap/integer-mult-bounds +PR #1351 at commit `6060e62e9d42a16eff493aba74c8a617a12d8041`, used with +attribution as the exact target of this independent audit. Selected inputs and +predecessor contributions remain governed by their original repository +notices. diff --git a/research/bit-family-projector-algebra-seed10/PR1351-RESULT.json b/research/bit-family-projector-algebra-seed10/PR1351-RESULT.json new file mode 100644 index 0000000000..4865d97527 --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/PR1351-RESULT.json @@ -0,0 +1,235 @@ +{ + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "family": { + "child_ids": [ + 0, + 7 + ], + "copy": 0, + "pair": 1, + "port": 0, + "roles": [ + [ + 0, + 0, + 0, + 8, + 1, + 0 + ], + [ + 7, + 0, + 0, + 8, + 5, + 429 + ], + [ + 7, + 0, + 8, + 8, + 5, + 430 + ], + [ + 7, + 0, + 16, + 8, + 5, + 431 + ] + ], + "side": 0 + }, + "interval_results": { + "0": { + "chronological_order": [ + "host:child0:stage1:helper0", + "idle-remainder:child0" + ], + "columns_checked": 128, + "deadline_event_position": 2, + "equal": true, + "host_axes": [ + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "host_event_positions": [ + 1 + ], + "host_labels": [ + "child0:stage1:helper0" + ], + "host_ranks": [ + 8 + ], + "remainder_axes": [ + 9, + 10, + 11, + 12, + 13, + 14 + ], + "remainder_rank": 6, + "source_axes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14 + ], + "source_rank": 14 + }, + "7": { + "chronological_order": [ + "host:child7:stage5:helper429", + "host:child7:stage5:helper430", + "host:child7:stage5:helper431", + "idle-remainder:child7" + ], + "columns_checked": 128, + "deadline_event_position": 22, + "equal": true, + "host_axes": [ + [ + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43 + ], + [ + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51 + ], + [ + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59 + ] + ], + "host_event_positions": [ + 13, + 13, + 13 + ], + "host_labels": [ + "child7:stage5:helper429", + "child7:stage5:helper430", + "child7:stage5:helper431" + ], + "host_ranks": [ + 8, + 8, + 8 + ], + "remainder_axes": [ + 60, + 61, + 62, + 63 + ], + "remainder_rank": 4, + "source_axes": [ + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "source_rank": 28 + } + }, + "scope": "One selected PR589 physical family only; finite exact address operators, no full supplier admission or new kappa.", + "source_hashes": { + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "docs/research/agent-task-catalog.json": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "research/community-frontier1094-audit/SELECTED-SOURCE.json": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "research/e8-bit-p111-tuned/data/selection9-p111.json": "4ab1ed4529683cd184987f8bc3031fb7408b9cd22c25ab9cf541a8aaf896eaf1", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + "status": "PASS_PR589_PHYSICAL_FAMILY", + "summary": { + "child0_hosted_rank": 8, + "child0_remainder_rank": 6, + "child0_source_rank": 14, + "child7_hosted_rank": 24, + "child7_remainder_rank": 4, + "child7_source_rank": 28, + "children": 2, + "exact_basis_columns_per_interval": 128, + "helper_occurrences": 4, + "helper_order_permutations_checked": 6, + "one_replica_slots": 3951, + "rejected_controls": [ + "omitted_helper", + "equal_rank_wrong_axis", + "duplicate_helper", + "wrong_source_port" + ], + "source_idle_children": 10, + "source_schedule_events": 29 + } +} diff --git a/research/bit-family-projector-algebra-seed10/PROOF.md b/research/bit-family-projector-algebra-seed10/PROOF.md new file mode 100644 index 0000000000..75b1c7980a --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/PROOF.md @@ -0,0 +1,61 @@ +# Exact projector decomposition + +## Scope + +Fix PR #1351's pinned family role map and its two interval descriptions. The +claim here is only the finite address-operator identity for those maps. The +schedule reconstruction, family selection, scalar word, helper lowering and +supplier admission remain inherited obligations. + +## Projectors + +The selected line q has eight rational entries and q-transpose-q equals 4. +Its perpendicular projector is + + K = I_8 - q q^T / 4. + +Thus K is symmetric, K squared equals K, q is in its kernel, and trace(K)=7. +For a host or remainder axes record, the ambient 64-dimensional projector is +K on the first eight coordinates when the full q-perp block is present, plus +the coordinate projectors for its external axes. The verifier establishes +these statements over rational numbers. + +## Frozen interval decompositions + +Child 0 has host axes `[1,2,3,4,5,6,7,8]`, remainder axes `[9,...,14]`, and +source axes `[1,...,14]`. The host projector is K plus the projector onto +coordinate 8. The remainder consists of the six coordinate projectors 9 +through 14. Their product is zero in either order, and their sum is the source +projector. + +Child 7 has host axes `[36,...,43]`, `[44,...,51]`, `[52,...,59]`, remainder +axes `[60,...,63]`, and source axes `[36,...,63]`. These four projectors are +coordinate projectors on disjoint axes, so every pairwise product is zero and +their sum is the source projector. + +## Block identity + +For projectors P and Q with PQ=QP=0, direct block multiplication gives + + D(P)D(Q) + = [[I-P-Q+2PQ, P+Q-2PQ], [P+Q-2PQ, I-P-Q+2PQ]] + = D(P+Q). + +Induction gives the same result for any finite pairwise-orthogonal list. Since +the verifier checks that each interval's listed factors are symmetric +idempotents, pairwise orthogonal, and sum exactly to its source projector, the +entire 128-dimensional address operator equals D(source). Orthogonality also +makes the product independent of the order of those factors. No finite basis +replay is used in this implication. + +## Controls and limits + +The checker confirms that dropping child 7's last helper, changing child 0's +external host axis from 8 to 22 while preserving rank, or duplicating a helper +breaks the orthogonal decomposition. These controls cover the algebraic +certificate's exact target; they do not test the complete supplier pipeline. + +The input `PR1351-RESULT.json` is pinned to the open PR head recorded in +`SOURCES.json`. This audit does not independently regenerate the PR's role map +or prove its chronology. The selected kappa and all source files remain +unchanged; no new exponent bound follows. diff --git a/research/bit-family-projector-algebra-seed10/README.md b/research/bit-family-projector-algebra-seed10/README.md new file mode 100644 index 0000000000..02bf22ead4 --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/README.md @@ -0,0 +1,81 @@ +# PR589 physical-family projector algebra audit + +**Independent verification; no new kappa.** This package audits the exact +address-operator identity for family `(pair=1, copy=0)` in the selected PR589 +bit supplier. It uses exact rational projector algebra and the block identity +below, not PR #1351's 128-column operator replay. The audit is conditional on +the frozen role map and interval axes recorded by PR #1351. + +## Finding + +The q-perp projector has rank seven. In child 0, its rank-seven block and +coordinate axis 8 make the rank-eight host; axes 9 through 14 are the rank-six +remainder. Their projectors are orthogonal and sum to the rank-fourteen source +projector. In child 7, the three rank-eight coordinate hosts on axes 36 through +59 and the rank-four remainder on axes 60 through 63 are mutually orthogonal +and sum to the rank-twenty-eight source projector. + +For orthogonal projectors P and Q, the exact identity + + D(P) D(Q) = D(P + Q), D(P) = [[I-P, P], [P, I-P]] + +proves the full 128-dimensional address-map equality for each interval. The +verifier checks the exact 64-by-64 projectors, their ranks, idempotence, +orthogonality and sums with fractions. It also rejects an omitted helper, a +same-rank wrong-axis helper, and a duplicated helper. + +This adds a symbolic proof route for the two frozen interval maps. It does not +rebuild the selected slot allocator or independently prove PR #1351's family +selection, chronology, or helper lowering. It does not change the paid profile, +the selected kappa, or supplier admission. + +## Assignment and overlap + +- Track: Bit supplier; OS assignment seed 10; exact base + `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. +- The selected certificate is `research/community-frontier1094-audit/ASSEMBLY.json`, + reviewed in `docs/research/community-batch1099-review.md`. Its selected value + is kappa `836330098538459/500000000000000000`; its bit side inherits PR589 + commit `a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46`. +- Candidate #1345 exhausts its stated fixed-word single and pair gate-order + transport scope; #1334 prices its stated revision-3 lever relaxations at + `a=1/99`; #1351 checks the same family by a different method. This package is + deliberately an independent second audit of #1351's algebraic identity. +- PR #1307's all-family geometric census supplies useful predecessor context, + including the warning that weaker slot/count conditions do not imply the + physical projector map. Its production pipeline found no acceptance bug. +- No pinned sprint coordination issue was found. The local claim is in + `CLAIM.md`; assignment screening and the fresh overlap snapshot are in + `../seed10-bit-supplier/ASSIGNMENT.json`. + +The exact PR #1351 head, result blob, and all consumed base files are pinned in +`SOURCES.json`. The predecessor result is retained as `PR1351-RESULT.json` so +the audit can be reproduced even if that PR changes or closes. + +## Reproduce + +From the repository root: + +```sh +python3 -I -O -B research/bit-family-projector-algebra-seed10/verify.py +``` + +Expected output: + +```text +PASS_BIT_FAMILY_PROJECTOR_ALGEBRA children=0,7 factors=2+4 q_rank=7 controls=3 no_new_kappa +``` + +## Open next questions + +No new next question is claimed here. PR #1351 already lists the wider check of +all 444 mixed-child families and a full caller replay as follow-up work. + +## Credit and disclosure + +Credit 1337isnot1337 for PR #1351's frozen target certificate, commdata2338 for +PR #1307's geometric census, and DreamingOfClouds and eumemic for the selected +PR589/PR555 supplier lineage. Prepared by Cinna Davis with substantial OpenAI +Codex assistance for research, implementation, verification and writing. No +subagents or independent human review are claimed. The package carries the +repository Apache-2.0 license. diff --git a/research/bit-family-projector-algebra-seed10/RESULT.json b/research/bit-family-projector-algebra-seed10/RESULT.json new file mode 100644 index 0000000000..e0e4e89c70 --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/RESULT.json @@ -0,0 +1,52 @@ +{ + "status": "PASS_BIT_FAMILY_PROJECTOR_ALGEBRA", + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "pr1351_head": "6060e62e9d42a16eff493aba74c8a617a12d8041", + "pr1351_result_git_blob": "4865d97527a9457dd28c0439ba89a1b072a64008", + "selected_kappa": "836330098538459/500000000000000000", + "family": { + "pair": 1, + "copy": 0, + "side": 0, + "port": 0 + }, + "q_perp_rank": 7, + "intervals": [ + { + "child": 0, + "factor_ranks": [ + 8, + 6 + ], + "source_rank": 14, + "host_event_positions": [ + 1 + ], + "deadline_event_position": 2 + }, + { + "child": 7, + "factor_ranks": [ + 8, + 8, + 8, + 4 + ], + "source_rank": 28, + "host_event_positions": [ + 13, + 13, + 13 + ], + "deadline_event_position": 22 + } + ], + "block_identity": "pairwise orthogonal P_i imply product D(P_i)=D(sum P_i)", + "negative_controls": { + "omitted_helper": "rejected", + "same_rank_wrong_axis": "rejected", + "duplicate_helper": "rejected" + }, + "no_new_kappa": true, + "scope": "Exact operator identities conditional on the pinned PR1351 role map; no independent family selection, chronology replay, helper lowering, or supplier admission." +} diff --git a/research/bit-family-projector-algebra-seed10/SOURCES.json b/research/bit-family-projector-algebra-seed10/SOURCES.json new file mode 100644 index 0000000000..e7620bc03a --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/SOURCES.json @@ -0,0 +1,93 @@ +{ + "schema_version": 1, + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb", + "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/e8-bit-carrier-skeleton/code/nine/geometry.py", + "usage": "input", + "git_blob": "91594e0223e8fac49162b5aef834ffaa8e94a254", + "sha256": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca" + }, + { + "path": "research/e8-bit-p111-tuned/data/selection9-p111.json", + "usage": "input", + "git_blob": "e69ea66a3add357f570fc5552ab6368b3c8f9bb2", + "sha256": "4ab1ed4529683cd184987f8bc3031fb7408b9cd22c25ab9cf541a8aaf896eaf1" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "usage": "input", + "git_blob": "3df12bd632f1fdba825ced57110a1fee82eb2857", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "docs/research/current-status.md", + "usage": "provenance", + "git_blob": "aa3cf49715cd367ad8c4e63ab28856fc0d19794f", + "sha256": "1f59d648763c77d574d18dc59ea8bf62d2ee74aaed3c202c9c8cfa4f901badbd" + }, + { + "path": "docs/research/pr-ledger.md", + "usage": "provenance", + "git_blob": "4331ba3175b3418f70fb5cf7ee9689b3505c0678", + "sha256": "8030b58f708e40aee4e40f950a20a0b0ccef3f92b08e6e089fe35db82ec027e6" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + } + ], + "predecessor_record": { + "repository": "CrocSwap/integer-mult-bounds", + "pr": 1351, + "commit": "6060e62e9d42a16eff493aba74c8a617a12d8041", + "path": "research/seed03-bit-physical-family/RESULT.json", + "git_blob": "4865d97527a9457dd28c0439ba89a1b072a64008", + "sha256": "3702b8cf99b5cefada0bff568ac54c05ef23996d2282684a3f00ec051bb6054b", + "status_at_selection": "open" + } +} diff --git a/research/bit-family-projector-algebra-seed10/TASK.json b/research/bit-family-projector-algebra-seed10/TASK.json new file mode 100644 index 0000000000..a0d4254db9 --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/TASK.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 2, + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "original_card": { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + "scope_status": "changed", + "actual_scope": "Independent exact algebraic audit of the selected PR589 physical family (pair=1, copy=0): certify its two address-operator decompositions by orthogonal projectors, conditional on the pinned PR #1351 role map.", + "scope_change_reason": "The fixed-word transport, a=1/99 lever relaxation, and original family replay already have live claims (#1345, #1334, #1351). This is the explicitly permitted second audit of #1351, using a different proof obligation: exact projector orthogonality and a block-matrix identity, rather than a 128-column operator replay.", + "bottleneck_link": "Checks whether the selected bit supplier's assigned helper address maps really compose to each pending source map. It changes confidence in a finite decoder interface, not its paid profile or selected kappa.", + "budget_minutes": 41, + "stop_rule": "Stop after source pins, both interval decompositions, the block identity, and omitted-helper/wrong-axis/duplicate controls pass. Do not generalize to other families or infer a supplier improvement.", + "outcome": "completed", + "evidence": "The direct verifier and focused control check pass under CPython 3.14.7; scripts/research_package.py --check-only passes. The registered Python 3.12 wrapper could not run because Python 3.12 is not installed locally.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance with source inspection, proof design, implementation, verification, and writing; no subagents or independent human review claimed.", + "open_questions": [], + "no_open_questions_reason": "The natural wider question, auditing all 444 mixed-child families, is already listed in PR #1351's Open next questions and is outside this seed's claim." +} diff --git a/research/bit-family-projector-algebra-seed10/VERIFY.json b/research/bit-family-projector-algebra-seed10/VERIFY.json new file mode 100644 index 0000000000..feadbe1186 --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/VERIFY.json @@ -0,0 +1,40 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/community-frontier1094-audit/ASSEMBLY.json", + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py", + "research/e8-bit-p111-tuned/data/selection9-p111.json", + "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "PR1351 predecessor record and all 13 selected-source hashes; exact q-perp rank-7 projector; child 0 and 7 projector decompositions; three rejecting negative controls; unchanged selected kappa" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_package.py" + ], + "timeout_seconds": 120, + "checks": "positive identity for both intervals and rejection of all three mutated projector controls" + } + ] +} diff --git a/research/bit-family-projector-algebra-seed10/test_package.py b/research/bit-family-projector-algebra-seed10/test_package.py new file mode 100644 index 0000000000..77b6ad295f --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/test_package.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +"""Focused positive and negative-control checks for this audit package.""" +import importlib.util +from pathlib import Path + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("family_algebra_verify", HERE / "verify.py") +module = importlib.util.module_from_spec(spec) +spec.loader.exec_module(module) + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +result = module.verify() +need(result["status"] == "PASS_BIT_FAMILY_PROJECTOR_ALGEBRA", "positive identity") +need(len(result["intervals"]) == 2, "both frozen intervals") +need(result["negative_controls"] == { + "omitted_helper": "rejected", + "same_rank_wrong_axis": "rejected", + "duplicate_helper": "rejected", +}, "all three algebraic controls") +print("PASS_BIT_FAMILY_PROJECTOR_ALGEBRA_CONTROLS positive=2 intervals negative=3") diff --git a/research/bit-family-projector-algebra-seed10/verify.py b/research/bit-family-projector-algebra-seed10/verify.py new file mode 100644 index 0000000000..09d10c1d83 --- /dev/null +++ b/research/bit-family-projector-algebra-seed10/verify.py @@ -0,0 +1,286 @@ +#!/usr/bin/env python3 +"""Independent rational projector-algebra audit of PR1351's frozen family.""" +import gzip +import hashlib +import json +from fractions import Fraction as Q +from pathlib import Path +import sys + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +TARGET = PACKAGE / "PR1351-RESULT.json" +REPORT = PACKAGE / "RESULT.json" +DIM = 64 +BASE = "bce54fb3f895cbe5cd4c0eb477c3afeed100190f" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def read_root(relative): + return (ROOT / relative).read_bytes() + + +def sha256(raw): + return hashlib.sha256(raw).hexdigest() + + +def git_blob(raw): + header = b"blob " + str(len(raw)).encode() + b"\0" + return hashlib.sha1(header + raw).hexdigest() + + +def zero_matrix(): + return [[Q(0) for _ in range(DIM)] for _ in range(DIM)] + + +def identity_matrix(): + result = zero_matrix() + for i in range(DIM): + result[i][i] = Q(1) + return result + + +def transpose(a): + return [list(row) for row in zip(*a)] + + +def multiply(a, b): + n = len(a) + result = [[Q(0) for _ in range(n)] for _ in range(n)] + for i in range(n): + for k, left in enumerate(a[i]): + if left: + for j, right in enumerate(b[k]): + if right: + result[i][j] += left * right + return result + + +def add(*matrices): + n = len(matrices[0]) + return [[sum((m[i][j] for m in matrices), Q(0)) + for j in range(n)] for i in range(n)] + + +def trace(a): + return sum((a[i][i] for i in range(len(a))), Q(0)) + + +def is_symmetric(a): + return a == transpose(a) + + +def is_projector(a): + return is_symmetric(a) and multiply(a, a) == a + + +def q_perp(q): + need(len(q) == 8 and sum(x * x for x in q) == 4, + "selected port line has norm squared four") + k = [[Q(int(i == j)) - Q(q[i] * q[j], 4) + for j in range(8)] for i in range(8)] + need(k == transpose(k), "q-perp symmetry") + need([[sum(k[i][m] * k[m][j] for m in range(8)) + for j in range(8)] for i in range(8)] == k, + "q-perp idempotence") + need(all(sum(k[i][j] * q[j] for j in range(8)) == 0 + for i in range(8)), "q-perp annihilates selected line") + need(sum(k[i][i] for i in range(8)) == 7, "q-perp rank seven") + return k + + +def ambient_projector(axes, q): + axes = tuple(axes) + need(len(set(axes)) == len(axes), "unique axes") + need(all(isinstance(a, int) and 0 <= a < DIM for a in axes), + "axis in ambient space") + local = {a for a in axes if a < 8} + need(local in (set(), set(range(1, 8))), + "local axes contain the whole q-perp block") + p = zero_matrix() + if local: + k = q_perp(q) + for i in range(8): + for j in range(8): + p[i][j] = k[i][j] + for axis in axes: + if axis >= 8: + p[axis][axis] = Q(1) + need(is_projector(p), "ambient projector symmetry and idempotence") + need(trace(p).denominator == 1, "projector trace integral") + return p + + +def orthogonal_decomposition(factors, source): + if not is_projector(source): + return False + if not all(is_projector(p) for p in factors): + return False + for i, p in enumerate(factors): + for q in factors[i + 1:]: + if multiply(p, q) != zero_matrix(): + return False + if multiply(q, p) != zero_matrix(): + return False + total = add(*factors) + return total == source and is_projector(total) + + +def source_data(target, sources): + need(sources["base_commit"] == BASE, "exact base commit") + for row in sources["files"]: + if row["usage"] == "provenance": + continue + raw = read_root(row["path"]) + need(sha256(raw) == row["sha256"], "source SHA-256: " + row["path"]) + need(git_blob(raw) == row["git_blob"], "source Git blob: " + row["path"]) + + remote = sources["predecessor_record"] + target_raw = TARGET.read_bytes() + need(remote["pr"] == 1351 and remote["commit"] == + "6060e62e9d42a16eff493aba74c8a617a12d8041", "pinned PR1351 head") + need(sha256(target_raw) == remote["sha256"], "PR1351 result SHA-256") + need(git_blob(target_raw) == remote["git_blob"], "PR1351 result Git blob") + + input_pins = {row["path"]: row for row in sources["files"] + if row["usage"] == "input"} + all_pins = {row["path"]: row for row in sources["files"]} + for path, expected in target["source_hashes"].items(): + need(path in all_pins and all_pins[path]["sha256"] == expected, + "predecessor source pin: " + path) + + selected = json.loads(read_root("certificates/selected-result.json")) + assembly = json.loads(read_root( + "research/community-frontier1094-audit/ASSEMBLY.json")) + need(selected["kappa"] == "836330098538459/500000000000000000", + "selected kappa") + need(589 in selected["source_prs"], "PR589 is a selected source") + need(assembly["bit_supplier"]["commit"] == + "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46", + "selected PR589 source commit") + selected_manifest = json.loads(read_root( + "research/community-frontier1094-audit/SELECTED-SOURCE.json")) + need(selected_manifest["files"][ + "research/e8-bit-p111-tuned/tune/EXPECTED.json"] == + input_pins["research/e8-bit-p111-tuned/tune/EXPECTED.json"]["sha256"], + "selected PR589 receipt binding") + word_raw = read_root( + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz") + word = json.loads(gzip.decompress(word_raw)) + return selected, tuple(word["lines"][0]) + + +def verify(): + target = json.loads(TARGET.read_text()) + sources = json.loads((PACKAGE / "SOURCES.json").read_text()) + selected, q = source_data(target, sources) + k = q_perp(q) + need(target["base_commit"] == BASE, "predecessor exact base") + need(target["status"] == "PASS_PR589_PHYSICAL_FAMILY", + "predecessor positive status") + + family = target["family"] + need((family["pair"], family["copy"], family["side"], family["port"]) == + (1, 0, 0, 0), "selected physical family key") + expected_roles = [[0, 0, 0, 8, 1, 0], + [7, 0, 0, 8, 5, 429], + [7, 0, 8, 8, 5, 430], + [7, 0, 16, 8, 5, 431]] + need(family["roles"] == expected_roles, "pinned family roles") + need(q == (2, 0, 0, 0, 0, 0, 0, 0), "family port-zero line") + + expected = { + 0: {"host_axes": [[1, 2, 3, 4, 5, 6, 7, 8]], + "remainder_axes": list(range(9, 15)), + "source_axes": list(range(1, 15)), "host_event_positions": [1], + "deadline_event_position": 2}, + 7: {"host_axes": [list(range(36, 44)), list(range(44, 52)), + list(range(52, 60))], + "remainder_axes": list(range(60, 64)), + "source_axes": list(range(36, 64)), + "host_event_positions": [13, 13, 13], + "deadline_event_position": 22}} + intervals = target["interval_results"] + need(set(intervals) == {"0", "7"}, "exact interval set") + summarized = [] + for child in (0, 7): + data = intervals[str(child)] + shape = expected[child] + for field, value in shape.items(): + need(data[field] == value, f"child {child} {field}") + hosts = [ambient_projector(axes, q) for axes in shape["host_axes"]] + remainder = ambient_projector(shape["remainder_axes"], q) + source = ambient_projector(shape["source_axes"], q) + factors = hosts + [remainder] + need(orthogonal_decomposition(factors, source), + f"child {child} exact orthogonal decomposition") + ranks = [int(trace(p)) for p in factors] + need(ranks == ([8, 6] if child == 0 else [8, 8, 8, 4]), + f"child {child} exact factor ranks") + need(int(trace(source)) == (14 if child == 0 else 28), + f"child {child} source rank") + summarized.append({"child": child, "factor_ranks": ranks, + "source_rank": int(trace(source)), + "host_event_positions": shape["host_event_positions"], + "deadline_event_position": shape["deadline_event_position"]}) + + # Negative controls are mutations of the exact projector decomposition. + child7 = intervals["7"] + factors7 = [ambient_projector(a, q) for a in expected[7]["host_axes"]] + rem7 = ambient_projector(expected[7]["remainder_axes"], q) + source7 = ambient_projector(expected[7]["source_axes"], q) + omitted = orthogonal_decomposition(factors7[:-1] + [rem7], source7) + need(not omitted, "omitted-helper negative control") + + child0 = intervals["0"] + good_host0 = expected[0]["host_axes"][0] + bad_host0 = [a for a in good_host0 if a != 8] + [22] + p_good = ambient_projector(good_host0, q) + p_bad = ambient_projector(bad_host0, q) + need(trace(p_good) == trace(p_bad), "wrong-axis control preserves rank") + source0 = ambient_projector(expected[0]["source_axes"], q) + rem0 = ambient_projector(expected[0]["remainder_axes"], q) + wrong_axis = orthogonal_decomposition([p_bad, rem0], source0) + need(not wrong_axis, "wrong-axis negative control") + + duplicate = orthogonal_decomposition(factors7 + [factors7[0], rem7], source7) + need(not duplicate, "duplicate-helper negative control") + + return { + "status": "PASS_BIT_FAMILY_PROJECTOR_ALGEBRA", + "base_commit": BASE, + "pr1351_head": sources["predecessor_record"]["commit"], + "pr1351_result_git_blob": sources["predecessor_record"]["git_blob"], + "selected_kappa": selected["kappa"], + "family": {"pair": 1, "copy": 0, "side": 0, "port": 0}, + "q_perp_rank": int(trace(k)), + "intervals": summarized, + "block_identity": "pairwise orthogonal P_i imply product D(P_i)=D(sum P_i)", + "negative_controls": {"omitted_helper": "rejected", + "same_rank_wrong_axis": "rejected", + "duplicate_helper": "rejected"}, + "no_new_kappa": True, + "scope": "Exact operator identities conditional on the pinned PR1351 role map; no independent family selection, chronology replay, helper lowering, or supplier admission." + } + + +def main(): + write = len(sys.argv) == 2 and sys.argv[1] == "--write" + need(len(sys.argv) == 1 or write, "usage: verify.py [--write]") + result = verify() + if write: + need(not REPORT.exists(), "refusing to overwrite RESULT.json") + REPORT.write_text(json.dumps(result, indent=2) + "\n") + print("WROTE_RESULT " + str(REPORT.relative_to(ROOT))) + return + expected = json.loads(REPORT.read_text()) + need(result == expected, "stored RESULT.json differs from exact replay") + print("PASS_BIT_FAMILY_PROJECTOR_ALGEBRA children=0,7 factors=2+4 q_rank=7 controls=3 no_new_kappa") + + +if __name__ == "__main__": + main() diff --git a/research/seed10-bit-supplier/ASSIGNMENT.json b/research/seed10-bit-supplier/ASSIGNMENT.json new file mode 100644 index 0000000000..976a6956aa --- /dev/null +++ b/research/seed10-bit-supplier/ASSIGNMENT.json @@ -0,0 +1,65 @@ +{ + "assignment_seed_os_random": 10, + "draw_source": "/dev/urandom", + "started_at_utc": "2026-10-13T23:19:21Z", + "track": "Bit supplier", + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "selected_record": { + "kappa": "836330098538459/500000000000000000", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "review": "docs/research/community-batch1099-review.md", + "bit_source_pr": 589, + "bit_source_commit": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46" + }, + "candidates": [ + { + "object": "PR589 exact single/pair gate-order transport atlas", + "live_record": "PR #1345 at b54a856aa79857d91cd5d65f8f7144e26c8c084f", + "decision": "occupied; no fixed-word transport search repeated" + }, + { + "object": "PR589 revision-3 bit lever relaxation at a=1/99", + "live_record": "PR #1334 at 5ad74a4a04d1c9264768c43762e130690918b043", + "decision": "occupied; no same parameter relaxation repeated" + }, + { + "object": "PR589 physical host family pair=1,copy=0", + "live_record": "PR #1351 at 6060e62e9d42a16eff493aba74c8a617a12d8041", + "decision": "direct construction claim occupied; choose only a second audit using a different proof method, as explicitly permitted" + } + ], + "scope_claimed": "Independent exact algebraic audit of PR #1351 pair=1, copy=0 address-operator identity. Prove each interval as an orthogonal projector decomposition and derive D(P1)...D(Pk)=D(sum Pi); do not repeat the 128-column matrix replay. Conditional on the pinned PR #1351 role map and source pins.", + "diversifier": "Seed 10 selects the algebraic proof obligation for the concrete PR589 family, rather than another fixed-word search or the original coordinate replay.", + "coordination": "No pinned sprint coordination issue identified by a fresh open-issue search; local claim recorded in the package.", + "expected_deliverable": "Source-pinned independent-verification package with exact projector certificate, two interval decompositions, three negative controls, and one reproduction command.", + "expected_finish_utc": "2026-10-14T00:00:00Z", + "status": "completed and handed off", + "final_overlap_refresh": { + "searched_at_utc": "2026-10-13T23:34:41Z", + "open_prs": 840, + "discussions": 89, + "pagination_complete": true, + "warnings": [], + "query": "PR589 pair=1 copy=0 physical family orthogonal projector D(P) independent algebraic audit", + "query_matches": 0, + "direct_checks": { + "pr1351": { + "state": "OPEN", + "head": "6060e62e9d42a16eff493aba74c8a617a12d8041", + "scope": "same family matrix replay; our audit uses exact orthogonal-projector block proof" + }, + "pr1353": { + "state": "OPEN", + "head": "efc6bfc3302a966ac0e1f5f4656e94b4cabeb9ca", + "scope": "seed22 complex mixed-gauge result; unrelated" + } + } + }, + "contribution": { + "classification": "independent verification; no new kappa", + "summary": "Proved PR1351 family pair=1/copy=0 address-map identity for children 0 and 7 from exact orthogonal-projector decompositions and the D(P) block identity; three malformed decompositions rejected. Conditional on PR1351 pinned role map.", + "result": "PASS_BIT_FAMILY_PROJECTOR_ALGEBRA children=0,7 factors=2+4 q_rank=7 controls=3 no_new_kappa", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/1371", + "commit": "aee76f5d" + } +}