From 3cdb6abcd702bc946ed9ba6d81413a81c75a12e6 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 18:20:34 -0500 Subject: [PATCH 1/2] Research exact S5 inverse five-cycle word minimum --- .../CERTIFICATE.json | 133 +++++++ .../s5-inverse-fivecycle-seed52bf211c/LICENSE | 201 ++++++++++ .../PR-BODY.md | 32 ++ .../README.md | 64 ++++ .../SOURCES.json | 18 + .../TASK.json | 144 ++++++++ .../VERIFY.json | 18 + .../verify.py | 344 ++++++++++++++++++ 8 files changed, 954 insertions(+) create mode 100644 research/s5-inverse-fivecycle-seed52bf211c/CERTIFICATE.json create mode 100644 research/s5-inverse-fivecycle-seed52bf211c/LICENSE create mode 100644 research/s5-inverse-fivecycle-seed52bf211c/PR-BODY.md create mode 100644 research/s5-inverse-fivecycle-seed52bf211c/README.md create mode 100644 research/s5-inverse-fivecycle-seed52bf211c/SOURCES.json create mode 100644 research/s5-inverse-fivecycle-seed52bf211c/TASK.json create mode 100644 research/s5-inverse-fivecycle-seed52bf211c/VERIFY.json create mode 100644 research/s5-inverse-fivecycle-seed52bf211c/verify.py diff --git a/research/s5-inverse-fivecycle-seed52bf211c/CERTIFICATE.json b/research/s5-inverse-fivecycle-seed52bf211c/CERTIFICATE.json new file mode 100644 index 0000000000..ce7f2286b0 --- /dev/null +++ b/research/s5-inverse-fivecycle-seed52bf211c/CERTIFICATE.json @@ -0,0 +1,133 @@ +{ + "alphabet": { + "all_factors_involutive": true, + "factor_count": 24, + "factor_involution_checks": 24, + "rank_one_idempotents": [ + [ + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 1, + 1 + ], + [ + 0, + 1, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 0 + ], + [ + 1, + 1, + 0, + 0 + ] + ] + }, + "direct_control": { + "call_count": 8, + "exact_target": true, + "factor_indices": [ + 3, + 9, + 15, + 21, + 18, + 12, + 6, + 0 + ] + }, + "group": { + "c": "s1*s2*s3*s4=(1 2 3 4 5)", + "elements": 120, + "generated_closure": 120, + "generators": [ + "(12)", + "(23)", + "(34)", + "(45)" + ], + "group_product": "standard right-to-left composition (a*b)(x)=a(b(x))", + "target": "diag([c],[c^-1])" + }, + "limits": [ + "Exact result only for the two-register F2[S5] model and the specified 24-factor alphabet.", + "No native integer-multiplication supplier mapping or selected-kappa improvement is claimed." + ], + "negative_controls": [ + "opposite target orientation remains distinct", + "drop final direct factor", + "replace the fourth generator in the E11 block with the third" + ], + "search": { + "exact_depth_state_counts_0_to_4": [ + 1, + 24, + 407, + 6098, + 87023 + ], + "exact_depth_state_sha256_0_to_4": [ + "d49869ed69e3f6c5767be714e35da226433b0c0af8c303185e36bd717c490802", + "193fb918b247b0d19283b8154594421401309a376afa71622e04bfc676ba0f04", + "6340116395cdb2c53ca1f47c018ee818d0123b793dcc10530c4e23c667fb8361", + "4f6c94816028dfa82a9b2bd9af0af239e98d4e90d0fad9a6672bf5cadaeffda4", + "47ee1342f918b9de763a0bd0c419c5a37589128c41e680c2f18ae93fe7ad6620" + ], + "exact_depth_word_counts_0_to_4": [ + 1, + 24, + 576, + 13824, + 331776 + ], + "minimum_call_count": 8, + "prefix_queries": 6505, + "radius": 7, + "raw_prefix_words": 14425, + "raw_suffix_words": 346201, + "shortest_witness_factor_indices": null, + "split": "prefix length <=3; suffix length <=4; factors are involutions", + "target_hits": 0, + "unique_prefix_states": 6505, + "unique_suffix_states": 93121 + }, + "solver_positive_control": { + "direct_word_factor_indices": [ + 3, + 9, + 15 + ], + "found_witness_factor_indices": [ + 3, + 9, + 15 + ], + "prefix_states": 25, + "radius": 3, + "split": "prefix length <=1; suffix length <=2", + "suffix_states": 431, + "target": "diag([s1*s2*s3],[1])", + "target_hits": 1 + }, + "status": "PASS_S5_INVERSE_FIVECYCLE_RADIUS7" +} diff --git a/research/s5-inverse-fivecycle-seed52bf211c/LICENSE b/research/s5-inverse-fivecycle-seed52bf211c/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/s5-inverse-fivecycle-seed52bf211c/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/s5-inverse-fivecycle-seed52bf211c/PR-BODY.md b/research/s5-inverse-fivecycle-seed52bf211c/PR-BODY.md new file mode 100644 index 0000000000..c15c969783 --- /dev/null +++ b/research/s5-inverse-fivecycle-seed52bf211c/PR-BODY.md @@ -0,0 +1,32 @@ +## Scope and result + +**Scoped exact minimum of eight paid factors; no new kappa.** In the full group algebra `F2[S5]`, generated by the four adjacent transpositions `s1=(12), s2=(23), s3=(34), s4=(45)`, the target `diag([c],[c^-1])`, where `c=s1*s2*s3*s4` is a 5-cycle, has no word of length at most seven in the 24-factor alphabet + +```text +D_N(si) = I + ([si] + [1]) N, +``` + +with all six rank-one idempotents `N` in `M2(F2)` allowed for each generator. The direct independent-coordinate construction uses eight factors, so the exact minimum in this two-register formal model is eight. Equality in the full group algebra certifies the action on arbitrary dirty inputs for these two registers. + +The complete radius-seven meet-in-the-middle search builds the prefix ball through length three and suffix ball through length four. It covers 14,425 raw prefix words and 346,201 raw suffix words before deduplication; the exact balls contain 6,505 and 93,121 matrix states. It finds zero target hits. The certificate records every per-depth state count and digest. All 24 factors are checked involutive; a planted three-call target is recovered; reverse-orientation, dropped-factor, and wrong-generator controls pass. + +## Reproduction + +```sh +python3 -I -B research/s5-inverse-fivecycle-seed52bf211c/verify.py +python3 scripts/research_package.py --package research/s5-inverse-fivecycle-seed52bf211c --check-only +``` + +Both commands passed locally under CPython 3.14.7. The package metadata and source-pin check passed. The registered package runner requests Python 3.12, which is unavailable locally. + +## Pins, costs, and limits + +- Seed: `52bf211cbbc5cdf54a9c9460f2174659`; task `bit-new-register-model`, priority revision 4. +- Exact scientific base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. +- Selected-result SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Catalogue SHA-256: `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`. +- Direct paid bill: eight factors; a shorter word would save one call, or 12.5%. The formal alphabet has no helper, recursive, frame, copy, restoration, precision, or hosting operations, so those costs are absent by definition. +- Merged PR #1911 proves sharp bills for two paid reflection labels in `D_infinity`; its Laurent argument does not descend to finite quotients. The completed free-group inverse-commutator claim in Discussion #1997 was released as implied by that theorem. This package uses four paid Coxeter generators in finite `S5`, which that two-label theorem does not cover. +- No native supplier mapping or selected-bound improvement is claimed. Physical implementation, precision, hosting, and assembly remain outside this formal model. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in target selection, exact search implementation, verification controls, and packaging. Apache-2.0. diff --git a/research/s5-inverse-fivecycle-seed52bf211c/README.md b/research/s5-inverse-fivecycle-seed52bf211c/README.md new file mode 100644 index 0000000000..1993217f2a --- /dev/null +++ b/research/s5-inverse-fivecycle-seed52bf211c/README.md @@ -0,0 +1,64 @@ +# Inverse 5-cycle pair in the four-generator S5 model + +**Scoped exact minimum: eight paid factors.** The complete radius-seven search finds no shorter word in the stated two-register group-algebra model. No selected supplier or κ improvement is claimed. + +## Model and target + +Use the full group algebra `F2[S5]`, with standard right-to-left permutation composition. The group is generated by the four adjacent transpositions + +```text +s1=(12), s2=(23), s3=(34), s4=(45). +``` + +For each generator `si` and every rank-one idempotent `N` in `M2(F2)`, a paid factor is + +```text +D_N(si) = I + ([si] + [1]) N. +``` + +There are six such idempotents and 24 paid factors. Each factor costs one call. The target is `diag([c],[c^-1])`, where `c=s1*s2*s3*s4=(1 2 3 4 5)`. Independent coordinate projectors give a direct eight-call word: four factors on `E11` for `c` and four on `E22` for `c^-1`. + +The exact result is that no word of length at most seven over the complete alphabet realizes this target. Since the direct eight-call word is replayed exactly, the minimum is eight in this model. Equality in the full `F2[S5]` algebra gives the arbitrary-dirty-state statement for the two registers. + +## Exact search and completeness + +The verifier enumerates the full 120-element permutation group, checks that the four transpositions generate it, enumerates all 16 binary 2x2 matrices and retains all six rank-one idempotents, then verifies that each of the 24 paid factors is an involution. + +It builds exact matrix-state balls through length four. Each group-algebra coefficient vector is a 120-bit integer; addition is XOR and right multiplication by a group element permutes those bits. Equal complete matrices have identical continuations, so the exact-depth state layers safely deduplicate words while retaining one witness per state. + +Every word of length at most seven splits as `P S` with `|P|<=3` and `|S|<=4`. Because each factor is self-inverse, `P S = T` exactly when `S=P^-1 T`. The verifier stores all states in the prefix and suffix balls and checks each inverse-prefix target in the suffix map. This covers all 4,785,883,225 raw words of lengths 0 through 7 without walking them individually. The complete balls contain 6,505 unique prefix states and 93,121 unique suffix states; per-depth counts and SHA-256 digests are in `CERTIFICATE.json`. + +The search's orientation is checked on a known three-call diagonal target, which is recovered by a 1+2 split. The eight-call direct construction, reverse target orientation, dropped-factor mutation, and wrong-generator mutation are also checked. + +## Cost and limits + +The direct formal cost is eight calls. A shorter witness through seven would save at least one fully charged call (12.5% of this word). This alphabet has no helper operations, recursive children, frame changes, copies, restorations, or hosting costs; every legal factor is charged once. The exact cost model is only the finite group-algebra word model. + +This is not a native integer-multiplication circuit or a selected bit-supplier mapping. The result does not change the selected record or κ. A physical address-map realization and its implementation, precision, hosting, and assembly costs remain outside the scope. + +## Reproduce + +From the repository root: + +```sh +python3 -I -B research/s5-inverse-fivecycle-seed52bf211c/verify.py +python3 scripts/research_package.py --package research/s5-inverse-fivecycle-seed52bf211c --check-only +``` + +Expected final line: + +```text +PASS_S5_INVERSE_FIVECYCLE_RADIUS7 alphabet=24 group=120 prefix_states=6505 suffix_states=93121 hits=0 direct=8 minimum=8 no_kappa +``` + +## Predecessors and overlap + +The closest two-register inverse-pair work is the free-group claim in Discussion #1997. It was handed off without a PR because the sharp two-label `D_infinity` theorem in merged [PR #1911](https://github.com/CrocSwap/integer-mult-bounds/pull/1911) implies that free-group endpoint. That theorem uses two paid reflections and its proof does not descend to finite quotients. This package instead charges four adjacent-transposition labels in `S5`; the four-label finite group and 5-cycle target are not covered by the two-label theorem. + +Other nearby results use a different object or endpoint: [PR #2116](https://github.com/CrocSwap/integer-mult-bounds/pull/2116) studies a four-role `A4` target with rank-one idempotents in `M4(F2)`; [PR #2187](https://github.com/CrocSwap/integer-mult-bounds/pull/2187) studies four order-two outputs over `C4`; [PR #2186](https://github.com/CrocSwap/integer-mult-bounds/pull/2186) uses two reflection labels in `D_infinity`; PR #2135 studies a three-role `D8` inverse pair. Discussion #2012 uses three registers over `S3`, while #1740 studies four registers over `S4`. The refreshed checks and the exact distinctions are recorded in `TASK.json`. + +## Open next questions + +- **Can an operation in a source-bound bit supplier realize any of these four adjacent-transposition calls at one paid-call cost?** A native realization would be needed before this finite model could affect the conditional multiplication bound. A feasible first step is to identify a source-bound address action with the adjacent-transposition relations and price its full carrier. No such mapping is known in this package, so the formal word result is not presented as a supplier improvement. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in selecting the target, implementing the exact meet-in-the-middle search, verification controls and packaging. New work is Apache-2.0. diff --git a/research/s5-inverse-fivecycle-seed52bf211c/SOURCES.json b/research/s5-inverse-fivecycle-seed52bf211c/SOURCES.json new file mode 100644 index 0000000000..392737aa2a --- /dev/null +++ b/research/s5-inverse-fivecycle-seed52bf211c/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + } + ] +} diff --git a/research/s5-inverse-fivecycle-seed52bf211c/TASK.json b/research/s5-inverse-fivecycle-seed52bf211c/TASK.json new file mode 100644 index 0000000000..54eacee330 --- /dev/null +++ b/research/s5-inverse-fivecycle-seed52bf211c/TASK.json @@ -0,0 +1,144 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "In F2[S5], generated by the four adjacent transpositions s1=(12), s2=(23), s3=(34), s4=(45), determine whether any word of at most seven paid factors D_N(si)=I+([si]+[1])N realizes diag([c],[c^-1]) on two arbitrary dirty registers, where c=s1*s2*s3*s4 is a 5-cycle and N ranges over all rank-one idempotents in M2(F2). The direct independent-coordinate word has eight calls.", + "scope_change_reason": "The selector card is broad and has recent neighboring work on S3, S4, D8 and D-infinity. This cycle changes both the group and operation alphabet: four noncommuting Coxeter generators of S5, a 5-cycle inverse-pair endpoint, and a complete radius-seven two-register search. It is not the previous two-generator D-infinity target or the active three-register S3 target.", + "bottleneck_link": "A shorter exact inverse-cycle word would expose cross-generator sharing in a new legal bit-operation alphabet. Its maximum local saving is one of eight calls; this is a formal mechanism result and requires a separate native supplier mapping before it can affect the selected bound.", + "budget_minutes": 60, + "stop_rule": "Run one complete exact meet-in-the-middle search for lengths 0..7. Stop at completion because the direct eight-call construction gives the upper bound. No reroll or larger radius.", + "outcome": "negative-result", + "evidence": "Exact meet-in-the-middle over the full 24-factor alphabet finds zero target hits through length 7. The independent-coordinate direct word of length 8 is exact, so the minimum is 8 in this model. The faithful S5 generator closure has 120 elements; all 24 factors are checked involutive; all six rank-one idempotents are enumerated. The radius-seven search covers 14,425 raw prefix words and 346,201 raw suffix words before state deduplication, yielding 6,505 prefix states and 93,121 suffix states. A known three-call diagonal target is recovered by a separate 1+2 lookup; reverse-target, dropped-factor and wrong-generator controls pass.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, exact group-algebra implementation, verification and package preparation.", + "open_questions": [ + { + "question": "Does the complete four-generator S5 factor alphabet contain a word of length at most seven for the inverse 5-cycle pair?", + "why_it_matters": "A shorter word would show a sharing mechanism across four noncommuting involutive address operations in a fully charged finite model.", + "first_step": "Build exact B3 and B4 matrix-state maps over F2[S5] and perform inverse-prefix lookup for the target.", + "blocked_by": "If the exact census has no hit, the scoped minimum is eight; transfer to a physical supplier remains outside this cycle." + } + ], + "track": "bit-mechanisms", + "seed": "52bf211cbbc5cdf54a9c9460f2174659", + "scope_key": "7084092dd726e7ba1f2f", + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "changed_hypothesis": "Replace two paid reflection labels in D-infinity with all four paid adjacent transpositions generating the finite nonabelian group S5; target a long inverse 5-cycle pair.", + "predecessors_and_overlap": { + "current_card": "The first selector suggestion, bit-helper-contract, was completed in Cycle Z; this cycle takes the other suggested bit-mechanisms card bit-new-register-model.", + "nearest_work": [ + "Merged PR #1911: sharp two-paid-reflection bills in D-infinity for arbitrary dirty registers. Its Laurent proof does not descend to finite quotients.", + "Discussion #1997: completed free-group inverse-commutator search, released without a PR because PR #1911 implies that two-label endpoint; the four-generator S5 alphabet is not covered by that quotient theorem.", + "PR #2116: four-role A4 endpoint in F2[A4], with M4(F2) factors; it excludes lengths through six, while this is a two-role S5 inverse 5-cycle through seven.", + "PR #2187: four-register C4 order-two outputs; different group and endpoint.", + "PR #2186: two-label D-infinity opposite translations; PR #2135: three-role D8 inverse pair.", + "Discussion #2012: completed three-register S3 mixed target; Discussion #1740: completed four-register S4 3-cycle target." + ], + "overlap_snapshot": "Cached complete snapshot had 435 open PRs (2026-10-14T23:03:49Z) and 877 Discussions (2026-10-14T23:05:44Z). A new live REST pass paged all 435 open PRs at 2026-10-14T23:19Z. A live GraphQL pass searched the 100 most recently updated open discussions and latest comments; the complete hub #1167 was fetched separately. The repository-wide find_overlap.py --refresh was interrupted after it stalled while paging Discussion comments.", + "live_checks": "No exact S5/five-cycle/adjacent-transposition target claim was found. The nearest exact two-register inverse-pair claim, #1997, is completed and explicitly subsumed by merged PR #1911 only after quotienting to D-infinity; that result does not cover the finite four-generator S5 model. PR #2116 (A4, four roles), PR #2187 (C4, four outputs), PR #2186 (D-infinity, two labels), and PR #2135 (D8, third role) are related but have different groups or endpoints. Latest #1167 hub comment is this cycle’s claim; no later same-scope claim was present." + }, + "optimistic_full_cost_budget": { + "direct_calls": 8, + "target_calls": 7, + "best_possible_saving": "1 call (12.5% of this exact formal word)", + "alphabet": "4 transposition labels x 6 rank-one idempotents = 24 paid factors; every factor costs one call.", + "complete_radius": "0..7, split into all prefixes of length <=3 and suffixes of length <=4; 14,425 prefix words and 346,201 suffix words before state deduplication.", + "dirty_state": "Full equality in F2[S5] ensures the two-register identity on arbitrary dirty group-algebra inputs.", + "other_costs": "No helper register, recursive child, frame transition, copy, restoration, precision or hosting operation exists in the defined formal word model. The direct eight paid factors are fully charged.", + "implementation_limit": "No native selected bit-supplier mapping exists in this model; no selected kappa improvement can be claimed." + }, + "method_and_domain": "Enumerate all six rank-one idempotents in M2(F2) and all 24 factors. Verify D_N(si)^2=I. Build exact group-algebra matrix balls B0..B4 over the faithful 120-element permutation model of S5, then use inverse-prefix lookup from B0..B3 against B0..B4 to decide whether any word of length <=7 equals the fixed target.", + "expected_evidence": "Exact group multiplication table, factor involution checks, complete B3/B4 state counts/digests, a 7-call-or-shorter witness if one exists, exact eight-call positive control, wrong-generator and dropped-factor controls, and full factor-cost ledger. If no shorter word exists, report only the scoped exact minimum eight in this formal model.", + "claim_expiry_utc": "2026-10-15T01:11:01Z", + "claim_status": "The claim is posted in the mechanism-proposals hub Discussion #1167: https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18935952. It remains active until the bounded search package is handed off.", + "remaining_obligations": [ + "The registered CPython 3.12 package replay remains unrun locally because python3.12 is unavailable; observe the hosted package check after publication.", + "No native supplier, selected-result or kappa improvement is claimed." + ], + "local_verification": { + "interpreter": "CPython 3.14.7", + "direct_verifier": "PASS_S5_INVERSE_FIVECYCLE_RADIUS7", + "positive_control": "known three-call target recovered by the exact 1+2 inverse-prefix search", + "negative_controls": [ + "reverse target differs", + "dropped direct factor differs", + "wrong-generator mutation differs" + ], + "registered_runner": "not yet run locally: repository runner requires Python 3.12; python3.12 is unavailable", + "package_metadata": "PASS_PACKAGE_METADATA_AND_PINS (check-only; not a mathematical acceptance check)" + }, + "final_overlap_refresh": { + "cached_complete_snapshot": { + "open_prs": 435, + "discussions": 877, + "open_prs_fetched_at_utc": "2026-10-14T23:03:49Z", + "discussions_fetched_at_utc": "2026-10-14T23:05:44Z" + }, + "live_pull_request_scan": { + "open_prs_fetched": 435, + "pages": 5, + "terms": "s5, 5-cycle, five-cycle, adjacent transposition, inverse-cycle, Coxeter, group algebra", + "nearest_open": "#2116 A4 four-output target; #2186 D-infinity; #2135 D8; no exact S5 target." + }, + "live_discussion_scan": { + "recent_open_discussions_reviewed": 100, + "coordination_hub": "#1167 fetched through its latest comment at 2026-10-14T23:11:35Z; this cycle’s claim remains the latest comment.", + "nearest": "#1997 completed free-group inverse-pair handoff; #2185 completed C4 work handed to PR #2187; #2012 completed S3 work; no exact S5 inverse-5-cycle claim." + }, + "refresh_note": "The full find_overlap.py --refresh was interrupted after about 50 seconds in Discussion comment pagination. Live open-PR pages, the newest 100 open Discussions and latest comments, the proposal hub, and nearest predecessor records were queried directly instead.", + "distinctions": "PR #1911 has a theorem for D-infinity with two paid reflection labels, and its proof does not descend to finite quotients. PR #2116 uses A4, four roles and M4(F2); PR #2187 uses C4 and four order-two outputs. This package uses two roles, all four adjacent transpositions of S5, and an inverse 5-cycle pair.", + "exact_scope_matches": { + "open_prs": 0, + "recent_open_discussions": 0 + } + }, + "publication": { + "status": "verified local package; ready to publish", + "path": "research/s5-inverse-fivecycle-seed52bf211c/", + "base": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "seed": "52bf211cbbc5cdf54a9c9460f2174659" + }, + "verified_at_utc": "2026-10-14T23:19:17Z" +} diff --git a/research/s5-inverse-fivecycle-seed52bf211c/VERIFY.json b/research/s5-inverse-fivecycle-seed52bf211c/VERIFY.json new file mode 100644 index 0000000000..2f042300a1 --- /dev/null +++ b/research/s5-inverse-fivecycle-seed52bf211c/VERIFY.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Rebuild the faithful S5 operation alphabet; verify all rank-one idempotents and involutive factors; check a known three-call meet-in-the-middle positive control, direct eight-call target, full radius-seven prefix/suffix census and target orientation, with dropped-factor and wrong-generator controls." + } + ] +} diff --git a/research/s5-inverse-fivecycle-seed52bf211c/verify.py b/research/s5-inverse-fivecycle-seed52bf211c/verify.py new file mode 100644 index 0000000000..1a347705d2 --- /dev/null +++ b/research/s5-inverse-fivecycle-seed52bf211c/verify.py @@ -0,0 +1,344 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact radius-seven meet-in-the-middle search in F2[S5].""" + +import argparse +import hashlib +import itertools +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +CERTIFICATE = HERE / "CERTIFICATE.json" +N_GROUP = 120 +POLY_BYTES = 15 # 120 coefficients over F2 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def mat_mul_f2(a, b): + return ( + (a[0] & b[0]) ^ (a[1] & b[2]), + (a[0] & b[1]) ^ (a[1] & b[3]), + (a[2] & b[0]) ^ (a[3] & b[2]), + (a[2] & b[1]) ^ (a[3] & b[3]), + ) + + +def rank2(m): + a, b, c, d = m + determinant = (a & d) ^ (b & c) + if determinant: + return 2 + return int(any(m)) + + +def idempotents(): + out = [] + for m in itertools.product((0, 1), repeat=4): + if rank2(m) == 1 and mat_mul_f2(m, m) == m: + out.append(m) + return tuple(out) + + +def make_group(): + permutations = tuple(itertools.permutations(range(5))) + index = {p: i for i, p in enumerate(permutations)} + identity = index[tuple(range(5))] + # Standard right-to-left composition: (a*b)(x) = a(b(x)). + product = tuple( + tuple(index[tuple(a[b[i]] for i in range(5))] for b in permutations) + for a in permutations + ) + generators = [] + for j in range(4): + p = list(range(5)) + p[j], p[j + 1] = p[j + 1], p[j] + generators.append(index[tuple(p)]) + inverse = [] + for p in permutations: + q = [0] * 5 + for i, value in enumerate(p): + q[value] = i + inverse.append(index[tuple(q)]) + return permutations, index, product, identity, tuple(generators), tuple(inverse) + + +def closure_size(product, identity, generators): + seen = {identity} + frontier = [identity] + while frontier: + g = frontier.pop() + for s in generators: + h = product[g][s] + if h not in seen: + seen.add(h) + frontier.append(h) + return len(seen) + + +def translate(poly, g, product): + out = 0 + bits = poly + while bits: + low = bits & -bits + i = low.bit_length() - 1 + out |= 1 << product[i][g] + bits ^= low + return out + + +def run(): + permutations, index, group_product, e, generators, inverses = make_group() + need(len(permutations) == N_GROUP, "S5 permutation count") + need(closure_size(group_product, e, generators) == N_GROUP, + "adjacent transpositions do not generate all S5 elements") + need(all(group_product[s][s] == e for s in generators), + "adjacent transposition order") + need(all(group_product[a][b] == group_product[b][a] + for a, b in ((generators[0], generators[2]), + (generators[0], generators[3]), + (generators[1], generators[3]))), + "nonadjacent Coxeter generators should commute") + + ns = idempotents() + need(len(ns) == 6 and len(set(ns)) == 6, "rank-one idempotent inventory") + alphabet = tuple((g, n) for g in generators for n in ns) + need(len(alphabet) == 24, "paid alphabet size") + + # c = s1*s2*s3*s4 under the declared permutation product. + c = e + for s in generators: + c = group_product[c][s] + c_inv = inverses[c] + need(group_product[c][c_inv] == e and group_product[c_inv][c] == e, + "5-cycle inverse") + powers = [] + power = e + for _ in range(5): + power = group_product[power][c] + powers.append(power) + need(all(p != e for p in powers[:4]) and powers[4] == e, + "target generator is not order five") + + one = 1 << e + zero = 0 + identity = (one, zero, zero, one) + target = (1 << c, zero, zero, 1 << c_inv) + target_reverse = (1 << c_inv, zero, zero, 1 << c) + + def factor_step(matrix, factor_index): + g, n = alphabet[factor_index] + a, b, c0, d = matrix + ta = a ^ translate(a, g, group_product) + tb = b ^ translate(b, g, group_product) + tc = c0 ^ translate(c0, g, group_product) + td = d ^ translate(d, g, group_product) + n00, n01, n10, n11 = n + return ( + a ^ (ta if n00 else 0) ^ (tb if n10 else 0), + b ^ (ta if n01 else 0) ^ (tb if n11 else 0), + c0 ^ (tc if n00 else 0) ^ (td if n10 else 0), + d ^ (tc if n01 else 0) ^ (td if n11 else 0), + ) + + factor_by_pair = {(n, g): i for i, (g, n) in enumerate(alphabet)} + factor_involution_controls = 0 + for fi in range(len(alphabet)): + need(factor_step(factor_step(identity, fi), fi) == identity, + "paid factor is not involutive") + factor_involution_controls += 1 + + # Independent-coordinate construction: D_E11(c) D_E22(c^-1), with each + # group element expanded into its four paid Coxeter generators. + e11 = (1, 0, 0, 0) + e22 = (0, 0, 0, 1) + direct = tuple(factor_by_pair[(e11, s)] for s in generators) + tuple( + factor_by_pair[(e22, s)] for s in reversed(generators) + ) + + def product_word(word): + out = identity + for fi in word: + out = factor_step(out, fi) + return out + + need(len(direct) == 8 and product_word(direct) == target, + "direct eight-call construction") + wrong_orientation = tuple(factor_by_pair[(e22, s)] for s in generators) + tuple( + factor_by_pair[(e11, s)] for s in reversed(generators) + ) + need(product_word(wrong_orientation) == target_reverse + and target_reverse != target, "opposite target orientation control") + need(product_word(direct[:-1]) != target, "dropped-factor control") + wrong_generator = list(direct) + wrong_generator[3] = factor_by_pair[(e11, generators[2])] + need(product_word(tuple(wrong_generator)) != target, + "wrong-generator control") + + # Exact balls of words of exactly each length. State deduplication is safe: + # equal complete matrices have identical continuations. Representatives + # are retained only to reconstruct witnesses. + layers = [{identity: ()}] + for depth in range(1, 5): + current = {} + for state, word in layers[-1].items(): + for fi in range(len(alphabet)): + child = factor_step(state, fi) + if child not in current: + current[child] = word + (fi,) + layers.append(current) + + def right_diagonal(matrix, left, right): + a, b, c0, d = matrix + return ( + translate(a, left, group_product), + translate(b, right, group_product), + translate(c0, left, group_product), + translate(d, right, group_product), + ) + + def inverse_prefix_search(left, right, prefix_depth, suffix_depth): + prefix_map = {} + suffix_map = {} + for layer in layers[:prefix_depth + 1]: + for state, word in layer.items(): + prefix_map.setdefault(state, word) + for layer in layers[:suffix_depth + 1]: + for state, word in layer.items(): + suffix_map.setdefault(state, word) + hits_ = [] + test_target = (1 << left, zero, zero, 1 << right) + for word in prefix_map.values(): + inverse_state = identity + for fi in reversed(word): + inverse_state = factor_step(inverse_state, fi) + tail = right_diagonal(inverse_state, left, right) + suffix = suffix_map.get(tail) + if suffix is not None: + combined = word + suffix + need(product_word(combined) == test_target, + "meet-in-the-middle witness failed exact replay") + hits_.append(combined) + best_ = min(hits_, key=len) if hits_ else None + return best_, len(hits_), len(prefix_map), len(suffix_map) + + # Solver positive control on a known three-call diagonal word, searched as + # a 1+2 split. This checks the inverse-prefix orientation used below. + known3 = tuple(factor_by_pair[(e11, s)] for s in generators[:3]) + g3 = e + for s in generators[:3]: + g3 = group_product[g3][s] + known3_target = (1 << g3, zero, zero, one) + need(product_word(known3) == known3_target, "known three-call target control") + found3, found3_count, found3_prefixes, found3_suffixes = inverse_prefix_search( + g3, e, 1, 2 + ) + need(found3 is not None and len(found3) <= 3, + "meet-in-the-middle failed the known three-call target") + + best, hit_count, prefix_count, suffix_count = inverse_prefix_search( + c, c_inv, 3, 4 + ) + if best is None: + minimum = 8 + else: + minimum = len(best) + need(minimum <= 7, "radius-seven witness outside search radius") + + def layer_digest(layer): + h = hashlib.sha256() + for state in sorted(layer): + for poly in state: + h.update(poly.to_bytes(POLY_BYTES, "little")) + return h.hexdigest() + + word_counts = [24 ** depth for depth in range(5)] + all_prefix_words = sum(24 ** depth for depth in range(4)) + all_suffix_words = sum(word_counts) + certificate = { + "status": "PASS_S5_INVERSE_FIVECYCLE_RADIUS7", + "group": { + "elements": N_GROUP, + "generated_closure": N_GROUP, + "generators": ["(12)", "(23)", "(34)", "(45)"], + "group_product": "standard right-to-left composition (a*b)(x)=a(b(x))", + "c": "s1*s2*s3*s4=(1 2 3 4 5)", + "target": "diag([c],[c^-1])", + }, + "alphabet": { + "rank_one_idempotents": [list(n) for n in ns], + "factor_count": len(alphabet), + "all_factors_involutive": factor_involution_controls == 24, + "factor_involution_checks": factor_involution_controls, + }, + "search": { + "radius": 7, + "split": "prefix length <=3; suffix length <=4; factors are involutions", + "raw_prefix_words": all_prefix_words, + "raw_suffix_words": all_suffix_words, + "unique_prefix_states": prefix_count, + "unique_suffix_states": suffix_count, + "exact_depth_word_counts_0_to_4": word_counts, + "exact_depth_state_counts_0_to_4": [len(layer) for layer in layers], + "exact_depth_state_sha256_0_to_4": [layer_digest(layer) for layer in layers], + "prefix_queries": prefix_count, + "target_hits": hit_count, + "minimum_call_count": minimum, + "shortest_witness_factor_indices": list(best) if best is not None else None, + }, + "solver_positive_control": { + "target": "diag([s1*s2*s3],[1])", + "direct_word_factor_indices": list(known3), + "radius": 3, + "split": "prefix length <=1; suffix length <=2", + "found_witness_factor_indices": list(found3), + "target_hits": found3_count, + "prefix_states": found3_prefixes, + "suffix_states": found3_suffixes, + }, + "direct_control": { + "factor_indices": list(direct), + "call_count": len(direct), + "exact_target": True, + }, + "negative_controls": [ + "opposite target orientation remains distinct", + "drop final direct factor", + "replace the fourth generator in the E11 block with the third", + ], + "limits": [ + "Exact result only for the two-register F2[S5] model and the specified 24-factor alphabet.", + "No native integer-multiplication supplier mapping or selected-kappa improvement is claimed.", + ], + } + return certificate + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true", help="write the deterministic certificate") + args = parser.parse_args() + certificate = run() + if args.write: + CERTIFICATE.write_text(json.dumps(certificate, indent=2, sort_keys=True) + "\n") + else: + expected = json.loads(CERTIFICATE.read_text()) + need(certificate == expected, "certificate mismatch; use --write only for an intentional update") + search = certificate["search"] + print( + "PASS_S5_INVERSE_FIVECYCLE_RADIUS7 alphabet=24 group=120 " + f"prefix_states={search['unique_prefix_states']} suffix_states={search['unique_suffix_states']} " + f"hits={search['target_hits']} direct=8 minimum={search['minimum_call_count']} no_kappa" + ) + + +if __name__ == "__main__": + main() From 8c85205e1d04a5df55a811df6638cd9e121afb42 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 18:21:31 -0500 Subject: [PATCH 2/2] Record S5 research PR handoff --- .../s5-inverse-fivecycle-seed52bf211c/TASK.json | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/research/s5-inverse-fivecycle-seed52bf211c/TASK.json b/research/s5-inverse-fivecycle-seed52bf211c/TASK.json index 54eacee330..5cfc87a75e 100644 --- a/research/s5-inverse-fivecycle-seed52bf211c/TASK.json +++ b/research/s5-inverse-fivecycle-seed52bf211c/TASK.json @@ -92,9 +92,9 @@ "method_and_domain": "Enumerate all six rank-one idempotents in M2(F2) and all 24 factors. Verify D_N(si)^2=I. Build exact group-algebra matrix balls B0..B4 over the faithful 120-element permutation model of S5, then use inverse-prefix lookup from B0..B3 against B0..B4 to decide whether any word of length <=7 equals the fixed target.", "expected_evidence": "Exact group multiplication table, factor involution checks, complete B3/B4 state counts/digests, a 7-call-or-shorter witness if one exists, exact eight-call positive control, wrong-generator and dropped-factor controls, and full factor-cost ledger. If no shorter word exists, report only the scoped exact minimum eight in this formal model.", "claim_expiry_utc": "2026-10-15T01:11:01Z", - "claim_status": "The claim is posted in the mechanism-proposals hub Discussion #1167: https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18935952. It remains active until the bounded search package is handed off.", + "claim_status": "FINDING / HANDOFF posted to Discussion #1167 at https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18936078; claim released after exact result and PR #2196 were posted.", "remaining_obligations": [ - "The registered CPython 3.12 package replay remains unrun locally because python3.12 is unavailable; observe the hosted package check after publication.", + "Observe the hosted PR checks; the registered CPython 3.12 package replay is unavailable locally.", "No native supplier, selected-result or kappa improvement is claimed." ], "local_verification": { @@ -107,7 +107,8 @@ "wrong-generator mutation differs" ], "registered_runner": "not yet run locally: repository runner requires Python 3.12; python3.12 is unavailable", - "package_metadata": "PASS_PACKAGE_METADATA_AND_PINS (check-only; not a mathematical acceptance check)" + "package_metadata": "PASS_PACKAGE_METADATA_AND_PINS (check-only; not a mathematical acceptance check)", + "hosted_checks": "All reported checks were QUEUED at PR head 3cdb6abcd702bc946ed9ba6d81413a81c75a12e6 when checked; no hosted pass is claimed." }, "final_overlap_refresh": { "cached_complete_snapshot": { @@ -135,10 +136,14 @@ } }, "publication": { - "status": "verified local package; ready to publish", + "status": "open focused PR; hosted checks queued at last observation", "path": "research/s5-inverse-fivecycle-seed52bf211c/", "base": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", - "seed": "52bf211cbbc5cdf54a9c9460f2174659" + "seed": "52bf211cbbc5cdf54a9c9460f2174659", + "commit": "3cdb6abcd702bc946ed9ba6d81413a81c75a12e6", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/2196", + "discussion_handoff": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18936078", + "head_status": "MERGEABLE; merge state UNSTABLE because all hosted checks were QUEUED when observed at 2026-10-14T23:20Z" }, - "verified_at_utc": "2026-10-14T23:19:17Z" + "verified_at_utc": "2026-10-14T23:21:21Z" }