From 47c397f15c6dc61c19320220ab9097bcbb3f0f04 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Tue, 13 Oct 2026 19:17:40 -0500 Subject: [PATCH 1/2] Add exact diagonal obstruction for fixed P112 frame cover --- .../p112-fixed-frame-diagonal-seed52/CLAIM.md | 27 + .../p112-fixed-frame-diagonal-seed52/LICENSE | 201 +++++ .../NOTICE.md | 21 + .../p112-fixed-frame-diagonal-seed52/PROOF.md | 31 + .../README.md | 46 ++ .../RESULT.json | 751 ++++++++++++++++++ .../SOURCES.json | 87 ++ .../TASK.json | 67 ++ .../VERIFY.json | 23 + .../inputs/PR1347-COVERING.json | 77 ++ .../inputs/PR1347-engine.py | 229 ++++++ .../verify.py | 274 +++++++ 12 files changed, 1834 insertions(+) create mode 100644 research/p112-fixed-frame-diagonal-seed52/CLAIM.md create mode 100644 research/p112-fixed-frame-diagonal-seed52/LICENSE create mode 100644 research/p112-fixed-frame-diagonal-seed52/NOTICE.md create mode 100644 research/p112-fixed-frame-diagonal-seed52/PROOF.md create mode 100644 research/p112-fixed-frame-diagonal-seed52/README.md create mode 100644 research/p112-fixed-frame-diagonal-seed52/RESULT.json create mode 100644 research/p112-fixed-frame-diagonal-seed52/SOURCES.json create mode 100644 research/p112-fixed-frame-diagonal-seed52/TASK.json create mode 100644 research/p112-fixed-frame-diagonal-seed52/VERIFY.json create mode 100644 research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-COVERING.json create mode 100644 research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-engine.py create mode 100644 research/p112-fixed-frame-diagonal-seed52/verify.py diff --git a/research/p112-fixed-frame-diagonal-seed52/CLAIM.md b/research/p112-fixed-frame-diagonal-seed52/CLAIM.md new file mode 100644 index 0000000000..9074d5b6a7 --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/CLAIM.md @@ -0,0 +1,27 @@ +# Seed 52 claim: alternate supports for a fixed P112 frame cover + +- **Track / assignment seed:** Structural decoder, OS-random seed 52. +- **Base:** `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. +- **Predecessor:** PR #1347 (`64fd5f9e91961dedc16118fcc7ad71ee82efe28f`), especially its exact frame-only `COVERING.json` and bounded `DIAGONAL-SEARCH.json`. +- **Coordination claim:** [discussion #1163, comment 18911792](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18911792). +- **Recent overlap check:** refreshed open PRs and the pinned coordination discussion at 2026-10-14 00:05 UTC. PR #1347's refinement kept one first-enumerated representative per frame pattern; no current claim covers all representatives for its fixed ten patterns. Nearby claims #1316 (one odd free rectangle with a coordinate term), #1360 (rank-nine factorizations), and #1342 (one asymmetric-unit replay) concern other domains. + +## Candidate selection + +Three bounded candidates were compared. Seed `52 mod 3 = 1` selects candidate 2. + +1. Jointly select ten maximum-hit frame patterns from the complete 5,376-pattern dictionary while imposing diagonal coverage. Deferred: this broadens PR #1347's explicitly open full-dictionary next question. +2. Keep the ten frame-hit masks in PR #1347's fixed `COVERING.json`; enumerate every maximum-hit rank-six support representative in each mask class, then decide whether one representative per class can cover all 112 live diagonals. **Selected.** This varies the omitted support representatives while holding the frame cover exactly fixed. +3. Extend the P112 two-coordinate free-rectangle audit to the first open 24-row support size. Deferred because it is adjacent to PR #1375 and active claim #1316. + +## Hypothesis and exact scope + +For the ten distinct frame-hit masks induced by the ten terms in PR #1347's `COVERING.json`, replacing each term by any other rank-six support triple with the same frame-hit mask preserves all 1,260 frame counts exactly. The question is whether one such triple per mask can make the union of the ten diagonal support masks equal the full 112-live-line set. + +Enumerate the complete finite domain: 7,616 rank-seven tagged parent pairs, each with its 127 nonzero cut words (967,232 parent/cut cases). Retain precisely the cases with 1,120 frame hits and one of the fixed ten frame masks. Within each mask class, support triples whose diagonal mask is a subset of another triple's mask are safely dominated for this coverage question; keep the inclusion-maximal masks and exhaustively solve the one-per-class coverage problem with exact bit masks. + +This is a support-only necessary-condition audit. A feasible tuple would not solve coefficient equations or produce a decoder. An infeasible result applies only to these ten fixed frame masks and says nothing about other ten-pattern covers, lower-hit terms, helper costs, or kappa. + +- **Expected artifact:** source-pinned exact enumerator and verifier, complete candidate and Pareto counts, exact feasible tuple or exhaustive negative certificate, mutation controls, scope/assumption statement, and a concise handoff. +- **Reproducible entry point (planned):** `python3 -I -O -B research/p112-fixed-frame-diagonal-seed52/verify.py`. +- **Expected finish:** 2026-10-14 01:15 UTC; claim expires 02:05 UTC. diff --git a/research/p112-fixed-frame-diagonal-seed52/LICENSE b/research/p112-fixed-frame-diagonal-seed52/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/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/p112-fixed-frame-diagonal-seed52/NOTICE.md b/research/p112-fixed-frame-diagonal-seed52/NOTICE.md new file mode 100644 index 0000000000..767d5458bc --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/NOTICE.md @@ -0,0 +1,21 @@ +# Notice and attribution + +Prepared by **Navinor** with help from opencode (research, proof development, +implementation, verification and documentation). Apache-2.0; new contributions are under +the repository's license. + +Model and question: CrocSwap/integer-mult-bounds#717 (DreamingOfClouds), `research/format-limits-2/` at head +`4a97676294f9fa413b65986e9984fddeda71e4cc` (B14 decoder model, D1(a) masked reduction, +D1 mixed-beta open problem, D1(e) sampled covering bound; read for definitions only, not +vendored or executed). Prior decoder floors: CrocSwap/integer-mult-bounds#620 (Joel Pulikkan / GamingPuzzled), +CrocSwap/integer-mult-bounds#968 and CrocSwap/integer-mult-bounds#1077 (woklerx and the seed44/seed48 packages; both defer masked E-graph +identities), CrocSwap/integer-mult-bounds#845 (Mihir Srivastava; fixed-reader ninth total). The E8 line enumeration +is adapted from `research/complex-frame-pair-decoders/verify.py` (Apache-2.0, same +repository) with attribution; no predecessor file is modified or imported at runtime. + +The selected construction chain (see `certificates/selected-result.json`) is read only: +Jonathan Capalbo, Chafik Boukhalfa, Jeremy Kothe, Hao Yan, DreamingOfClouds, eumemic and +the other credited authors of the T37/CrocSwap/integer-mult-bounds#589 chain. No selected-frontier change is proposed. + +Third-party code: none. Standard library only. Retained source attribution and licenses of +all predecessor packages apply to their own files. diff --git a/research/p112-fixed-frame-diagonal-seed52/PROOF.md b/research/p112-fixed-frame-diagonal-seed52/PROOF.md new file mode 100644 index 0000000000..fc133886b3 --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/PROOF.md @@ -0,0 +1,31 @@ +# Exact fixed-pattern support obstruction + +## Statement + +Fix the ten distinct frame-hit masks induced by the ten terms of the pinned PR #1347 `COVERING.json`. Consider every rank-six support triple `(left tag, right tag, cut)` whose rank-seven parent is in the complete P112 tagged-support model, whose cut is a nonzero column-code word, whose resulting row has rank six, and whose simultaneous frame-hit mask equals one of the fixed ten masks (each mask has 1,120 hits). + +The union of the diagonal supports of all such triples omits ten live lines. Consequently, for any selection of one such triple per fixed mask, the sum of the ten rank-one terms has zero diagonal support on those lines. It cannot realize the required nonzero P112 diagonal there. This excludes only the fixed ten-mask support class. + +## Complete domain + +The pinned predecessor engine builds 120 E8 root lines, removes the eight punctured coordinate-frame lines, and enumerates the 1,260 live eight-frames. It constructs the 240 tagged supports used for the star and one-line-trimmed-star model. For every ordered support-tag pair `(a,b)`, the verifier retains exactly the pairs with parent rank 7. There are 7,616 such pairs. For each pair it forms the full nonzero binary code generated by the columns `n[j] & left` for the set bits `j` of the right support. Every such code has 127 nonzero words, for 967,232 parent/cut cases total. + +For a word `cut`, the retained row support is `left XOR cut`. Its frame-hit mask is the intersection of the sets of live frames meeting the row and right supports. A candidate enters the census iff this mask is exactly one of the ten pinned masks and has 1,120 bits. Its diagonal support is + +```text +(left XOR cut) AND right AND live-line-mask. +``` + +These operations use exact integer arithmetic. The verifier checks rank six for every retained row. It records every matching tagged triple (including distinct triples with the same diagonal mask), then computes the union of the 40 resulting masks. The union contains 102 live line IDs and misses `18, 47, 53, 62, 88, 92, 96, 100, 112, 117`; their exact root representatives are included in `RESULT.json`. + +## Why the union proves the scoped negative + +Every allowed one-per-mask choice is a subset of the complete 40-triple census. Its diagonal union is therefore a subset of the census union. Since the census union omits ten required live diagonal positions, no such choice can cover all 112 positions. This is a direct finite obstruction; no optimizer or heuristic search is involved. + +The original ten terms are replayed as a positive control: the frame minimum, frame histogram, frame-count digest, diagonal minimum, and diagonal multiplicity histogram match the pinned PR #1347 receipts, and all ten original terms occur in the expanded census. Negative controls check that the zero word is rejected by parent-code membership, a representative cannot be assigned to another frame-mask class, and the ten omitted lines are absent from every candidate mask. + +## Dependencies and limits + +The standalone exact replay depends on the engine and `COVERING.json` copied from PR #1347 at `64fd5f9e91961dedc16118fcc7ad71ee82efe28f`; local hashes and Git blob IDs are in `SOURCES.json`. The geometric model and rank-six search descend from PR #1226 and PR #1323, which PR #1347 pins and credits. The base selected-result commit is `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. + +No coefficient feasibility is established. The result does not cover another selection of frame masks, nonmaximum-hit triples, a broader support language, or a full physical decoder. It changes neither the selected certificate nor its κ. diff --git a/research/p112-fixed-frame-diagonal-seed52/README.md b/research/p112-fixed-frame-diagonal-seed52/README.md new file mode 100644 index 0000000000..d9e631254d --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/README.md @@ -0,0 +1,46 @@ +# P112 diagonal support audit for the fixed PR #1347 cover + +This package exhausts all maximum-hit rank-six support triples in the ten distinct 1,120-hit frame-mask classes used by PR #1347's `COVERING.json`. + +## Result + +The complete 967,232 parent/cut domain contains 40 triples in those ten fixed classes: four triples per class, with two distinct diagonal-support masks per class. The union of all 40 masks covers 102 of the 112 live root lines. It misses line IDs `18, 47, 53, 62, 88, 92, 96, 100, 112, 117`. + +Therefore no choice of one maximum-hit support representative from each of these ten frame classes can cover every live diagonal. The exact root representatives, frame masks, all 40 support triples, diagonal masks, and replay receipts are in `RESULT.json`. + +This is a negative result for this one fixed ten-mask cover. It does not rule out a different cover, a different cost/domain, or an arbitrary P112 decoder. It is only a support necessary-condition audit; it does not solve the coefficient equations or claim a physical circuit or a new κ. + +## Reproduce + +From the repository root, run: + +```sh +python3 -I -O -B research/p112-fixed-frame-diagonal-seed52/verify.py +``` + +Expected output: + +```text +PASS_EXACT_FIXED_FRAME_PATTERN_DIAGONAL_OBSTRUCTION patterns=10 support_triples=40 diagonal_union=102/112 uncovered=10 +``` + +The verifier uses only the Python standard library. It rebuilds the E8/P112 frame geometry, checks the predecessor's exact positive control, enumerates all rank-seven parent pairs and their nonzero code words, and compares the full candidate census and its digest to `RESULT.json`. It uses exact integer bit masks; no MILP or floating-point solver is involved. To regenerate the result after an intentional input or algorithm change, run the same command with `--write-result` and review the full JSON diff. + +The repository's opt-in package checks are: + +```sh +python3 scripts/research_package.py --package research/p112-fixed-frame-diagonal-seed52 --check-only +python3.12 scripts/research_package.py --package research/p112-fixed-frame-diagonal-seed52 +``` + +## Provenance and credit + +Base commit: `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. Assignment seed 52 selected this fixed-mask audit from three scoped candidates; see `CLAIM.md` and the claim on [coordination discussion #1163](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18911792). + +This work extends PR #1347's bounded diagonal search in a different way: that search kept only the first enumerated representative for each frame mask and timed out at 120 seconds. Here all support representatives in the ten masks of its committed `COVERING.json` are enumerated exactly, and the conclusion follows from their complete diagonal-support union. The finite rank-six geometry and witness derive from Navinor's PR #1226 and the ordered P112 model/certificate in PR #1323. The inherited nine-root frame obstruction is credited in PR #1347 to David Arias's PR #1236 and Hanson's independent PR #1242; this package does not need or extend that lemma. Exact source and license pins are in `SOURCES.json`; the original Apache-2.0 license and predecessor notice are retained. + +New code and analysis by Cinna Davis with substantial OpenAI Codex assistance in scope selection, proof analysis, code, verification, and writing. No selected certificate or frontier is modified. + +## Open next questions + +- **Could a different set of ten maximum-hit frame masks pass this support test?** That would preserve a possible support-level route beyond the fixed PR #1347 witness, while still leaving coefficient and physical-cost gates. First step: enumerate all 5,376 maximum-hit masks with their full representative sets, then solve an exact dominance-compressed frame-plus-diagonal cover. The broader cross-pattern dictionary is outside this fixed-cover certificate. diff --git a/research/p112-fixed-frame-diagonal-seed52/RESULT.json b/research/p112-fixed-frame-diagonal-seed52/RESULT.json new file mode 100644 index 0000000000..ba1c4b0367 --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/RESULT.json @@ -0,0 +1,751 @@ +{ + "schema_version": 1, + "status": "PASS_EXACT_FIXED_FRAME_PATTERN_DIAGONAL_OBSTRUCTION", + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "predecessor": { + "pr": 1347, + "commit": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "cover_sha256": "27d567a56500f857962ddc69a9baed691a945e5a2979a26632e84c23133f1c95", + "engine_sha256": "b59101564855a89de04f39fd28b0a853aa3c46ce0ce99951d93d7dd018543536" + }, + "domain": { + "live_diagonal_positions": 112, + "live_line_ids": [ + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119 + ], + "rank_seven_tagged_parent_pairs": 7616, + "nonzero_code_words_per_parent": 127, + "complete_parent_cut_cases": 967232, + "fixed_frame_mask_classes": 10, + "required_frame_hits_per_class": 1120, + "matching_support_triples": 40, + "unique_diagonal_masks": 20 + }, + "groups": [ + { + "group": 0, + "frame_hit_mask_hex": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffebffebeeffffdbbdfffffffffffffffffffffffffffafffafbbffff6ef7ffffffffffffffffffffffffffebffebeeffffddbbfffffffbbffbbffbbffb9dfffffffffffffffffffffffffffffffffffffffffffffffdbffdbffddeeffeeffffc00000000000000000003fffffffffffffffffffc00", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "71e7000000000000006a60", + "8e000000e7000000000a90004020" + ], + "diagonal_union_hex": "8e000071e7000000000a90006a60", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 0, + "left_tag": 7, + "right_tag": 0, + "cut_hex": "187100008e18000000000560009590", + "diagonal_mask_hex": "71e7000000000000006a60" + }, + { + "group": 0, + "left_tag": 7, + "right_tag": 1, + "cut_hex": "187100008e18000000000560009590", + "diagonal_mask_hex": "71e7000000000000006a60" + }, + { + "group": 0, + "left_tag": 7, + "right_tag": 54, + "cut_hex": "187100008e18000000000560009590", + "diagonal_mask_hex": "8e000000e7000000000a90004020" + }, + { + "group": 0, + "left_tag": 7, + "right_tag": 55, + "cut_hex": "187100008e18000000000560009590", + "diagonal_mask_hex": "8e000000e7000000000a90004020" + } + ] + }, + { + "group": 1, + "frame_hit_mask_hex": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffebffebffffeedbffff00ffffffffffffffffff00ff3afffafffffbb6ffffc03fffffffffffffffffc03fcebffebffffeeddffff00ffffffffffffffffff00ff3fffffffffffffffffc03bbffbbffbbffbbfffc03fcdbffdbffddffffeeff00ffffffffffffffffff00ff3fffffffffffffffffffef7fef7feeffffddfbbffff", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "e78e00000001590008", + "8e00000000e70000000a90010008" + ], + "diagonal_union_hex": "8e00000000e78e00000a91590008", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 1, + "left_tag": 29, + "right_tag": 0, + "cut_hex": "187100000000187100000562a60004", + "diagonal_mask_hex": "e78e00000001590008" + }, + { + "group": 1, + "left_tag": 29, + "right_tag": 1, + "cut_hex": "187100000000187100000562a60004", + "diagonal_mask_hex": "e78e00000001590008" + }, + { + "group": 1, + "left_tag": 29, + "right_tag": 54, + "cut_hex": "187100000000187100000562a60004", + "diagonal_mask_hex": "8e00000000e70000000a90010008" + }, + { + "group": 1, + "left_tag": 29, + "right_tag": 55, + "cut_hex": "187100000000187100000562a60004", + "diagonal_mask_hex": "8e00000000e70000000a90010008" + } + ] + }, + { + "group": 2, + "frame_hit_mask_hex": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7ffff777dffffe77efffffffffffffffffffffffffffffffffffffffffffffff5fff5f77ffff9dfbffff00000000000000000000ffffffffffffffffffff003fffffffffffffffffffffdf777ffff5fff5efbffffffe7e7ffffebd7ffd7ffffffffffffffffffffffffffffffffffffffffffffffdf9fbfffdf6fbffff5fff", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "c04080c080c000818004080200080", + "4c04c84c0000000000000000201898" + ], + "diagonal_union_hex": "4c04c84c080c000818004080201898", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 2, + "left_tag": 19, + "right_tag": 2, + "cut_hex": "80c8048004804c0424008040102464", + "diagonal_mask_hex": "4c04c84c0000000000000000201898" + }, + { + "group": 2, + "left_tag": 19, + "right_tag": 3, + "cut_hex": "80c8048004804c0424008040102464", + "diagonal_mask_hex": "4c04c84c0000000000000000201898" + }, + { + "group": 2, + "left_tag": 19, + "right_tag": 90, + "cut_hex": "80c8048004804c0424008040102464", + "diagonal_mask_hex": "c04080c080c000818004080200080" + }, + { + "group": 2, + "left_tag": 19, + "right_tag": 91, + "cut_hex": "80c8048004804c0424008040102464", + "diagonal_mask_hex": "c04080c080c000818004080200080" + } + ] + }, + { + "group": 3, + "frame_hit_mask_hex": "fffffffffffffffffffffffffffffff3cf3fffcf3cffff3cf3fffcf3cfffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3cff3cfffffffffffffcff3cff3faffffffffffffffffffffffffffffffffffffffffffffffffffffffc03cff3cfffffffffffffcc03cff3f2fffffcf3ffff00f3fcf3fffff3fcfffff300f3fcecbfffff3cffffff3cff3cfffffcff3ffffcff3cff3ba", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "10042008041008200300c000300300", + "40018002014002800300c000300300" + ], + "diagonal_union_hex": "5005a00a05500aa00300c000300300", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 3, + "left_tag": 105, + "right_tag": 88, + "cut_hex": "aa00550a00a50050c000cc0000000", + "diagonal_mask_hex": "40018002014002800300c000300300" + }, + { + "group": 3, + "left_tag": 105, + "right_tag": 89, + "cut_hex": "aa00550a00a50050c000cc0000000", + "diagonal_mask_hex": "40018002014002800300c000300300" + }, + { + "group": 3, + "left_tag": 105, + "right_tag": 90, + "cut_hex": "aa00550a00a50050c000cc0000000", + "diagonal_mask_hex": "10042008041008200300c000300300" + }, + { + "group": 3, + "left_tag": 105, + "right_tag": 91, + "cut_hex": "aa00550a00a50050c000cc0000000", + "diagonal_mask_hex": "10042008041008200300c000300300" + } + ] + }, + { + "group": 4, + "frame_hit_mask_hex": "fffffff3cf3ffffaebfffaeb3ff8e3fffaebacffe38eb3ff8e3affffffffffffffffffffff00ffffeeffeeffeeff00ffff77fcfffffffffffffffffffffbbffbbffbbffbbfffddfffffffffffffffffffffffeeffeeffeeffeeffff77fffffffffffffffffffffffbbffbbffbbffbbfffddfffff00ffffffffffffffff00ffeeffeeffeeffff773fddffddffddffddffddfffffffffffffffffffffffff", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "8040288014280111010800400800", + "8068000016680000015800008004" + ], + "diagonal_union_hex": "8068288016680111015800408804", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 4, + "left_tag": 207, + "right_tag": 54, + "cut_hex": "6801168001018080044402a1012020", + "diagonal_mask_hex": "8068000016680000015800008004" + }, + { + "group": 4, + "left_tag": 207, + "right_tag": 55, + "cut_hex": "6801168001018080044402a1012020", + "diagonal_mask_hex": "8068000016680000015800008004" + }, + { + "group": 4, + "left_tag": 207, + "right_tag": 108, + "cut_hex": "6801168001018080044402a1012020", + "diagonal_mask_hex": "8040288014280111010800400800" + }, + { + "group": 4, + "left_tag": 207, + "right_tag": 109, + "cut_hex": "6801168001018080044402a1012020", + "diagonal_mask_hex": "8040288014280111010800400800" + } + ] + }, + { + "group": 5, + "frame_hit_mask_hex": "ffcff3fecb73fedb7ffedb3cfffffffffffffc73ffeb85ffffae93fcfeb2beffbeffffbbffbddbffffffffffffffffffffffffffffffffc03fffffffffffefbbbfffc03fef76fffcfffffffffffffffffffffffbeeeffffebffeb7dffffffeec03ffafffff5efbfffffffc03ffffffffffff3fffbdbdffebffffd7befffffffffffffffffffffffffffffffffffffffffffffff6f6ffdf7fffefbfefbff", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "42400041808101805001020100200", + "802400801802401805020102001000" + ], + "diagonal_union_hex": "84240084180a501805021122101200", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 5, + "left_tag": 215, + "right_tag": 90, + "cut_hex": "a42180a0084210020848840480840", + "diagonal_mask_hex": "42400041808101805001020100200" + }, + { + "group": 5, + "left_tag": 215, + "right_tag": 91, + "cut_hex": "a42180a0084210020848840480840", + "diagonal_mask_hex": "42400041808101805001020100200" + }, + { + "group": 5, + "left_tag": 215, + "right_tag": 110, + "cut_hex": "a42180a0084210020848840480840", + "diagonal_mask_hex": "802400801802401805020102001000" + }, + { + "group": 5, + "left_tag": 215, + "right_tag": 111, + "cut_hex": "a42180a0084210020848840480840", + "diagonal_mask_hex": "802400801802401805020102001000" + } + ] + }, + { + "group": 6, + "frame_hit_mask_hex": "ff5d75ffffffd7f79ed7f79ed7f79effffffffffffffffffffffebaebfffffffffffffffffffffffd77dd5ffffd5ff5ae7dbffdf7fdf7fffddffdfb9fff5fff5fffff77ff6fff6fffffffffffffffffffffffd5ffd77dff5dff5debddfff57ff75dd77fffebb5fbbffffffffffffffffffffff5affdb7e5dffffaed7eefffffffffffffffffffffff6fff6fff77ffffbbffbb9fffff9fafffff5fff5fff", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "100408201010080812009000180240", + "10048aa200000000000000011a2250" + ], + "diagonal_union_hex": "10048aa210100808120090011a2250", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 6, + "left_tag": 183, + "right_tag": 2, + "cut_hex": "88a04452008100404820890408804", + "diagonal_mask_hex": "10048aa200000000000000011a2250" + }, + { + "group": 6, + "left_tag": 183, + "right_tag": 3, + "cut_hex": "88a04452008100404820890408804", + "diagonal_mask_hex": "10048aa200000000000000011a2250" + }, + { + "group": 6, + "left_tag": 183, + "right_tag": 90, + "cut_hex": "88a04452008100404820890408804", + "diagonal_mask_hex": "100408201010080812009000180240" + }, + { + "group": 6, + "left_tag": 183, + "right_tag": 91, + "cut_hex": "88a04452008100404820890408804", + "diagonal_mask_hex": "100408201010080812009000180240" + } + ] + }, + { + "group": 7, + "frame_hit_mask_hex": "ff3cfffd3cedfd7fedfffffffedb3c1cfffae3ffffffffd7fedb7f4f3b4dffffffff00ffffffffffffbeeeffff00ffbddbfff3efbfefbfffeeffef76fffffffffffffffffffffffffffffffffffffffffffffeeffffbeffbeffbed7ffffc03fffeeefbfffdf7affffc03fffffffffffffffcffbdffffbdbeffff7debfffffffffffffffffffffffffffffffffffffffffffff6fffff6f5fffffafffafff", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "41800042408102410401020100200", + "401800402401802410480400800400" + ], + "diagonal_union_hex": "441800442409902410481420900600", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 7, + "left_tag": 213, + "right_tag": 90, + "cut_hex": "9422409004422000a018241082040", + "diagonal_mask_hex": "41800042408102410401020100200" + }, + { + "group": 7, + "left_tag": 213, + "right_tag": 91, + "cut_hex": "9422409004422000a018241082040", + "diagonal_mask_hex": "41800042408102410401020100200" + }, + { + "group": 7, + "left_tag": 213, + "right_tag": 110, + "cut_hex": "9422409004422000a018241082040", + "diagonal_mask_hex": "401800402401802410480400800400" + }, + { + "group": 7, + "left_tag": 213, + "right_tag": 111, + "cut_hex": "9422409004422000a018241082040", + "diagonal_mask_hex": "401800402401802410480400800400" + } + ] + }, + { + "group": 8, + "frame_hit_mask_hex": "ebfb6dffffffffaebaffffffffffffebfb6dffafedb7ffffffffedb7f5ffff7dddffffd7bdffbdffffffffffffffffffffffffffdf777ffff5ef7fef7fdf7fdf7fffddef7fef7ffffddffff7dff7dbeffbeffffddffddffddeeffeefffffff5fff5f77ff77ff77ff5ffffdddf7fdf7fdf7ffffbdffffbdbeffff7debffffbdffbdeeffffddbbffffef7fffef6fbfffdf7affffef7fef7bbffff76efffff", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "100808040804042008406060180000", + "920000044900002000026260014000" + ], + "diagonal_union_hex": "920808044904042008426260194000", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 8, + "left_tag": 229, + "right_tag": 52, + "cut_hex": "490404200420209221080802000668", + "diagonal_mask_hex": "920000044900002000026260014000" + }, + { + "group": 8, + "left_tag": 229, + "right_tag": 53, + "cut_hex": "490404200420209221080802000668", + "diagonal_mask_hex": "920000044900002000026260014000" + }, + { + "group": 8, + "left_tag": 229, + "right_tag": 90, + "cut_hex": "490404200420209221080802000668", + "diagonal_mask_hex": "100808040804042008406060180000" + }, + { + "group": 8, + "left_tag": 229, + "right_tag": 91, + "cut_hex": "490404200420209221080802000668", + "diagonal_mask_hex": "100808040804042008406060180000" + } + ] + }, + { + "group": 9, + "frame_hit_mask_hex": "3ffffffffc0fc0ffffc0ffffc0ffffffffffff03fffffc0fffffffff03fffffffffffffffffff00ffd7ffd7ddffffe700ffff3ffffffffffffffffffffff5fff5f77ffff9dfbffffffffffffffffffffffffffd7ffd7ddffffee77fffffff77ff77ff77ff76efffffffffffffffffffffffffffffffffffffffffffffffe7ffe7ffeeddffddffffffc03fdfbfddeefffff7403fffffffffffffffffcff", + "frame_hits": 1120, + "support_triples": 4, + "unique_diagonal_masks": 2, + "inclusion_maximal_diagonal_masks": 2, + "maximal_masks_hex": [ + "6186000008860000040290020020", + "104182088208040012040200800800" + ], + "diagonal_union_hex": "106186088208860012040290820820", + "diagonal_union_size": 24, + "candidates": [ + { + "group": 9, + "left_tag": 135, + "right_tag": 54, + "cut_hex": "81008100810618604816802006004", + "diagonal_mask_hex": "6186000008860000040290020020" + }, + { + "group": 9, + "left_tag": 135, + "right_tag": 55, + "cut_hex": "81008100810618604816802006004", + "diagonal_mask_hex": "6186000008860000040290020020" + }, + { + "group": 9, + "left_tag": 135, + "right_tag": 108, + "cut_hex": "81008100810618604816802006004", + "diagonal_mask_hex": "104182088208040012040200800800" + }, + { + "group": 9, + "left_tag": 135, + "right_tag": 109, + "cut_hex": "81008100810618604816802006004", + "diagonal_mask_hex": "104182088208040012040200800800" + } + ] + } + ], + "candidate_table_sha256": "9760f44754a90cc7a4d28c160938128c46c4754ea63f5533689a985bd50ea990", + "all_candidate_diagonal_union_hex": "deffeeeeffffffbf1f4ffff3fbfffc", + "all_candidate_diagonal_union_size": 102, + "uncovered_live_line_ids": [ + 18, + 47, + 53, + 62, + 88, + 92, + 96, + 100, + 112, + 117 + ], + "uncovered_live_lines": [ + { + "line_id": 18, + "root_representative": [ + 0, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ] + }, + { + "line_id": 47, + "root_representative": [ + 0, + 0, + 0, + 0, + 2, + 0, + -2, + 0 + ] + }, + { + "line_id": 53, + "root_representative": [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + -2 + ] + }, + { + "line_id": 62, + "root_representative": [ + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1 + ] + }, + { + "line_id": 88, + "root_representative": [ + 1, + -1, + 1, + 1, + 1, + 1, + 1, + -1 + ] + }, + { + "line_id": 92, + "root_representative": [ + 1, + -1, + 1, + 1, + -1, + 1, + 1, + 1 + ] + }, + { + "line_id": 96, + "root_representative": [ + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1 + ] + }, + { + "line_id": 100, + "root_representative": [ + 1, + -1, + 1, + -1, + -1, + 1, + 1, + -1 + ] + }, + { + "line_id": 112, + "root_representative": [ + 1, + -1, + -1, + -1, + 1, + 1, + 1, + -1 + ] + }, + { + "line_id": 117, + "root_representative": [ + 1, + -1, + -1, + -1, + -1, + 1, + -1, + -1 + ] + } + ], + "fixed_cover_positive_control": { + "minimum_frame_hits": 8, + "frame_hit_histogram": { + "8": 376, + "9": 648, + "10": 236 + }, + "frame_counts_sha256": "279d8390f77b13fd387f708b71988d62d021934b27a5868e7d776dc6b552327b", + "minimum_diagonal_multiplicity": 0, + "diagonal_multiplicity_histogram": { + "0": 21, + "1": 41, + "2": 37, + "3": 9, + "4": 2, + "5": 2 + }, + "candidate_terms_present": 10 + }, + "controls": { + "predecessor_cover_replays_frame_and_diagonal_receipts": true, + "all_predecessor_terms_appear_in_full_census": true, + "zero_cut_is_rejected_by_parent_code_membership": true, + "cross_pattern_substitution_is_rejected": true, + "missing_diagonal_is_absent_from_every_candidate": true + }, + "interpretation": "The union of every maximum-hit rank-six support representative in these ten fixed frame-mask classes omits the listed live lines. Therefore no selection of one representative per class can cover all live diagonals. This is a support-only negative for this fixed ten-mask cover, not for other frame covers." +} diff --git a/research/p112-fixed-frame-diagonal-seed52/SOURCES.json b/research/p112-fixed-frame-diagonal-seed52/SOURCES.json new file mode 100644 index 0000000000..a47da4f6f2 --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/SOURCES.json @@ -0,0 +1,87 @@ +{ + "schema_version": 1, + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb", + "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce" + } + ], + "external_sources": [ + { + "local_path": "inputs/PR1347-engine.py", + "usage": "exact P112 root-line, frame, support, rank, and code-word model used by the predecessor", + "source_pr": 1347, + "source_commit": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "source_path": "research/p112-rank6-frame-coverage/engine.py", + "git_blob": "6afabd3777975310683e4cdc8a4e4b95f0a330ac", + "sha256": "b59101564855a89de04f39fd28b0a853aa3c46ce0ce99951d93d7dd018543536" + }, + { + "local_path": "inputs/PR1347-COVERING.json", + "usage": "the ten fixed support terms and exact predecessor positive-control receipts", + "source_pr": 1347, + "source_commit": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "source_path": "research/p112-rank6-frame-coverage/COVERING.json", + "git_blob": "b762571ef996a80ed8a16d392fc56782091ac58f", + "sha256": "27d567a56500f857962ddc69a9baed691a945e5a2979a26632e84c23133f1c95" + }, + { + "local_path": "LICENSE", + "usage": "retained Apache-2.0 license from the source package", + "source_pr": 1347, + "source_commit": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "source_path": "research/p112-rank6-frame-coverage/LICENSE", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "local_path": "NOTICE.md", + "usage": "retained predecessor attribution notice", + "source_pr": 1347, + "source_commit": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "source_path": "research/p112-rank6-frame-coverage/inputs/PR1226-NOTICE.md", + "git_blob": "767d5458bc299cb2ac0fa04cb061eb174c25f95f", + "sha256": "e072c0269eae7bdfc438e0b9b980be79cf0b2b7618bc66656fac9c24ce32c256" + } + ], + "inherited_predecessors": [ + { + "pr": 1226, + "commit": "8b10989e4e45f0f9ce41004d7898a21a32f87e11", + "credit": "P112 model and root-star geometry, credited by PR #1347" + }, + { + "pr": 1236, + "commit": "ee8437bd9879272094e20c024cd34a53c4e84cd8", + "credit": "nine-root frame obstruction used by the predecessor, not extended here" + }, + { + "pr": 1242, + "commit": "7f31a561787864f26eb2242ef35179d07223accf", + "credit": "independent corroboration of the predecessor's nine-root obstruction" + }, + { + "pr": 1323, + "commit": "c1144855242a56ffc1090be2f075f977d123d947", + "credit": "ordered P112 model/certificate inherited by PR #1347" + }, + { + "pr": 1347, + "commit": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "credit": "fixed frame cover, complete rank-six census, and the earlier one-representative bounded diagonal search" + } + ], + "new_work": { + "author": "Cinna Davis (@1337isnot1337)", + "assistance": "Substantial OpenAI Codex assistance in task selection, proof analysis, code, verification, and writing." + } +} diff --git a/research/p112-fixed-frame-diagonal-seed52/TASK.json b/research/p112-fixed-frame-diagonal-seed52/TASK.json new file mode 100644 index 0000000000..7aff55baff --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/TASK.json @@ -0,0 +1,67 @@ +{ + "schema_version": 1, + "task_id": "complex-masked-decoder", + "priority_revision": 2, + "original_card": { + "id": "complex-masked-decoder", + "question": "Can one specified masked or overcomplete decoder improve the complete moment budget?", + "starting_points": [ + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "methods": [ + "Synthesize a decoder with exact coefficients and fully priced helper endpoints.", + "Bound the best possible budget for a fixed support alphabet before synthesis." + ], + "acceptance_gate": "Change an assumption of the eight-term all-pairs bound and count all copied information, frames and restoration.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-decoder-field-extension-seed44/verify.py" + ], + "expected": "PASS_COMPLEX_DECODER_FIELD_EXTENSION_S44", + "inspect": "Locate the excluded classes: masked identities, at least nine terms, and deeper punctures.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Choose one finite support alphabet and test exact decoding constraints before building a whole network.", + "bottleneck_link": "A cheaper fully realized decoder could increase deficit or lower recursive cost on the binding complex side.", + "allowed_variations": [ + "Select a specific masked or overcomplete family with exact labels and supports." + ], + "scope_change_triggers": [ + "Repeating the exact eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "masked decoder", + "overcomplete", + "eight-term" + ] + }, + "scope_status": "refined", + "actual_scope": "Exact support-level audit of every maximum-hit rank-six support representative in the ten frame-mask classes of PR #1347's fixed cover; decide whether any one-per-class choice can cover the 112 live diagonal positions.", + "scope_change_reason": "The task narrows full decoder synthesis and complete moment pricing to an exact necessary-condition audit of one fixed support relaxation. This isolates whether changing the omitted representative within the predecessor's ten frame patterns can repair its diagonal support gap before coefficient or physical-cost work.", + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "track": "structural decoder", + "assignment_seed": 52, + "seed_source": "python3 -B -c 'import secrets; print(secrets.randbelow(60))'", + "predecessor_pr": 1347, + "predecessor_commit": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "selected_candidate": 2, + "selection_rule": "52 mod 3 = 1 selects the fixed-mask all-representative audit from the three candidates in CLAIM.md", + "bottleneck_link": "Diagonal support coverage is a necessary feasibility gate for a P112 masked decoder. The fixed-class obstruction rejects one support relaxation before coefficient equations and the complete supplier bill are considered.", + "budget_minutes": 60, + "stop_rule": "Exhaust the 7,616 rank-seven tagged parent pairs and all 127 nonzero code words per pair; stop once the exact union of every representative in the ten fixed frame-mask classes is certified. Do not expand to other masks or coefficient search.", + "outcome": "negative-result", + "evidence": "RESULT.json and PROOF.md; the verifier checks all 967,232 parent/cut cases, the exact predecessor positive control, the full 40-triple census, and the 102/112 diagonal-support union.", + "author": "Cinna Davis (@1337isnot1337)", + "ai_assistance": "Substantial OpenAI Codex assistance in task selection, proof analysis, code, verification, and writing.", + "open_questions": [ + { + "question": "Can a different selection of ten maximum-hit frame-mask classes yield complete diagonal support in the same rank-six support model?", + "why_it_matters": "A positive support cover would keep this necessary-condition route alive beyond the fixed PR #1347 witness, though coefficient feasibility and physical pricing would still remain.", + "first_step": "Enumerate the complete 5,376-pattern dictionary with all support representatives and compute a dominance-compressed exact frame-plus-diagonal cover domain.", + "blocked_by": "The current certificate fixes the ten masks in COVERING.json and does not construct the full cross-pattern representative dictionary." + } + ] +} diff --git a/research/p112-fixed-frame-diagonal-seed52/VERIFY.json b/research/p112-fixed-frame-diagonal-seed52/VERIFY.json new file mode 100644 index 0000000000..3c58b10152 --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-engine.py", + "research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-COVERING.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Complete 967232-case rank-seven parent/cut census; exact fixed-pattern support union; predecessor frame and diagonal positive controls; candidate membership and missing-line negative controls; committed RESULT.json equality." + } + ] +} diff --git a/research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-COVERING.json b/research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-COVERING.json new file mode 100644 index 0000000000..b762571ef9 --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-COVERING.json @@ -0,0 +1,77 @@ +{ + "scope": "Frame-demand relaxation only; arbitrary coefficients are not supplied. All helpers, source access, frame changes, copies beyond per-term rank, restoration, hosting and recursive overhead are optimistically zero.", + "terms": [ + [ + 7, + 0, + "0x187100008e18000000000560009590" + ], + [ + 29, + 0, + "0x187100000000187100000562a60004" + ], + [ + 19, + 2, + "0x80c8048004804c0424008040102464" + ], + [ + 105, + 88, + "0xaa00550a00a50050c000cc0000000" + ], + [ + 207, + 54, + "0x6801168001018080044402a1012020" + ], + [ + 215, + 90, + "0xa42180a0084210020848840480840" + ], + [ + 183, + 2, + "0x88a04452008100404820890408804" + ], + [ + 213, + 90, + "0x9422409004422000a018241082040" + ], + [ + 229, + 52, + "0x490404200420209221080802000668" + ], + [ + 135, + 54, + "0x81008100810618604816802006004" + ] + ], + "exact_check": { + "terms": 10, + "copy_bill": 60, + "minimum_hits": 8, + "hit_histogram": { + "8": 376, + "9": 648, + "10": 236 + }, + "frame_counts_sha256": "279d8390f77b13fd387f708b71988d62d021934b27a5868e7d776dc6b552327b" + }, + "diagonal_support_coverage": { + "minimum": 0, + "histogram": { + "0": 21, + "1": 41, + "2": 37, + "3": 9, + "4": 2, + "5": 2 + } + } +} diff --git a/research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-engine.py b/research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-engine.py new file mode 100644 index 0000000000..6afabd3777 --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/inputs/PR1347-engine.py @@ -0,0 +1,229 @@ +# SPDX-License-Identifier: Apache-2.0 +# Cinna Davis, with substantial OpenAI Codex assistance. +"""Complete maximal rank-six slice census; E8 model from PR1226/PR1323.""" +from collections import Counter +from fractions import Fraction +import hashlib +import itertools +import json + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def bits(mask): + while mask: + bit = mask & -mask + yield bit.bit_length() - 1 + mask ^= bit + + +def model(): + roots = [] + for i, j in itertools.combinations(range(8), 2): + for si in (1, -1): + for sj in (1, -1): + root = [0] * 8 + root[i], root[j] = 2 * si, 2 * sj + roots.append(tuple(root)) + roots.extend(r for r in itertools.product((1, -1), repeat=8) + if r.count(-1) % 2 == 0) + lines, seen = [], set() + for root in roots: + key = max(root, tuple(-x for x in root)) + if key not in seen: + seen.add(key) + lines.append(root) + puncture = [] + for k in range(4): + for sign in (1, -1): + root = [0] * 8 + root[2*k], root[2*k+1] = 2, 2*sign + puncture.append(lines.index(tuple(root))) + return dict(lines=[list(r) for r in lines], punctured_frame=puncture, + live=[i for i in range(120) if i not in puncture]) + + +def geometry(data): + roots, live = data["lines"], data["live"] + require(len(roots) == 120 and len(live) == 112, "wrong model size") + require(all(sum(x*x for x in r) == 8 for r in roots), "wrong root norm") + products = [[sum(x*y for x, y in zip(a, b)) for b in roots] for a in roots] + require(all(v % 4 == 0 for row in products for v in row), "nonintegral pairing") + ip = [[v // 4 for v in row] for row in products] + n = [sum(((v+1) % 2) << j for j, v in enumerate(row)) for row in ip] + supports = [] + for a in range(120): + star = sum(1 << i for i in live if ip[a][i] != 0) + supports.extend((star, star & ~(1 << a))) + adjacent = [sum(1 << j for j in live if i != j and ip[i][j] == 0) + for i in range(120)] + frames = [] + + def extend(chosen, candidates): + if len(chosen) == 8: + frames.append(tuple(chosen)) + return + while candidates: + if candidates.bit_count() < 8-len(chosen): + return + bit = candidates & -candidates + candidates ^= bit + i = bit.bit_length()-1 + extend(chosen + [i], candidates & adjacent[i]) + extend([], sum(1 << i for i in live)) + require(len(frames) == 1260, "live frame census changed") + incidence = Counter(i for f in frames for i in f) + require(set(incidence) == set(live) and set(incidence.values()) == {90}, + "live frame incidence changed") + coframe = {pair for f in frames for pair in itertools.combinations(f, 2)} + require(all((i, j) in coframe for i, j in itertools.combinations(live, 2) + if ip[i][j] == 0), "an orthogonal live pair has no live frame") + return ip, n, supports, frames + + +def basis(values): + pivots = {} + for v in values: + while v: + p = v.bit_length()-1 + if p in pivots: + v ^= pivots[p] + else: + pivots[p] = v + break + return tuple(pivots.values()) + + +def rank(n, left, right): + return len(basis(n[i] & right for i in bits(left))) + + +def column_code(n, left, right): + generators = basis(n[j] & left for j in bits(right)) + code = [0] + for g in generators: + code += [v ^ g for v in code] + return sorted(code[1:]) + + +def word_digest(records): + return hashlib.sha256("".join(f"{w:x}\t{h}\n" for w, h in records).encode()).hexdigest() + + +def table_bytes(table): + return "".join(json.dumps(row, separators=(",", ":"))+"\n" for row in table).encode() + + +def census(data): + ip, n, supports, frames = geometry(data) + frame_masks = [sum(1 << i for i in f) for f in frames] + hit_cache, row_masks = {}, set() + + def hits(mask): + if mask not in hit_cache: + hit_cache[mask] = sum(1 << k for k, f in enumerate(frame_masks) if mask & f) + return hit_cache[mask] + + parent_ranks, cut_ranks, hit_counts = Counter(), Counter(), Counter() + table = [] + for a, left in enumerate(supports): + for b, right in enumerate(supports): + r = rank(n, left, right) + parent_ranks[r] += 1 + if r != 7: + continue + require((a % 2 or a//2 in data["punctured_frame"]) and + (b % 2 or b//2 in data["punctured_frame"]) and + ip[a//2][b//2] % 2, "rank-seven parent classification failed") + words = column_code(n, left, right) + require(len(words) == len(set(words)) == 127 and all(words), "incomplete code") + values = [] + right_hits = hits(right) + for word in words: + row = left ^ word + require(word & ~left == 0, "codeword leaves parent support") + r = rank(n, row, right) + require(r == 6, "maximal one-axis slice is not rank six") + cut_ranks[r] += 1 + row_masks.add(row) + h = (hits(row) & right_hits).bit_count() + hit_counts[h] += 1 + values.append((word, h)) + maximum = max(h for _, h in values) + maximizers = [w for w, h in values if h == maximum] + cut = min(maximizers, key=lambda w: (w.bit_count(), w)) + table.append([a, b, maximum, format(cut, "x"), cut.bit_count(), + len(maximizers), word_digest(values)]) + require(parent_ranks == {7: 7616, 8: 37440, 9: 12544}, "parent census changed") + lookup = {(row[0], row[1]): row for row in table} + one_axis = Counter(row[2] for row in table) + joint = Counter(max(row[2], lookup[row[1], row[0]][2]) for row in table) + maximum = max(one_axis) + selected = min((row for row in table if row[2] == maximum), + key=lambda row: ((row[0]-20) % 240, (row[1]-20) % 240, + int(row[3], 16))) + a, b, h, cut_hex = selected[:4] + cut = int(cut_hex, 16) + summary = dict( + status="PASS_COMPLETE_RANK6_FRAME_CENSUS", frames=1260, + required_frame_hits=10080, rank7_tagged_parents=len(table), + codeword_cases=sum(cut_ranks.values()), distinct_row_slice_supports=len(row_masks), + parent_rank_histogram=dict(sorted(parent_ranks.items())), + slice_rank_histogram=dict(cut_ranks), slice_frame_hit_histogram=dict(sorted(hit_counts.items())), + one_axis_parent_maximum_histogram=dict(sorted(one_axis.items())), + arbitrary_joint_parent_maximum_histogram=dict(sorted(joint.items())), + maximum_frame_hits=maximum, + averaged_frame_bound=str(Fraction(10080 * 6, maximum)), + all_rank6_term_count_lower_bound=10, + witness=dict(left_tag=a, right_tag=b, row_cut_hex=cut_hex, + retained_row_ids=list(bits(supports[a] ^ cut)), + column_ids=list(bits(supports[b])), copy_rank=6, frame_hits=h), + table_sha256=hashlib.sha256(table_bytes(table)).hexdigest()) + return table, summary + + +def check_cover(data, cover): + """Check a necessary-condition witness with exact bit ranks, not an LP solver.""" + _, n, supports, frames = geometry(data) + counts = [0] * len(frames) + diagonal = {i: 0 for i in data["live"]} + masks = [sum(1 << i for i in f) for f in frames] + terms = cover["terms"] + require(len(terms) == 10, "cover must contain ten terms") + for term in terms: + a, b, cut_hex = term + require(type(a) is int and type(b) is int and 0 <= a < 240 and 0 <= b < 240, + "invalid parent tags") + cut = int(cut_hex, 16) + left, right = supports[a], supports[b] + require(rank(n, left, right) == 7 and cut in column_code(n, left, right), + "cover term is outside the maximal-cut dictionary") + row = left ^ cut + require(rank(n, row, right) == 6, "cover term does not cost six") + for i, mask in enumerate(masks): + counts[i] += bool(row & mask and right & mask) + for i in diagonal: + diagonal[i] += bool(row & right & (1 << i)) + require(min(counts) >= 8, "cover misses a frame demand") + result = dict(terms=10, copy_bill=60, minimum_hits=min(counts), + hit_histogram=dict(sorted(Counter(counts).items())), + frame_counts_sha256=hashlib.sha256(bytes(counts)).hexdigest()) + require(json.loads(json.dumps(result)) == cover["exact_check"], "cover receipt changed") + diagonal_result = dict(minimum=min(diagonal.values()), + histogram=dict(sorted(Counter(diagonal.values()).items()))) + require(json.loads(json.dumps(diagonal_result)) == cover["diagonal_support_coverage"], + "diagonal support receipt changed") + return result + + +def check_diagonal_coverage(data, cover): + """Separate necessary identity check; frame feasibility does not imply it.""" + _, _, supports, _ = geometry(data) + covered = 0 + for a, b, cut in cover["terms"]: + covered |= (supports[a] ^ int(cut, 16)) & supports[b] + missing = [i for i in data["live"] if not covered & (1 << i)] + require(not missing, "uncovered diagonal prevents a masked identity: " + str(missing)) diff --git a/research/p112-fixed-frame-diagonal-seed52/verify.py b/research/p112-fixed-frame-diagonal-seed52/verify.py new file mode 100644 index 0000000000..dfe7af71ea --- /dev/null +++ b/research/p112-fixed-frame-diagonal-seed52/verify.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Cinna Davis, with substantial OpenAI Codex assistance. +"""Exact support census for the ten fixed maximum-hit P112 frame masks.""" +from collections import Counter +import argparse +import hashlib +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +INPUTS = HERE / "inputs" +PINNED = { + "PR1347-engine.py": "b59101564855a89de04f39fd28b0a853aa3c46ce0ce99951d93d7dd018543536", + "PR1347-COVERING.json": "27d567a56500f857962ddc69a9baed691a945e5a2979a26632e84c23133f1c95", +} + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def sha256(data): + return hashlib.sha256(data).hexdigest() + + +def load_engine(): + path = INPUTS / "PR1347-engine.py" + spec = importlib.util.spec_from_file_location("p112_pr1347_engine", path) + require(spec is not None and spec.loader is not None, "cannot load pinned predecessor engine") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def enum_bits(mask): + while mask: + bit = mask & -mask + yield bit.bit_length() - 1 + mask ^= bit + + +def candidate_record(group, a, b, cut, diagonal): + return {"group": group, "left_tag": a, "right_tag": b, + "cut_hex": format(cut, "x"), "diagonal_mask_hex": format(diagonal, "x")} + + +def make_result(): + for name, expected in PINNED.items(): + path = INPUTS / name + require(path.is_file(), f"missing pinned input: {name}") + require(sha256(path.read_bytes()) == expected, f"source pin mismatch: {name}") + + engine = load_engine() + data = engine.model() + _, normals, supports, frames = engine.geometry(data) + frame_masks = [sum(1 << i for i in frame) for frame in frames] + live = data["live"] + live_mask = sum(1 << i for i in live) + cover = json.loads((INPUTS / "PR1347-COVERING.json").read_text()) + require(len(cover["terms"]) == 10, "predecessor cover no longer has ten terms") + + hit_cache = {} + + def hits(support): + if support not in hit_cache: + hit_cache[support] = sum(1 << j for j, frame in enumerate(frame_masks) + if frame & support) + return hit_cache[support] + + patterns = [] + baseline_terms = [] + for term_index, (a, b, cut_hex) in enumerate(cover["terms"]): + require(0 <= a < len(supports) and 0 <= b < len(supports), + "predecessor cover has an out-of-range parent tag") + cut = int(cut_hex, 16) + left, right = supports[a], supports[b] + require(engine.rank(normals, left, right) == 7, + "predecessor cover parent rank changed") + require(cut in engine.column_code(normals, left, right), + "predecessor cover cut is outside its exact parent code") + row = left ^ cut + require(engine.rank(normals, row, right) == 6, + "predecessor cover row rank changed") + pattern = hits(row) & hits(right) + require(pattern.bit_count() == 1120, + "a fixed predecessor term is no longer maximum-hit") + patterns.append(pattern) + baseline_terms.append((term_index, a, b, cut, row, right)) + require(len(set(patterns)) == 10, "fixed cover does not have ten distinct frame masks") + pattern_to_group = {pattern: i for i, pattern in enumerate(patterns)} + groups = [[] for _ in patterns] + + rank7_pairs = 0 + code_words = 0 + for a, left in enumerate(supports): + for b, right in enumerate(supports): + if engine.rank(normals, left, right) != 7: + continue + rank7_pairs += 1 + words = engine.column_code(normals, left, right) + require(len(words) == 127 and all(words), "rank-seven parent code changed") + right_hits = hits(right) + code_words += len(words) + for cut in words: + row = left ^ cut + frame_hits = hits(row) & right_hits + if frame_hits.bit_count() != 1120: + continue + group = pattern_to_group.get(frame_hits) + if group is None: + continue + require(engine.rank(normals, row, right) == 6, + "maximum-hit candidate is not rank six") + diagonal = row & right & live_mask + groups[group].append((a, b, cut, diagonal)) + + require(rank7_pairs == 7616, "rank-seven tagged-parent count changed") + require(code_words == 967232, "complete parent/cut domain changed") + require(all(groups), "a fixed frame-mask class has no enumerated representative") + + group_receipts = [] + all_candidate_union = 0 + canonical_candidates = [] + for group_index, records in enumerate(groups): + records.sort(key=lambda row: (row[0], row[1], row[2])) + masks = sorted(set(row[3] for row in records)) + maximal = [mask for mask in masks + if not any(mask != other and (mask & ~other) == 0 for other in masks)] + group_union = 0 + for mask in masks: + group_union |= mask + all_candidate_union |= group_union + group_receipts.append({ + "group": group_index, + "frame_hit_mask_hex": format(patterns[group_index], "x"), + "frame_hits": patterns[group_index].bit_count(), + "support_triples": len(records), + "unique_diagonal_masks": len(masks), + "inclusion_maximal_diagonal_masks": len(maximal), + "maximal_masks_hex": [format(mask, "x") for mask in maximal], + "diagonal_union_hex": format(group_union, "x"), + "diagonal_union_size": group_union.bit_count(), + "candidates": [candidate_record(group_index, *row) for row in records], + }) + canonical_candidates.extend(candidate_record(group_index, *row) for row in records) + + # Independent exact positive control: replay the predecessor's fixed ten terms. + frame_counts = [0] * len(frames) + diagonal_counts = Counter() + baseline_candidate_ids = [] + for term_index, a, b, cut, row, right in baseline_terms: + for j, frame in enumerate(frame_masks): + frame_counts[j] += bool(row & frame and right & frame) + diagonal = row & right & live_mask + diagonal_counts.update(enum_bits(diagonal)) + group = pattern_to_group[hits(row) & hits(right)] + match = candidate_record(group, a, b, cut, diagonal) + require(match in group_receipts[group]["candidates"], + "predecessor witness is absent from the complete representative census") + baseline_candidate_ids.append(match) + frame_histogram = dict(sorted(Counter(frame_counts).items())) + frame_sha = sha256(bytes(frame_counts)) + require(min(frame_counts) >= 8, "predecessor positive control misses a frame demand") + require({"terms": 10, "copy_bill": 60, "minimum_hits": min(frame_counts), + "hit_histogram": {str(k): v for k, v in frame_histogram.items()}, + "frame_counts_sha256": frame_sha} == cover["exact_check"], + "predecessor frame-count receipt changed") + baseline_diag_histogram = dict(sorted(Counter(diagonal_counts[i] for i in live).items())) + expected_diag_histogram = {int(k): v for k, v in + cover["diagonal_support_coverage"]["histogram"].items()} + require(min(diagonal_counts[i] for i in live) == cover["diagonal_support_coverage"]["minimum"], + "predecessor diagonal minimum changed") + require(baseline_diag_histogram == expected_diag_histogram, + "predecessor diagonal histogram changed") + + missing = [i for i in live if not (all_candidate_union & (1 << i))] + candidate_bytes = json.dumps(canonical_candidates, sort_keys=True, + separators=(",", ":")).encode() + require(len(canonical_candidates) == sum(len(g) for g in groups), + "canonical candidate serialization changed") + + # Negative controls exercise the exact membership and coverage gates. + first = groups[0][0] + invalid_zero_cut_rejected = 0 not in engine.column_code( + normals, supports[first[0]], supports[first[1]]) + require(invalid_zero_cut_rejected, "zero-cut negative control unexpectedly admitted") + wrong_pattern_rejected = patterns[0] != patterns[1] + require(wrong_pattern_rejected and + (hits(supports[first[0]] ^ first[2]) & hits(supports[first[1]])) != patterns[1], + "cross-pattern negative control unexpectedly admitted") + require(len(missing) > 0, "this package is intended to certify a support obstruction") + require(all_candidate_union.bit_count() + len(missing) == len(live), + "diagonal union complement is inconsistent") + + return { + "schema_version": 1, + "status": "PASS_EXACT_FIXED_FRAME_PATTERN_DIAGONAL_OBSTRUCTION", + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "predecessor": { + "pr": 1347, + "commit": "64fd5f9e91961dedc16118fcc7ad71ee82efe28f", + "cover_sha256": PINNED["PR1347-COVERING.json"], + "engine_sha256": PINNED["PR1347-engine.py"], + }, + "domain": { + "live_diagonal_positions": len(live), + "live_line_ids": live, + "rank_seven_tagged_parent_pairs": rank7_pairs, + "nonzero_code_words_per_parent": 127, + "complete_parent_cut_cases": code_words, + "fixed_frame_mask_classes": len(patterns), + "required_frame_hits_per_class": 1120, + "matching_support_triples": len(canonical_candidates), + "unique_diagonal_masks": sum(g["unique_diagonal_masks"] for g in group_receipts), + }, + "groups": group_receipts, + "candidate_table_sha256": sha256(candidate_bytes), + "all_candidate_diagonal_union_hex": format(all_candidate_union, "x"), + "all_candidate_diagonal_union_size": all_candidate_union.bit_count(), + "uncovered_live_line_ids": missing, + "uncovered_live_lines": [ + {"line_id": i, "root_representative": data["lines"][i]} + for i in missing + ], + "fixed_cover_positive_control": { + "minimum_frame_hits": min(frame_counts), + "frame_hit_histogram": {str(k): v for k, v in frame_histogram.items()}, + "frame_counts_sha256": frame_sha, + "minimum_diagonal_multiplicity": min(diagonal_counts[i] for i in live), + "diagonal_multiplicity_histogram": {str(k): v for k, v in baseline_diag_histogram.items()}, + "candidate_terms_present": len(baseline_candidate_ids), + }, + "controls": { + "predecessor_cover_replays_frame_and_diagonal_receipts": True, + "all_predecessor_terms_appear_in_full_census": True, + "zero_cut_is_rejected_by_parent_code_membership": invalid_zero_cut_rejected, + "cross_pattern_substitution_is_rejected": wrong_pattern_rejected, + "missing_diagonal_is_absent_from_every_candidate": True, + }, + "interpretation": ( + "The union of every maximum-hit rank-six support representative in these ten " + "fixed frame-mask classes omits the listed live lines. Therefore no selection " + "of one representative per class can cover all live diagonals. This is a " + "support-only negative for this fixed ten-mask cover, not for other frame covers." + ), + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true", + help="regenerate RESULT.json after the exact replay") + args = parser.parse_args() + result = make_result() + path = HERE / "RESULT.json" + encoded = json.dumps(result, indent=2) + "\n" + if args.write_result: + path.write_text(encoded) + else: + require(path.is_file(), "RESULT.json is missing; use --write-result to generate it") + require(path.read_text() == encoded, "RESULT.json does not match the exact replay") + print("PASS_EXACT_FIXED_FRAME_PATTERN_DIAGONAL_OBSTRUCTION " + f"patterns={result['domain']['fixed_frame_mask_classes']} " + f"support_triples={result['domain']['matching_support_triples']} " + f"diagonal_union={result['all_candidate_diagonal_union_size']}/" + f"{result['domain']['live_diagonal_positions']} " + f"uncovered={len(result['uncovered_live_line_ids'])}") + + +if __name__ == "__main__": + main() From e5917254b781e9f327436ac682baab1c93941aed Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Tue, 13 Oct 2026 19:18:20 -0500 Subject: [PATCH 2/2] Record seed52 fixed-cover result and PR handoff --- research/p112-fixed-frame-diagonal-seed52/CLAIM.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/research/p112-fixed-frame-diagonal-seed52/CLAIM.md b/research/p112-fixed-frame-diagonal-seed52/CLAIM.md index 9074d5b6a7..2bb2edcb71 100644 --- a/research/p112-fixed-frame-diagonal-seed52/CLAIM.md +++ b/research/p112-fixed-frame-diagonal-seed52/CLAIM.md @@ -25,3 +25,12 @@ This is a support-only necessary-condition audit. A feasible tuple would not sol - **Expected artifact:** source-pinned exact enumerator and verifier, complete candidate and Pareto counts, exact feasible tuple or exhaustive negative certificate, mutation controls, scope/assumption statement, and a concise handoff. - **Reproducible entry point (planned):** `python3 -I -O -B research/p112-fixed-frame-diagonal-seed52/verify.py`. - **Expected finish:** 2026-10-14 01:15 UTC; claim expires 02:05 UTC. + +## Completed result + +- **PR:** [#1402](https://github.com/CrocSwap/integer-mult-bounds/pull/1402). +- Exhaustive replay covered all 7,616 rank-seven tagged parent pairs and their 127 nonzero code words each (967,232 cases). The ten fixed frame-mask classes contain 40 exact rank-six support triples, two distinct diagonal masks per class. +- The union of all 40 masks has size 102/112 and misses live line IDs `18, 47, 53, 62, 88, 92, 96, 100, 112, 117`. Hence every one-per-class selection within this fixed mask family misses these same ten diagonals. +- The predecessor's frame counts, frame digest, and diagonal multiplicity histogram reproduce exactly. Zero-cut, cross-mask and omitted-diagonal controls pass. +- Local checks passed under CPython 3.14.7: exact verifier, package metadata/source pins, JSON syntax, and `git diff --check`. CPython 3.12 is not installed locally; the registered manifest is ready for the repository's Python 3.12 workflow. +- No coefficient feasibility, different-mask cover, physical realization or κ improvement is claimed. Exact next step beyond scope: include all 5,376 maximum-hit frame masks and all their representatives in an exact joint frame-plus-diagonal cover.