From e7adb88c33fc5e66a7b278432417cb112abc4ec4 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:08:17 -0500 Subject: [PATCH 1/4] Add exact S4 double-transposition register tariff --- .../CERTIFICATE.json | 79 ++++ .../s4-double-transposition-seedb270/CLAIM.md | 18 + .../s4-double-transposition-seedb270/PROOF.md | 100 +++++ .../README.md | 156 ++++++++ .../SOURCES.json | 48 +++ .../TASK.json | 66 ++++ .../VERIFY.json | 22 ++ .../verify.py | 356 ++++++++++++++++++ 8 files changed, 845 insertions(+) create mode 100644 research/s4-double-transposition-seedb270/CERTIFICATE.json create mode 100644 research/s4-double-transposition-seedb270/CLAIM.md create mode 100644 research/s4-double-transposition-seedb270/PROOF.md create mode 100644 research/s4-double-transposition-seedb270/README.md create mode 100644 research/s4-double-transposition-seedb270/SOURCES.json create mode 100644 research/s4-double-transposition-seedb270/TASK.json create mode 100644 research/s4-double-transposition-seedb270/VERIFY.json create mode 100644 research/s4-double-transposition-seedb270/verify.py diff --git a/research/s4-double-transposition-seedb270/CERTIFICATE.json b/research/s4-double-transposition-seedb270/CERTIFICATE.json new file mode 100644 index 0000000000..ad1a4f4347 --- /dev/null +++ b/research/s4-double-transposition-seedb270/CERTIFICATE.json @@ -0,0 +1,79 @@ +{ + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "controls": { + "all_28_idempotents_rank_one": true, + "all_3_paid_displacements_rank_one": true, + "all_84_factor_involutions": true, + "altered_dirty_role_target_rejected": true, + "gl3_f2_determinants_one": true, + "gl3_f2_order": 168, + "target_displacement_rank_two": true + }, + "cost_screen": { + "best_strict_improvement_bill": 6, + "call_saving_required": 2, + "direct_bill": 8, + "natural_representation_rank_floor": 4, + "sign_determinant_forces_even_length": true + }, + "direct_word": { + "adjacent_transposition_indices": [ + 1, + 0, + 2, + 1 + ], + "all_single_call_omissions_rejected": 8, + "formal_endpoint_verified": true, + "paid_call_count": 8 + }, + "meet_in_middle": { + "all_calls_involutive": true, + "exact_minimum": 8, + "exact_minimum_if_within_six": 8, + "intersection_count": 0, + "left_layer_counts": [ + 1, + 84, + 4697, + 232692 + ], + "left_sorted_state_sha256": "050e8b23a52a22b845208eb0a241872e53511f7843dbf5c6e42b3eda4bc757ac", + "left_state_count": 237474, + "radius_each_side": 3, + "right_layer_counts": [ + 1, + 84, + 4697, + 232692 + ], + "right_sorted_state_sha256": "caf772096918c6a120a394f7f734667e9bf69d67a871f868d4063a848f87827a", + "right_state_count": 237474, + "shortest_meeting_length": null, + "shortest_word_factor_ids": null + }, + "model": { + "active_targets": 2, + "address_group": "S4", + "dirty_roles": "all three arbitrary inputs; third role restored exactly", + "endpoint_ring": "formal F2[S4]", + "field": "F2", + "free_scalar_mixing": "all GL3(F2), normalized by augmentation", + "paid_factor_count": 84, + "paid_letters": [ + "(12)", + "(23)", + "(34)" + ], + "rank_one_idempotents": 28, + "roles": 3, + "target_permutation": "(13)(24)" + }, + "runtime_seconds_excluded_from_receipt": true, + "schema_version": 1, + "seed": "b270b3b52d302ab6281ea2bc042d4aea", + "selected_frontier": "unchanged; no supplier or kappa claim", + "selected_result_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "task_id": "bit-new-register-model", + "track": "bit-mechanisms" +} diff --git a/research/s4-double-transposition-seedb270/CLAIM.md b/research/s4-double-transposition-seedb270/CLAIM.md new file mode 100644 index 0000000000..e71818cc43 --- /dev/null +++ b/research/s4-double-transposition-seedb270/CLAIM.md @@ -0,0 +1,18 @@ +# Local scope claim — S4 double-transposition pair + +- **Track / accepted draw:** `bit-mechanisms`, seed `b270b3b52d302ab6281ea2bc042d4aea`. +- **Task / catalogue:** `bit-new-register-model`, priority revision 3; `docs/research/agent-task-catalog.json` SHA-256 `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`. +- **Exact base:** `0b1cccf86e2f5132ed286a26ef0a681a495740ea` (`origin/main`). +- **Selected record:** SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- **Scope key:** `032dead5b9f6bb2216f0` (first 20 hex characters of SHA-256 of the canonical scope below). +- **Scope-key input:** `In formal F2[S4] register circuits over three dirty scalar roles, determine the minimum paid-call count for diag([(13)(24)],[(13)(24)],[e]) using each of (12),(23),(34) at cost 1, all rank-one idempotents N over F2, and arbitrary free interleaved GL3(F2) scalar mixing; compare against direct cost 8.` +- **Canonical scope:** In formal `F2[S4]`, with three arbitrary dirty scalar roles, all 28 rank-one idempotents over F2, and the three paid adjacent transpositions `(12),(23),(34)` at one call each, determine the exact minimum for `diag([(13)(24)],[(13)(24)],[e])`, while allowing arbitrary free interleaved `GL3(F2)` mixing. Search only the complete parity-permitted radius-3 meet (all words of length at most 6); compare with the eight-call direct construction. +- **Changed hypothesis / expense:** replace the abelian rational-address model by this fixed nonabelian Coxeter alphabet; every paid letter is counted, while free scalar mixing and the restored third dirty role are granted optimistically at no extra charge. +- **Cost screen:** direct bill 8. The natural permutation representation gives a rank floor 4, and the sign determinant quotient forces even word length. The best possible strict improvement is therefore 6 calls (save 2/25%). If the exact radius-3 balls are disjoint, the declared endpoint has exact cost 8 and no local saving. +- **Predecessors / overlap:** PR #1720 at head `edb4a289a5f32c8209140144e384dcd3fa8cbfd1` studies two 4-cycle targets in the same S4 / three-role / adjacent-transposition model; this claim changes the endpoint to a rank-2 double transposition, where Coxeter length exceeds displacement rank. PR #1443 (merged at `965ff75aabb16cdd0978f4bf9222bcdedf514021`) studies two-register D8 central targets. The cached complete Discussion scan (351 records, fetched 2026-10-14 07:28:35Z) contains an exact UT3 third-role follow-up but no S4 `(2,2)` target claim. A direct REST open-PR census at 2026-10-14 08:00Z found no S4 double-transposition match; nearby #1720, #1705, #1711 and the UT3/UT4 results have different target groups or endpoints. `find_overlap.py --refresh` could not refresh PRs (`gh api --slurp` unsupported by installed gh) or Discussions (GitHub GraphQL rate limit). Recent Discussions could not be freshly rechecked or written to because of that API limit, so this claim is local. +- **Expected deliverable:** a full formal group-algebra identity for the direct eight-call word, exact complete radius-3 balls from identity and target, plus proof that they are disjoint or an extracted six-call construction. Finite controls check all 84 involutive factors, direct endpoint, call omissions and an altered dirty-role target. No selected-kappa claim. +- **Expiry:** 2026-10-14 08:40 UTC. + +The selector was run from this cycle's exact-base worktree. It discarded seeds `8ccb721845414467f1587f50e18a6252` (consolidation), `1bb2bb9d8fbe33f2d7d4099fb9db95f1` (adversarial-audit) and `72d16ec637edc91f2b0fa7c754335a35` (independent-verification), then accepted the seed above. A previous selector invocation from the separate cycle-2 worktree returned `18291c3ad5e0953d9e5f16c79f345b06` against that PR branch; it was discarded before any experiment because its base was not this cycle's main commit. + +GitHub Discussion claim publication is unavailable in the current environment; the local claim and the PR handoff will preserve the scope and result. diff --git a/research/s4-double-transposition-seedb270/PROOF.md b/research/s4-double-transposition-seedb270/PROOF.md new file mode 100644 index 0000000000..f7f2cd70c9 --- /dev/null +++ b/research/s4-double-transposition-seedb270/PROOF.md @@ -0,0 +1,100 @@ +# Exact cost of a pair of S4 double transpositions + +## Theorem + +Let `R = F2[S4]`, let the number of scalar roles be `W=3`, and define a paid +call for `s in {(12),(23),(34)}` and a rank-one idempotent `N in M3(F2)` by + +```text +D(s,N) = I + ([s]+[e])N. +``` + +Allow arbitrary free interleaved scalar `GL3(F2)` changes of basis. For +arbitrary dirty inputs, the complete endpoint + +```text +diag([(13)(24)], [(13)(24)], [e]) +``` + +has exact paid-call minimum eight. + +## Upper bound + +With right multiplication as the word convention, put +`s1=(12)`, `s2=(23)`, `s3=(34)`. Direct composition gives +`q=s2*s1*s3*s2=(13)(24)`. Four calls with `N=E11` place `[q]` in the first +diagonal role; four with `N=E22` place `[q]` in the second. Every other entry +is the identity, so this is a formal `R`-matrix identity on arbitrary input, +including the restored third dirty role. Thus the minimum is at most eight. + +## Normalize free scalar maps + +Write a free scalar map as `A tensor [e]`. Moving it to the right across a +paid factor uses + +```text +(A tensor 1) D(s,N) = D(s, A N A^-1) (A tensor 1). +``` + +Conjugation preserves rank one and idempotence, so the 84 factors already +include every normalized choice. The augmentation homomorphism +`epsilon:R->F2`, `epsilon([g])=1`, sends every paid factor to `I`. The target +also augments to `I3`. Therefore the product of the moved free scalar maps +must be `I3`. No extra words are introduced by free mixing. + +## Even-length obstruction + +The sign character gives a ring homomorphism +`F2[S4] -> F2[C2]`; denote the nonidentity basis element of `C2` by `x`, so +`x^2=1`. Every adjacent transposition maps to `x`, whereas +`q=(13)(24)` maps to `1`. The target therefore maps to the identity matrix. + +For any rank-one idempotent `N=u v^T`, `v^T u=1`, and the paid factor maps to +`I+(x+1)u v^T`. The coefficient ring is commutative, so the determinant +lemma yields + +```text +det(I+(x+1)u v^T) = 1 + (x+1)v^T u = x. +``` + +Each free `GL3(F2)` map has determinant one, since the only nonzero element of +`F2` is one. Determinants multiply, so an endpoint word with `k` paid calls +has determinant `x^k`; the target determinant is one. Since `x` has order +two, `k` is even. Any strict improvement over the eight-call direct word +would therefore have length at most six. + +## Complete six-call exclusion + +Each `D(s,N)` is an involution. In `R`, `a=[s]+[e]` satisfies `a^2=0` in +characteristic two; using `N^2=N`, + +```text +D(s,N)^2 = I + 2aN + a^2 N = I. +``` + +Consider the right-multiplication Cayley graph on all `3x3` matrices over +`R`, starting either at identity `I3` or at target `T`. The verifier +enumerates the full radius-three balls using all three labels and all 28 +rank-one idempotents. A word of length at most six splits as `AB` with +`|A|,|B|<=3`. If `AB=T`, involutivity gives `A=T B^-1`, so the intermediate +state belongs to both balls. The independently enumerated exact balls have +layers `[1,84,4697,232692]` and empty intersection. Hence no word of length +at most six reaches the target. + +The state stores every coefficient of every matrix entry in `F2[S4]` as a +24-bit mask; the implementation packs the nine masks into 27 bytes for the +visited-state keys. It performs no address specialization, probability +sampling, rank pruning or assumed group-ring faithfulness. Sorted state hashes +and counts are in `CERTIFICATE.json`; replay recomputes all states and hashes. + +Together with the direct word and even-length obstruction, the exact minimum +is eight. + +## Exactness boundary + +The theorem is for this fixed finite group, paid-letter set, role count and +endpoint. The natural permutation representation only gives the four-call +rank floor and is not used to prove the stronger exclusion. This does not +establish that any supplier can provide these operations, that the model +occurs in a selected circuit, or that any recursive moment or conditional +multiplication bound changes. diff --git a/research/s4-double-transposition-seedb270/README.md b/research/s4-double-transposition-seedb270/README.md new file mode 100644 index 0000000000..c9c447a2b6 --- /dev/null +++ b/research/s4-double-transposition-seedb270/README.md @@ -0,0 +1,156 @@ +# Two S4 double-transposition targets need eight paid calls + +**Scoped exact negative result; no new κ.** With three dirty scalar roles, +free `GL3(F2)` mixing and the paid alphabet of adjacent transpositions, two +copies of the S4 double transposition `(13)(24)` require exactly eight calls. +The natural displacement-rank floor is only four, so this test asks whether +register mixing can use that gap. A sign-determinant parity argument and a +complete formal radius-three meet-in-the-middle exclude every possible +improvement to six calls. + +## Exact model and optimistic cost + +Let `R = F2[S4]`. There are three scalar roles over `F2`, all with arbitrary +dirty input. A call chooses one adjacent transposition +`s in {(12),(23),(34)}` and one of the 28 rank-one idempotents +`N = u v^T in M3(F2)` with `v^T u = 1`, and applies + +```text +D(s,N) = I3 + ([s] + [e]) N. +``` + +Every call costs one. Arbitrary interleaved scalar `GL3(F2)` maps are free. +The endpoint is the full formal group-algebra matrix +`diag([(13)(24)],[(13)(24)],[e])`; therefore the third arbitrary dirty role +is restored identically. The complete alphabet has 3×28=84 paid factors. + +The direct Coxeter word for `(13)(24)` has length four, so the two-target +upper bill is eight. In the natural permutation representation on `F2^4`, +each adjacent transposition has displacement rank one, while `(13)(24)` has +rank two. Rank subadditivity therefore gives a four-call lower floor. The +strict improvement objective is six calls or fewer, a two-call / 25% saving. +This screen grants free register mixing and the third role without any +separate hosting, allocation or restoration charge, and charges every paid +address call. It is an optimistic local model, not a physical bit supplier. + +The accepted selected record is +`κ = 836330098538459/500000000000000000`, with selected-record SHA-256 +`10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +Its review is `docs/research/community-batch1099-review.md`; the source +manifest is `research/community-frontier1094-audit/SELECTED-SOURCE.json`; the +assembly certificate is +`research/community-frontier1094-audit/ASSEMBLY.json` (SHA-256 +`1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`); the +reproduction command is `make frontier1094-verify`. The binding-only baseline +reports the complex primitive as binding. This result has no supplier +occurrence, recursive moment or selected-κ implication. + +## Exact lower bound and matching construction + +The selected word `s2 s1 s3 s2` (where `s1=(12)`, `s2=(23)`, `s3=(34)`) +equals `(13)(24)`. Applying it with coordinate idempotent `E11`, then with +`E22`, gives the exact eight-call formal endpoint. All eight single-call +omissions and an endpoint changed on the dirty third role fail exact replay. + +For the lower bound, augmentation `ε([g])=1` sends every paid factor to the +identity. Move any free scalar map through a paid factor by conjugating `N`; +the conjugate remains a rank-one idempotent. The product of all free maps is +then the identity by augmentation, so it suffices to enumerate words in the +84-factor alphabet. + +The sign homomorphism `S4 -> C2` sends every paid adjacent transposition to +the nontrivial element `x`, with `x^2=1`, and sends the even target +`(13)(24)` to the identity. Over the commutative ring `F2[C2]`, the matrix +determinant lemma gives +`det(I + (x+1) u v^T) = 1 + (x+1) v^T u = x`. +Every scalar `GL3(F2)` map has determinant one. Hence a `k`-call word reaching +the target must satisfy `x^k=1`, so `k` is even. A strict improvement over +eight must consequently use at most six calls. + +Every paid factor is an involution because `( [s]+[e] )^2=0` in +characteristic two. Any word of length at most six splits into two words of +length at most three. Reversing the second part from the target would put an +intermediate matrix in both radius-three balls. The exact search enumerates +all such formal matrices, storing each 3×3 matrix as nine 24-bit +`F2[S4]` coefficient masks. Each ball has layer counts +`[1,84,4697,232692]`, for 237,474 states; their intersection is empty. +The hashes of the sorted packed states are recorded in +[CERTIFICATE.json](CERTIFICATE.json). The two upper/lower arguments establish +that the exact minimum in this model is eight. + +This is an exact theorem about one finite paid alphabet and one endpoint, +not a test over selected address columns. The natural representation supplies +only the weaker rank floor; the final exclusion uses the complete formal +group-algebra balls. The proof does not rely on faithfulness of the natural +group-algebra representation. + +## Reproduce + +From the repository root: + +```sh +python3.12 -I -B research/s4-double-transposition-seedb270/verify.py +python3.12 scripts/research_package.py --package research/s4-double-transposition-seedb270 --check-only +python3.12 scripts/research_package.py --package research/s4-double-transposition-seedb270 +``` + +Expected verifier output begins: + +```text +PASS_S4_DOUBLE_TRANSPOSITION EXACT_8 direct=8 rank_floor=4 parity=even factors=84 +balls=237474,237474 intersections=0 layers=[1, 84, 4697, 232692] +``` + +On Python 3.12.3 the full exact replay took about 3.1 seconds and used 93 MiB +peak resident memory as measured by `/usr/bin/time -v`. The certificate stores +deterministic complete-ball hashes, not an unbounded or sampled search. + +## Scope and overlap + +The main nonabelian register predecessors are PR #1720 (head +`edb4a289a5f32c8209140144e384dcd3fa8cbfd1`), which treats two 4-cycle targets +in S4 with the same adjacent-transposition alphabet, and the completed UT3 +central-commutator results in PR #1443 and its later third-role follow-up, +PR #1478 (head `b30fdba48f3db70e3589ba740b0782b56ec0ba2e`). The present +endpoint changes the target cycle type to `(2,2)`, where transposition length +four exceeds natural displacement rank two; the question is whether scalar +mixing bridges that specific gap. PR #1333's exact binary-affine register +formula and PR #1573's UT3 all-register rank result also use displacement-rank +arguments, but their address groups, paid alphabets and targets differ. This +package does not claim a new general rank method and imports no predecessor +code. PR #1705's GL2 coordinate-SWAP targets and PR #1711's AGL2 affine targets +are also distinct. + +The live PR scan used REST at 2026-10-14 08:00 UTC and found no S4 +double-transposition claim. The overlap helper could not refresh its PR cache +because the installed `gh api` rejects `--slurp`; the fresh Discussion fetch +was blocked by the GitHub GraphQL rate limit. Its latest complete cached scan +contained 351 records at 07:28 UTC and showed no S4 `(2,2)` target claim. A +fresh claim post was unavailable, so the complete local claim is in +[CLAIM.md](CLAIM.md). It records the exact seed, catalogue revision, base, +selected-record hash, scope, competitors and expiry. + +This local model is not physically mapped to the selected bit supplier. The +selected baseline remains complex-primitive-bound; physical address +realization, hosting, precision, restoration cost in a native circuit and +recursive-moment impact remain unestablished. No selected source, certificate +or frontier value is changed. + +## Open next questions + +The exact local endpoint is closed, so no adjacent target tuple is claimed. +The remaining question is whether any selected bit supplier exposes these +adjacent transpositions at a fully charged unit cost while retaining the dirty +role contract. The first step would be an explicit supplier-interface map and +invoice; the current complex-primitive binding and absence of an identified +supplier occurrence block a selected-bound conclusion. + +## Research record and credit + +This is a fixed nonabelian register-model negative result, not a new supplier, +conditional bound or multiplication theorem. Sources are pinned in +[SOURCES.json](SOURCES.json); the complete state and controls are in +[CERTIFICATE.json](CERTIFICATE.json), and the written argument is +[PROOF.md](PROOF.md). Prepared by Cinna Davis with substantial OpenAI Codex +assistance in scoping, algebraic proof, exact implementation, verification and +writing. No subagents or independent human review are claimed. Apache-2.0. diff --git a/research/s4-double-transposition-seedb270/SOURCES.json b/research/s4-double-transposition-seedb270/SOURCES.json new file mode 100644 index 0000000000..f0e192e1c5 --- /dev/null +++ b/research/s4-double-transposition-seedb270/SOURCES.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "autoresearch.md", + "usage": "input", + "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", + "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699" + }, + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "input", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "input", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "input", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + } + ] +} diff --git a/research/s4-double-transposition-seedb270/TASK.json b/research/s4-double-transposition-seedb270/TASK.json new file mode 100644 index 0000000000..f9478aa7fb --- /dev/null +++ b/research/s4-double-transposition-seedb270/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "track": "bit-mechanisms", + "seed": "b270b3b52d302ab6281ea2bc042d4aea", + "task_id": "bit-new-register-model", + "priority_revision": 3, + "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "selected_result_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "assignment_nonce": "b270b3b52d302ab6281ea2bc042d4aea", + "scope_key": "032dead5b9f6bb2216f0", + "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" + ], + "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": "Write a complete operation alphabet outside one named premise and price a baseline before searching identities.", + "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." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "refined", + "actual_scope": "In formal F2[S4] register circuits over three dirty scalar roles, determine the minimum paid-call count for diag([(13)(24)],[(13)(24)],[e]) using each of (12),(23),(34) at cost 1, all rank-one idempotents N over F2, and arbitrary free interleaved GL3(F2) scalar mixing; compare against direct cost 8.", + "scope_change_reason": "The broader all-transposition permutation-rank formula duplicates the generic rank-one address argument already available for arbitrary affine registers, and the candidate D8 third-role extension has an exact UT3 follow-up in current Discussion records. Keep the accepted seed and nonabelian register question, but refine to a distinct rank-slack endpoint: two copies of the S4 double transposition have adjacent-transposition length 4 each but natural displacement rank 2 each. This makes a two-call sharing saving possible under the generous three-role alphabet, unlike the 4-cycle endpoint in PR #1720.", + "bottleneck_link": "This tests whether nonabelian scalar-register mixing can exploit the gap between the Coxeter cost and natural displacement rank of a target. A saving would be a candidate bit mechanism requiring separate mapping into a supplier; the selected binding-only baseline currently reports the complex primitive as binding, so no selected kappa change follows.", + "budget_minutes": 60, + "stop_rule": "Prove the even-call parity obstruction using the sign determinant over F2[C2], then enumerate the complete radius-three balls from identity and target over all 84 paid involutions. Stop after the exact meet result and direct word; do not widen the group, alphabet, or role count.", + "outcome": "negative-result", + "evidence": "The direct formal endpoint costs 8 calls. The natural F2^4 permutation representation gives only a 4-call rank floor, while the sign determinant forces even length. Complete exact radius-three balls each contain 237474 formal 3x3 F2[S4] states with layers [1,84,4697,232692], hashes 050e8b23a52a22b845208eb0a241872e53511f7843dbf5c6e42b3eda4bc757ac and caf772096918c6a120a394f7f734667e9bf69d67a871f868d4063a848f87827a, and have empty intersection. Thus no word of length at most 6 exists and the exact minimum is 8 in this model. Eight call-omission controls, altered dirty-role control and all 84 factor involution checks pass. No supplier or kappa claim.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in scoping, algebraic proof, exact search implementation, verification and writing. No subagents or independent human review.", + "open_questions": [ + { + "question": "Can any supplier expose these adjacent transpositions as one uniformly paid operation while retaining the formal dirty-role endpoint?", + "why_it_matters": "Without a supplier and compiler mapping, this exact local cost model cannot change the selected conditional bound.", + "first_step": "Compare each adjacent-transposition operation to the selected bit-supplier interface and account for address, hosting and restoration costs.", + "blocked_by": "The present selected baseline is complex-primitive-bound, and this package supplies no physical embedding or recursive-moment occurrence." + } + ] +} diff --git a/research/s4-double-transposition-seedb270/VERIFY.json b/research/s4-double-transposition-seedb270/VERIFY.json new file mode 100644 index 0000000000..d0059d14ba --- /dev/null +++ b/research/s4-double-transposition-seedb270/VERIFY.json @@ -0,0 +1,22 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "autoresearch.md", + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json", + "docs/research/community-batch1099-review.md", + "research/bit-three-register-lower-bound/README.md", + "research/community-frontier1094-audit/ASSEMBLY.json", + "research/community-frontier1094-audit/SELECTED-SOURCE.json" + ], + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/verify.py"], + "timeout_seconds": 120, + "checks": "Recompute all 84 involutions, direct formal endpoint, parity controls, both complete radius-three balls, empty intersection and deterministic state hashes; compare the result with CERTIFICATE.json." + } + ] +} diff --git a/research/s4-double-transposition-seedb270/verify.py b/research/s4-double-transposition-seedb270/verify.py new file mode 100644 index 0000000000..31ce443448 --- /dev/null +++ b/research/s4-double-transposition-seedb270/verify.py @@ -0,0 +1,356 @@ +#!/usr/bin/env python3 +"""Exact F2[S4] radius-three test for a two-target double transposition.""" +from __future__ import annotations + +import argparse +import hashlib +import json +import itertools +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +NROLE = 3 +NBITS = 24 +MASK = (1 << NBITS) - 1 +PATH_MASK = (1 << 21) - 1 +BASE = "0b1cccf86e2f5132ed286a26ef0a681a495740ea" +SEED = "b270b3b52d302ab6281ea2bc042d4aea" +SELECTED_SHA256 = "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + + +def need(condition: bool, message: str) -> None: + if not condition: + raise SystemExit("FAIL_S4_DOUBLE_TRANSPOSITION: " + message) + + +def rank_f2(rows: list[int], n: int) -> int: + rows = rows[:] + rank = 0 + for col in range(n): + pivot = next((i for i in range(rank, len(rows)) if (rows[i] >> col) & 1), None) + if pivot is None: + continue + rows[rank], rows[pivot] = rows[pivot], rows[rank] + for i in range(len(rows)): + if i != rank and ((rows[i] >> col) & 1): + rows[i] ^= rows[rank] + rank += 1 + return rank + + +def compose(a: tuple[int, ...], b: tuple[int, ...]) -> tuple[int, ...]: + """Composition a after b, so words extend by right multiplication.""" + return tuple(a[b[i]] for i in range(4)) + + +def mat_from_perm(p: tuple[int, ...]) -> list[int]: + # Column i of the permutation matrix is e_{p[i]}. + rows = [0] * 4 + for col, row in enumerate(p): + rows[row] |= 1 << col + return rows + + +def pack_state(state: tuple[int, ...]) -> bytes: + return b"".join(x.to_bytes(3, "little") for x in state) + + +def unpack_state(key: bytes) -> tuple[int, ...]: + return tuple(int.from_bytes(key[i:i + 3], "little") for i in range(0, 27, 3)) + + +def ring_shift(mask: int, g: int, tables: list[list[list[int]]]) -> int: + return tables[g][0][mask & 255] | tables[g][1][(mask >> 8) & 255] | tables[g][2][(mask >> 16) & 255] + + +def encode_path(parent: int, factor_id: int) -> int: + depth = parent >> 21 + path = parent & PATH_MASK + return ((depth + 1) << 21) | (path << 7) | factor_id + + +def decode_path(encoded: int) -> tuple[int, ...]: + depth = encoded >> 21 + path = encoded & PATH_MASK + return tuple((path >> (7 * (depth - 1 - i))) & 127 for i in range(depth)) + + +def path_depth(encoded: int) -> int: + return encoded >> 21 + + +def build_tables(group: list[tuple[int, ...]], index: dict[tuple[int, ...], int], swaps: list[tuple[int, ...]]): + tables = [] + for s in swaps: + generator = len(tables) + chunks = [] + for byte_pos in range(3): + table = [0] * 256 + for value in range(256): + out = 0 + for bit in range(8): + source_index = byte_pos * 8 + bit + if source_index < len(group) and ((value >> bit) & 1): + out ^= 1 << index[compose(group[source_index], s)] + table[value] = out + chunks.append(table) + tables.append(chunks) + return tables + + +def apply_factor(state: tuple[int, ...], factor: tuple[int, int, int], tables) -> tuple[int, ...]: + g, u, v = factor + out = list(state) + for i in range(NROLE): + z = 0 + for k in range(NROLE): + if (u >> k) & 1: + z ^= state[3 * i + k] + delta = z ^ ring_shift(z, g, tables) + if delta: + for j in range(NROLE): + if (v >> j) & 1: + out[3 * i + j] ^= delta + return tuple(out) + + +def apply_word(start: tuple[int, ...], word: tuple[int, ...], factors, tables) -> tuple[int, ...]: + state = start + for factor_id in word: + state = apply_factor(state, factors[factor_id], tables) + return state + + +def ball(start: tuple[int, ...], radius: int, factors, tables): + # The encoded value stores shortest length and the 7-bit factor IDs. + start_key = pack_state(start) + seen = {start_key: 0} + frontier = [start_key] + layers = [1] + for _depth in range(1, radius + 1): + following = [] + for state_key in frontier: + state = unpack_state(state_key) + parent_code = seen[state_key] + for factor_id, factor in enumerate(factors): + nxt_key = pack_state(apply_factor(state, factor, tables)) + if nxt_key not in seen: + seen[nxt_key] = encode_path(parent_code, factor_id) + following.append(nxt_key) + layers.append(len(following)) + frontier = following + return seen, layers + + +def digest_ball(states: dict[bytes, int]) -> str: + h = hashlib.sha256() + for key in sorted(states): + h.update(key) + return h.hexdigest() + + +def determinant_f2(rows: list[int]) -> int: + # For a 3x3 binary matrix, sum the six permutation monomials in F2. + permutations = ((0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)) + value = 0 + for p in permutations: + term = 1 + for i, j in enumerate(p): + term &= (rows[i] >> j) & 1 + value ^= term + return value + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--write", action="store_true", help="write deterministic CERTIFICATE.json") + args = parser.parse_args() + need((ROOT / "certificates/selected-result.json").is_file(), "repository root not found") + selected = hashlib.sha256((ROOT / "certificates/selected-result.json").read_bytes()).hexdigest() + need(selected == SELECTED_SHA256, "selected record differs from the pinned base") + + group = sorted(itertools.permutations(range(4))) + index = {p: i for i, p in enumerate(group)} + identity_perm = (0, 1, 2, 3) + identity_group = 1 << index[identity_perm] + swaps = [(1, 0, 2, 3), (0, 2, 1, 3), (0, 1, 3, 2)] + target_perm = (2, 3, 0, 1) # (13)(24), a double transposition. + need(compose(target_perm, target_perm) == identity_perm, "target is not an involution") + # Every paid scalar coupling is a rank-one idempotent uv^T over F2. + projectors = [] + for u in range(1, 1 << NROLE): + for v in range(1, 1 << NROLE): + if ((u & v).bit_count() & 1) == 1: + projectors.append((u, v)) + need(len(projectors) == 28, "rank-one idempotent count is not 28") + factors = [(g, u, v) for g in range(3) for u, v in projectors] + need(len(factors) == 84, "paid alphabet is not 84 factors") + tables = build_tables(group, index, swaps) + + # Verify rank-one/idempotent and elementary displacement claims exactly. + for u, v in projectors: + rows = [sum((((u >> i) & 1) * (((v >> j) & 1) << j)) for j in range(3)) for i in range(3)] + need(rank_f2(rows, 3) == 1, "scalar coupling is not rank one") + product = [0] * 3 + for i in range(3): + for k in range(3): + if (rows[i] >> k) & 1: + product[i] ^= rows[k] + need(product == rows, "scalar coupling is not idempotent") + for s in swaps: + rows = mat_from_perm(s) + diff = [rows[i] ^ (1 << i) for i in range(4)] + need(rank_f2(diff, 4) == 1, "adjacent transposition displacement rank is not one") + qrows = mat_from_perm(target_perm) + qdiff = [qrows[i] ^ (1 << i) for i in range(4)] + need(rank_f2(qdiff, 4) == 2, "double-transposition displacement rank is not two") + + identity = tuple(identity_group if i // 3 == i % 3 else 0 for i in range(9)) + target_mask = 1 << index[target_perm] + target = (target_mask, 0, 0, 0, target_mask, 0, 0, 0, identity_group) + + # Every paid factor is involutive, so the target ball reverses all suffixes. + for factor in factors: + need(apply_factor(apply_factor(identity, factor, tables), factor, tables) == identity, + "a paid factor is not an involution") + + # Find a shortest adjacent-transposition word for q by exact BFS on S4. + permutation_words = {identity_perm: ()} + pending = [identity_perm] + for p in pending: + for s_id, s in enumerate(swaps): + nxt = compose(p, s) + if nxt not in permutation_words: + permutation_words[nxt] = permutation_words[p] + (s_id,) + pending.append(nxt) + q_word = permutation_words[target_perm] + need(len(q_word) == 4, "the direct Coxeter cost is not four per target") + factor_lookup = {(g, u, v): fid for fid, (g, u, v) in enumerate(factors)} + direct = tuple( + factor_lookup[(s_id, 1 << role, 1 << role)] + for role in (0, 1) + for s_id in q_word + ) + need(len(direct) == 8 and apply_word(identity, direct, factors, tables) == target, + "direct eight-call construction failed") + for omitted in range(len(direct)): + changed = direct[:omitted] + direct[omitted + 1:] + need(apply_word(identity, changed, factors, tables) != target, + "an omitted direct call still reaches the target") + altered_dirty_target = (target_mask, 0, 0, 0, target_mask, 0, 0, 1 << index[swaps[0]], identity_group) + need(apply_word(identity, direct, factors, tables) != altered_dirty_target, + "changed dirty-role control was not rejected") + + # Sign quotient F2[S4] -> F2[C2]. For rank-one idempotent N, det(I+(x+1)N)=x. + # q is even, so target determinant is 1. Since x has order two, call count is even. + invertible = 0 + for bits in range(1 << 9): + rows = [(bits >> (3 * i)) & 7 for i in range(3)] + if rank_f2(rows, 3) == 3: + invertible += 1 + need(determinant_f2(rows) == 1, "GL3(F2) mixer determinant is not one") + need(invertible == 168, "unexpected GL3(F2) order") + + left, left_layers = ball(identity, 3, factors, tables) + right, right_layers = ball(target, 3, factors, tables) + intersections = [] + for state, left_code in left.items(): + right_code = right.get(state) + if right_code is not None: + intersections.append((path_depth(left_code) + path_depth(right_code), state, left_code, right_code)) + intersections.sort(key=lambda entry: entry[0]) + if intersections: + shortest = intersections[0] + word = decode_path(shortest[2]) + tuple(reversed(decode_path(shortest[3]))) + need(len(word) == shortest[0] and apply_word(identity, word, factors, tables) == target, + "meet-in-the-middle witness does not replay") + exact_minimum = shortest[0] if len(word) % 2 == 0 else None + need(exact_minimum is not None, "odd-length witness contradicts the sign determinant") + else: + word = None + exact_minimum = 8 + + # Count and hash the complete canonical balls. Their size depends only on the + # Cayley action; hashes bind the exact coefficient states independently. + expected_layers = [1, 84, 4697, 232692] + need(left_layers == expected_layers and right_layers == expected_layers, + f"unexpected complete ball layers: {left_layers} / {right_layers}") + certificate = { + "schema_version": 1, + "track": "bit-mechanisms", + "seed": SEED, + "task_id": "bit-new-register-model", + "base_commit": BASE, + "selected_result_sha256": SELECTED_SHA256, + "model": { + "field": "F2", + "address_group": "S4", + "roles": 3, + "active_targets": 2, + "target_permutation": "(13)(24)", + "paid_letters": ["(12)", "(23)", "(34)"], + "rank_one_idempotents": 28, + "paid_factor_count": 84, + "free_scalar_mixing": "all GL3(F2), normalized by augmentation", + "dirty_roles": "all three arbitrary inputs; third role restored exactly", + "endpoint_ring": "formal F2[S4]" + }, + "direct_word": { + "adjacent_transposition_indices": list(q_word), + "paid_call_count": len(direct), + "formal_endpoint_verified": True, + "all_single_call_omissions_rejected": len(direct) + }, + "cost_screen": { + "direct_bill": 8, + "natural_representation_rank_floor": 4, + "sign_determinant_forces_even_length": True, + "best_strict_improvement_bill": 6, + "call_saving_required": 2 + }, + "meet_in_middle": { + "radius_each_side": 3, + "left_layer_counts": left_layers, + "right_layer_counts": right_layers, + "left_state_count": len(left), + "right_state_count": len(right), + "left_sorted_state_sha256": digest_ball(left), + "right_sorted_state_sha256": digest_ball(right), + "intersection_count": len(intersections), + "shortest_meeting_length": intersections[0][0] if intersections else None, + "shortest_word_factor_ids": list(word) if word is not None else None, + "exact_minimum_if_within_six": exact_minimum if exact_minimum is not None else None, + "exact_minimum": exact_minimum, + "all_calls_involutive": True + }, + "controls": { + "all_84_factor_involutions": True, + "all_28_idempotents_rank_one": True, + "all_3_paid_displacements_rank_one": True, + "target_displacement_rank_two": True, + "altered_dirty_role_target_rejected": True, + "gl3_f2_order": invertible, + "gl3_f2_determinants_one": True + }, + "selected_frontier": "unchanged; no supplier or kappa claim", + "runtime_seconds_excluded_from_receipt": True + } + cert_path = PACKAGE / "CERTIFICATE.json" + encoded = json.dumps(certificate, indent=2, sort_keys=True) + "\n" + if args.write: + cert_path.write_text(encoded) + else: + need(cert_path.is_file(), "CERTIFICATE.json missing; run verify.py --write first") + need(cert_path.read_text() == encoded, "deterministic certificate differs; regenerate with --write") + + result = "EXACT_8" if exact_minimum == 8 else f"EXACT_{exact_minimum}" + print(f"PASS_S4_DOUBLE_TRANSPOSITION {result} direct=8 rank_floor=4 parity=even factors=84") + print(f"balls={len(left)},{len(right)} intersections={len(intersections)} layers={left_layers}") + print(f"ball_sha256={certificate['meet_in_middle']['left_sorted_state_sha256'][:16]},{certificate['meet_in_middle']['right_sorted_state_sha256'][:16]}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) From 6237f0d11263c990cf72fa15f95c211b3f6445e5 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:10:43 -0500 Subject: [PATCH 2/4] Record cycle-three coordination and overlap --- .../s4-double-transposition-seedb270/CLAIM.md | 2 +- .../s4-double-transposition-seedb270/README.md | 17 +++++++++-------- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/research/s4-double-transposition-seedb270/CLAIM.md b/research/s4-double-transposition-seedb270/CLAIM.md index e71818cc43..d05de7b144 100644 --- a/research/s4-double-transposition-seedb270/CLAIM.md +++ b/research/s4-double-transposition-seedb270/CLAIM.md @@ -15,4 +15,4 @@ The selector was run from this cycle's exact-base worktree. It discarded seeds `8ccb721845414467f1587f50e18a6252` (consolidation), `1bb2bb9d8fbe33f2d7d4099fb9db95f1` (adversarial-audit) and `72d16ec637edc91f2b0fa7c754335a35` (independent-verification), then accepted the seed above. A previous selector invocation from the separate cycle-2 worktree returned `18291c3ad5e0953d9e5f16c79f345b06` against that PR branch; it was discarded before any experiment because its base was not this cycle's main commit. -GitHub Discussion claim publication is unavailable in the current environment; the local claim and the PR handoff will preserve the scope and result. +The live claim was initially unavailable while the GitHub API was rate-limited. After the fresh Discussion refresh at 08:09 UTC, I posted the completed finding to [coordination Discussion #1163](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18919260). That comment records this seed, base, exact scope, result, evidence and disclosure before PR submission. diff --git a/research/s4-double-transposition-seedb270/README.md b/research/s4-double-transposition-seedb270/README.md index c9c447a2b6..fea882f7a6 100644 --- a/research/s4-double-transposition-seedb270/README.md +++ b/research/s4-double-transposition-seedb270/README.md @@ -121,14 +121,15 @@ package does not claim a new general rank method and imports no predecessor code. PR #1705's GL2 coordinate-SWAP targets and PR #1711's AGL2 affine targets are also distinct. -The live PR scan used REST at 2026-10-14 08:00 UTC and found no S4 -double-transposition claim. The overlap helper could not refresh its PR cache -because the installed `gh api` rejects `--slurp`; the fresh Discussion fetch -was blocked by the GitHub GraphQL rate limit. Its latest complete cached scan -contained 351 records at 07:28 UTC and showed no S4 `(2,2)` target claim. A -fresh claim post was unavailable, so the complete local claim is in -[CLAIM.md](CLAIM.md). It records the exact seed, catalogue revision, base, -selected-record hash, scope, competitors and expiry. +The final PR scan used REST at 2026-10-14 08:09 UTC and covered 415 open PRs; +the only S4 adjacent-transposition match was PR #1720's 4-cycle endpoint, and +no double-transposition claim appeared. The overlap helper could not refresh +its own PR cache because the installed `gh api` rejects `--slurp`, so the REST +census was run directly. A fresh complete Discussion fetch at 08:09 UTC covered +365 records and showed no S4 `(2,2)` target claim. The completed finding was +posted to [coordination Discussion #1163](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18919260). +The full local claim is in [CLAIM.md](CLAIM.md), including the exact seed, +catalogue revision, base, selected-record hash, scope, competitors and expiry. This local model is not physically mapped to the selected bit supplier. The selected baseline remains complex-primitive-bound; physical address From 66a3589e7b81b66c1350ba86071a1b425d54e062 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:13:01 -0500 Subject: [PATCH 3/4] Refresh final S4 overlap evidence --- research/s4-double-transposition-seedb270/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/research/s4-double-transposition-seedb270/README.md b/research/s4-double-transposition-seedb270/README.md index fea882f7a6..66f84bd52b 100644 --- a/research/s4-double-transposition-seedb270/README.md +++ b/research/s4-double-transposition-seedb270/README.md @@ -121,12 +121,12 @@ package does not claim a new general rank method and imports no predecessor code. PR #1705's GL2 coordinate-SWAP targets and PR #1711's AGL2 affine targets are also distinct. -The final PR scan used REST at 2026-10-14 08:09 UTC and covered 415 open PRs; +The pre-submission PR scan used REST at 2026-10-14 08:12 UTC and covered 415 open PRs; the only S4 adjacent-transposition match was PR #1720's 4-cycle endpoint, and no double-transposition claim appeared. The overlap helper could not refresh its own PR cache because the installed `gh api` rejects `--slurp`, so the REST -census was run directly. A fresh complete Discussion fetch at 08:09 UTC covered -365 records and showed no S4 `(2,2)` target claim. The completed finding was +census was run directly. A fresh complete Discussion fetch at 08:12 UTC covered +366 records and showed no S4 `(2,2)` target claim. The completed finding was posted to [coordination Discussion #1163](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18919260). The full local claim is in [CLAIM.md](CLAIM.md), including the exact seed, catalogue revision, base, selected-record hash, scope, competitors and expiry. From 48855b620b23af3a7fe87d53bde05cd2211342c8 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:13:44 -0500 Subject: [PATCH 4/4] Link submitted S4 tariff result --- research/s4-double-transposition-seedb270/CLAIM.md | 2 +- research/s4-double-transposition-seedb270/README.md | 1 + research/s4-double-transposition-seedb270/TASK.json | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/research/s4-double-transposition-seedb270/CLAIM.md b/research/s4-double-transposition-seedb270/CLAIM.md index d05de7b144..fc61a762b7 100644 --- a/research/s4-double-transposition-seedb270/CLAIM.md +++ b/research/s4-double-transposition-seedb270/CLAIM.md @@ -15,4 +15,4 @@ The selector was run from this cycle's exact-base worktree. It discarded seeds `8ccb721845414467f1587f50e18a6252` (consolidation), `1bb2bb9d8fbe33f2d7d4099fb9db95f1` (adversarial-audit) and `72d16ec637edc91f2b0fa7c754335a35` (independent-verification), then accepted the seed above. A previous selector invocation from the separate cycle-2 worktree returned `18291c3ad5e0953d9e5f16c79f345b06` against that PR branch; it was discarded before any experiment because its base was not this cycle's main commit. -The live claim was initially unavailable while the GitHub API was rate-limited. After the fresh Discussion refresh at 08:09 UTC, I posted the completed finding to [coordination Discussion #1163](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18919260). That comment records this seed, base, exact scope, result, evidence and disclosure before PR submission. +The live claim was initially unavailable while the GitHub API was rate-limited. After the fresh Discussion refresh at 08:09 UTC, I posted the completed finding to [coordination Discussion #1163](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18919260), then submitted [PR #1734](https://github.com/CrocSwap/integer-mult-bounds/pull/1734). A final DONE reply records the PR head and remaining obligations. diff --git a/research/s4-double-transposition-seedb270/README.md b/research/s4-double-transposition-seedb270/README.md index 66f84bd52b..a15eea3cb3 100644 --- a/research/s4-double-transposition-seedb270/README.md +++ b/research/s4-double-transposition-seedb270/README.md @@ -130,6 +130,7 @@ census was run directly. A fresh complete Discussion fetch at 08:12 UTC covered posted to [coordination Discussion #1163](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18919260). The full local claim is in [CLAIM.md](CLAIM.md), including the exact seed, catalogue revision, base, selected-record hash, scope, competitors and expiry. +The focused result is submitted as [PR #1734](https://github.com/CrocSwap/integer-mult-bounds/pull/1734). This local model is not physically mapped to the selected bit supplier. The selected baseline remains complex-primitive-bound; physical address diff --git a/research/s4-double-transposition-seedb270/TASK.json b/research/s4-double-transposition-seedb270/TASK.json index f9478aa7fb..1e6b1d3c4d 100644 --- a/research/s4-double-transposition-seedb270/TASK.json +++ b/research/s4-double-transposition-seedb270/TASK.json @@ -52,6 +52,7 @@ "budget_minutes": 60, "stop_rule": "Prove the even-call parity obstruction using the sign determinant over F2[C2], then enumerate the complete radius-three balls from identity and target over all 84 paid involutions. Stop after the exact meet result and direct word; do not widen the group, alphabet, or role count.", "outcome": "negative-result", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/1734", "evidence": "The direct formal endpoint costs 8 calls. The natural F2^4 permutation representation gives only a 4-call rank floor, while the sign determinant forces even length. Complete exact radius-three balls each contain 237474 formal 3x3 F2[S4] states with layers [1,84,4697,232692], hashes 050e8b23a52a22b845208eb0a241872e53511f7843dbf5c6e42b3eda4bc757ac and caf772096918c6a120a394f7f734667e9bf69d67a871f868d4063a848f87827a, and have empty intersection. Thus no word of length at most 6 exists and the exact minimum is 8 in this model. Eight call-omission controls, altered dirty-role control and all 84 factor involution checks pass. No supplier or kappa claim.", "author": "Cinna Davis", "ai_assistance": "Substantial OpenAI Codex assistance in scoping, algebraic proof, exact search implementation, verification and writing. No subagents or independent human review.",