From 835bd7b1877f56d6d9f4eecd7d1ee32f31593e1e Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 21:03:53 -0500 Subject: [PATCH] Research exact Q8 three-role target minima --- .../CERTIFICATE.json | 368 +++++++++++++++ .../README.md | 59 +++ .../SOURCES.json | 78 ++++ .../TASK.json | 92 ++++ .../TASK.md | 13 + .../VERIFY.json | 34 ++ .../verify.py | 423 ++++++++++++++++++ 7 files changed, 1067 insertions(+) create mode 100644 research/q8-r3-two-central-one-generator-seed809fc39d/CERTIFICATE.json create mode 100644 research/q8-r3-two-central-one-generator-seed809fc39d/README.md create mode 100644 research/q8-r3-two-central-one-generator-seed809fc39d/SOURCES.json create mode 100644 research/q8-r3-two-central-one-generator-seed809fc39d/TASK.json create mode 100644 research/q8-r3-two-central-one-generator-seed809fc39d/TASK.md create mode 100644 research/q8-r3-two-central-one-generator-seed809fc39d/VERIFY.json create mode 100644 research/q8-r3-two-central-one-generator-seed809fc39d/verify.py diff --git a/research/q8-r3-two-central-one-generator-seed809fc39d/CERTIFICATE.json b/research/q8-r3-two-central-one-generator-seed809fc39d/CERTIFICATE.json new file mode 100644 index 0000000000..9f0b35cd19 --- /dev/null +++ b/research/q8-r3-two-central-one-generator-seed809fc39d/CERTIFICATE.json @@ -0,0 +1,368 @@ +{ + "cost": { + "candidate_gate_mixed": "at most 4 paid calls, saving at least 1/5 of this local word", + "candidate_gate_triple_central": "at most 5 paid calls, saving at least 1/6 of this local word; parity makes an odd saving length impossible, so a saving requires at most 4", + "direct_calls_mixed": 5, + "direct_calls_triple_central": 6, + "selected_kappa_change": false, + "setup_copy_hosting_precision_restoration_supplier_mapping": "zero in this optimistic formal-model screen; must be separately charged for physical adoption" + }, + "model": { + "dirty_roles": 3, + "equality": "coefficientwise in full F2[Q8]", + "free_scalar_mixing": "normalized; all 168 GL3 conjugations preserve the 28 idempotents", + "group": "Q8={+/-1,+/-i,+/-j,+/-k}", + "paid_generators": 56, + "paid_labels": [ + 1, + 2 + ], + "rank_one_idempotents": 28, + "registers": 3, + "x": 1, + "y": 2, + "z": 4 + }, + "parity_obstructions": { + "diag_z_z_x_or_y": "The x and y coefficient matrices in J/J^2 are E_kk for the one noncentral role and zero for the other label; trace forces odd count of that label and even count of the other, so every realizing word has odd length.", + "diag_z_z_z": "Both first-order coefficient matrices vanish; trace forces even counts of x and y calls, so every realizing word has even length." + }, + "schema_version": 1, + "scope": "Six coordinate permutations of diag([z],[z],[x]) or diag([z],[z],[y]), plus diag([z],[z],[z]), in the stated three-register alphabet; no statement for other labels, groups, roles, or longer words.", + "search": { + "known_diag_z_z_e_depth": 4, + "layer_sha256_sorted_9_byte_states": [ + "8c6a94754fb4364d433e02bca32367314b62f40c15aad5dd88748e5843715742", + "920b43f241039210191338537e0bd917afdd1d4c6ddbab3e31a16d15642b96cf", + "0403597968f6fb572c65e5da6a3edbd9afc2cec41b518afde02b8d6b78183b9c", + "e3f6671475c4ae9bb909dffea5cb05010c6aa8afbb0b3969d0ee471fbc0611b0", + "e4501b88905298a7098da79c9f11e9a1ed595bf41da4e1a3467a8d7addd9b2c0" + ], + "max_depth": 4, + "new_states_by_depth": [ + 1, + 56, + 2324, + 89574, + 3286437 + ], + "raw_extensions_by_depth": [ + 0, + 56, + 3136, + 130144, + 5016144 + ], + "raw_words_lengths_0_to_4": 10013305, + "transition_crosschecks": 952 + }, + "status": "PASS_Q8_EXACT_MIXED_TARGET_FLOORS", + "targets": [ + { + "candidate_word": null, + "deletion_controls": 5, + "diagonal": [ + 1, + 4, + 4 + ], + "direct_calls": 5, + "direct_word": [ + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 4, + 4 + ], + [ + 1, + 4, + 4 + ] + ], + "exact_minimum": 5, + "found_depth": null, + "linear_target_trace_x_mod2": 1, + "linear_target_trace_y_mod2": 0, + "minimum_through_four": true, + "realizing_word_length_mod2": 1 + }, + { + "candidate_word": null, + "deletion_controls": 5, + "diagonal": [ + 4, + 1, + 4 + ], + "direct_calls": 5, + "direct_word": [ + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 4, + 4 + ], + [ + 1, + 4, + 4 + ] + ], + "exact_minimum": 5, + "found_depth": null, + "linear_target_trace_x_mod2": 1, + "linear_target_trace_y_mod2": 0, + "minimum_through_four": true, + "realizing_word_length_mod2": 1 + }, + { + "candidate_word": null, + "deletion_controls": 5, + "diagonal": [ + 4, + 4, + 1 + ], + "direct_calls": 5, + "direct_word": [ + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 4, + 4 + ] + ], + "exact_minimum": 5, + "found_depth": null, + "linear_target_trace_x_mod2": 1, + "linear_target_trace_y_mod2": 0, + "minimum_through_four": true, + "realizing_word_length_mod2": 1 + }, + { + "candidate_word": null, + "deletion_controls": 5, + "diagonal": [ + 2, + 4, + 4 + ], + "direct_calls": 5, + "direct_word": [ + [ + 2, + 1, + 1 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 4, + 4 + ], + [ + 1, + 4, + 4 + ] + ], + "exact_minimum": 5, + "found_depth": null, + "linear_target_trace_x_mod2": 0, + "linear_target_trace_y_mod2": 1, + "minimum_through_four": true, + "realizing_word_length_mod2": 1 + }, + { + "candidate_word": null, + "deletion_controls": 5, + "diagonal": [ + 4, + 2, + 4 + ], + "direct_calls": 5, + "direct_word": [ + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 2, + 2, + 2 + ], + [ + 1, + 4, + 4 + ], + [ + 1, + 4, + 4 + ] + ], + "exact_minimum": 5, + "found_depth": null, + "linear_target_trace_x_mod2": 0, + "linear_target_trace_y_mod2": 1, + "minimum_through_four": true, + "realizing_word_length_mod2": 1 + }, + { + "candidate_word": null, + "deletion_controls": 5, + "diagonal": [ + 4, + 4, + 2 + ], + "direct_calls": 5, + "direct_word": [ + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 2, + 2 + ], + [ + 2, + 4, + 4 + ] + ], + "exact_minimum": 5, + "found_depth": null, + "linear_target_trace_x_mod2": 0, + "linear_target_trace_y_mod2": 1, + "minimum_through_four": true, + "realizing_word_length_mod2": 1 + }, + { + "candidate_word": null, + "deletion_controls": 6, + "diagonal": [ + 4, + 4, + 4 + ], + "direct_calls": 6, + "direct_word": [ + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 2, + 2 + ], + [ + 1, + 4, + 4 + ], + [ + 1, + 4, + 4 + ] + ], + "exact_minimum": 6, + "found_depth": null, + "linear_target_trace_x_mod2": 0, + "linear_target_trace_y_mod2": 0, + "minimum_through_four": true, + "realizing_word_length_mod2": 0 + } + ] +} diff --git a/research/q8-r3-two-central-one-generator-seed809fc39d/README.md b/research/q8-r3-two-central-one-generator-seed809fc39d/README.md new file mode 100644 index 0000000000..6aa6c087fa --- /dev/null +++ b/research/q8-r3-two-central-one-generator-seed809fc39d/README.md @@ -0,0 +1,59 @@ +# Q8 three-role targets retain their direct call bills + +**Scoped exact finite result; no supplier or kappa change.** In the three-register `F2[Q8]` paid-call model, every coordinate permutation of `diag([z],[z],[x])` or `diag([z],[z],[y])` has exact minimum five calls. The all-central target `diag([z],[z],[z])` has exact minimum six. Here `x=i`, `y=j`, and `z=-1=x^2=y^2`. The latter resolves the Q8 predecessor's listed open question about the three-active-role target. + +## Model and cost + +A paid factor is + +`D_N(g) = I + ([g] + [1]) N`, + +where `g` is `x` or `y`, and `N=uv^T` is any binary rank-one idempotent in `M3(F2)`. There are 28 idempotents and 56 paid factors. Equality is coefficientwise in the full eight-element group algebra, so each identity holds for arbitrary dirty contents of all three registers. The check covers free scalar `GL3(F2)` mixing by normalizing it into the paid factors; every one of the 168 conjugations preserves the enumerated idempotent set. No free address maps, clean roles, COPY/ERASE, or unpriced calls are allowed. + +The coordinate construction costs five calls for `diag(z,z,g)` (two calls for each `z`, one for `g`) and six for `diag(z,z,z)`. The search gives no local call saving. The construction cost includes every paid factor; extra setup, hosting, precision, restoration and any physical address-group implementation are set to zero, so it is an optimistic formal screen. The selected bit primitive remains above the complex primitive (`0.001733427039589844...` vs `0.001675462676808103...`), and no mapping of this Q8 model into the selected supplier is known. This result cannot change selected kappa. + +## Exact lower bounds + +The quotient `J/J^2` of the augmentation ideal records the abelianization classes of `x` and `y` as independent `C2` directions. Each `x` factor contributes `N` to the `x` coefficient matrix, and each `y` factor contributes `N` to the `y` coefficient matrix. Every such `N` has trace one over `F2`. + +For `diag(z,z,x)` the first-order trace parities are `(1,0)`; for `diag(z,z,y)` they are `(0,1)`. Thus every word for these targets has odd length. The exhaustive exact state search finds none through length four, while the coordinate word has length five. Their exact minimum is five. + +For `diag(z,z,z)`, both first-order coefficient matrices vanish, so the number of `x` calls and the number of `y` calls are each even. Every realizing word therefore has even length. The exact state search finds no word through length four, and length five is excluded by parity. The six-call coordinate word is optimal. + +The first-order invariant supplies only the parity restriction. The depth-four census is what excludes the remaining shorter words; it is not a claim about other targets or longer words. + +## Exact census and controls + +Breadth-first search starts from the identity matrix and right-multiplies all 56 paid factors. A state is the full 3-by-3 matrix of eight-bit group-algebra coefficients. Equal states have identical continuations, so exact state deduplication preserves complete coverage through depth four. The counts below are new states at each minimum distance; digests hash each sorted layer as concatenated nine-byte states. + +| Depth | New states | SHA-256 | +|---:|---:|---| +| 0 | 1 | `8c6a94754fb4364d433e02bca32367314b62f40c15aad5dd88748e5843715742` | +| 1 | 56 | `920b43f241039210191338537e0bd917afdd1d4c6ddbab3e31a16d15642b96cf` | +| 2 | 2,324 | `0403597968f6fb572c65e5da6a3edbd9afc2cec41b518afde02b8d6b78183b9c` | +| 3 | 89,574 | `e3f6671475c4ae9bb909dffea5cb05010c6aa8afbb0b3969d0ee471fbc0611b0` | +| 4 | 3,286,437 | `e4501b88905298a7098da79c9f11e9a1ed595bf41da4e1a3467a8d7addd9b2c0` | + +The verifier checks Q8 associativity, the `C2 x C2` abelianization map, all rank-one idempotents, all `GL3(F2)` conjugations, and 952 packed-versus-generic matrix transitions. It verifies all seven direct target words, 36 one-call-deletion controls, and the known depth-four `diag(z,z,1)` positive control. The generic matrix multiplier independently checks each direct word and each sampled transition. + +The search represents at most `10,013,305` raw words of lengths zero through four before merging identical product states. The depth-four frontier expands 5,016,144 outgoing transitions. The exact state search and parity proof together establish only the stated minima in this finite alphabet. + +## Reproduce + +From the repository root: + +```sh +python3 -I -B research/q8-r3-two-central-one-generator-seed809fc39d/verify.py +python3 -I -O -B research/q8-r3-two-central-one-generator-seed809fc39d/verify.py +python3 scripts/research_package.py --package research/q8-r3-two-central-one-generator-seed809fc39d --check-only +``` + +Expected verifier status: `PASS_Q8_EXACT_MIXED_TARGET_FLOORS`. The local direct replays use CPython 3.14.7; the registered package manifest targets Python 3.12. The package check pins its exact Q8 predecessor inputs and selected-result provenance. The selected cold replay remains `make frontier1094-verify`; it was not rerun because this contribution does not change the selected construction. + +## Open next questions + +- **Do the `diag(z,z,x/y)` minima remain five for every `r>=3` when additional dirty identity-target roles are allowed?** This would separate the three-role result from the uniform mixed-target bounds already proved for other Q8 profiles. A feasible first step is to derive an `r`-uniform trace/rank lower bound after the `J/J^2` parity step, then identify the first coefficient degree not controlled by parity. The blocker is that the current exact census is only for `r=3`, and the number of rank-one idempotents grows rapidly with `r`. + +## Credit + +The group model and Q8 factor normalization follow the merged Q8 central-pair result in PR #1822 and the mixed-target result in PR #1925. The `diag(z,z,z)` endpoint was explicitly left open in the Q8 predecessor package. PR #2047 and Discussion #2034 concern one central output with two order-four outputs, a different role profile. Prepared by Cinna Davis with substantial OpenAI Codex assistance; no independent human review is claimed. The repository contribution is Apache-2.0. diff --git a/research/q8-r3-two-central-one-generator-seed809fc39d/SOURCES.json b/research/q8-r3-two-central-one-generator-seed809fc39d/SOURCES.json new file mode 100644 index 0000000000..22d7dd17fd --- /dev/null +++ b/research/q8-r3-two-central-one-generator-seed809fc39d/SOURCES.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "AGENTS.md", + "usage": "provenance", + "git_blob": "1dce1b16a687a5d1a507ef64b9d4da19dd9e43f9", + "sha256": "5378ffbf3a119fcd0c23bcce20f34e5dd2fa792a00a0033e47667aeba72bbc37" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "git_blob": "9b6cbfef0fb725f28c177038d32f482706e12c94", + "sha256": "79d0c8be61d90dd6c46b6e7250e0c88713d29854128d8d1361b6343682dad1d8" + }, + { + "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" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "provenance", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "provenance", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/q8-central-commutator-pair/CERTIFICATE.json", + "usage": "input", + "git_blob": "2c805c49d2133888d0d433f482a5efbab7a8f6c9", + "sha256": "6e902e479aef695c8c7be18a9a5a1e02a6d19568ed695e4506ff16bef0048be5" + }, + { + "path": "research/q8-central-commutator-pair/README.md", + "usage": "input", + "git_blob": "7a6277dc860ea5440ab39b06160c337f93353357", + "sha256": "ee819ee843e1a93d7d320d02ccd5f47af0d912295de9d9c379ccc22c90093948" + }, + { + "path": "research/q8-central-commutator-pair/TASK.json", + "usage": "input", + "git_blob": "a409c338353b8018e2219e7100ebc148d53bc19a", + "sha256": "27fff88664837b87ce32b449e72a858af0b8c089039714322b584e0a62e81137" + } + ] +} diff --git a/research/q8-r3-two-central-one-generator-seed809fc39d/TASK.json b/research/q8-r3-two-central-one-generator-seed809fc39d/TASK.json new file mode 100644 index 0000000000..262b95abdd --- /dev/null +++ b/research/q8-r3-two-central-one-generator-seed809fc39d/TASK.json @@ -0,0 +1,92 @@ +{ + "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": "refined", + "actual_scope": "Exact minima in F2[Q8], with three arbitrary dirty scalar roles, all rank-one idempotents in M3(F2), and paid labels x=i,y=j: six coordinate permutations of diag([z],[z],[x]) or diag([z],[z],[y]), plus diag([z],[z],[z]), where z=-1=x^2=y^2. Equality is coefficientwise in the full eight-element group algebra.", + "scope_change_reason": "The card permits a specified nonabelian address group. This run refines the Q8 result to a different target-role profile: two central outputs and one order-four output, then answers the predecessor package open question for three central outputs. These targets differ from the earlier two-central-plus-identity and one-central-plus-two-order-four cases.", + "bottleneck_link": "Exact local bit-call minima constrain this nonabelian call model. The result gives no selected-supplier mapping or local saving; the selected complex primitive remains binding, so there is no kappa change.", + "budget_minutes": 60, + "stop_rule": "Complete coefficientwise BFS over all 56 factors through depth four; use the first-order trace parity to exclude the only remaining length for diag(z,z,z); stop at exact minima or a verified shorter witness. Do not extend to other groups, labels, roles, or lengths.", + "outcome": "negative-result", + "evidence": "CERTIFICATE.json records exact state-layer counts/digests and target minima; verify.py replays the exact BFS, checks Q8 and GL3 controls, generic transition comparisons, direct positive controls, and call-deletion controls.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance; the Q8 model is attributed to merged PR #1822 and PR #1925; no independent human review is claimed.", + "open_questions": [ + { + "question": "Do the diag(z,z,x/y) minima remain five for every r>=3 with additional dirty identity-target roles?", + "why_it_matters": "A uniform result would extend this exact role profile beyond the three-register case and separate its cost from the other uniform Q8 mixed-target bound.", + "first_step": "Use the J/J^2 trace parity first, then derive a dimension-independent rank bound at the first coefficient degree where parity is silent.", + "blocked_by": "The current exact census is only for r=3; the rank-one alphabet grows rapidly with r." + } + ], + "selector": { + "accepted_seed": "809fc39d62870d18f94dd48473f46972", + "track": "bit-mechanisms", + "discarded_seeds": [ + "32a7d05d2b903f5daacf986466a79cec", + "b32046774b2ca700559da2da0f578f15", + "0ec44474f0ad98eef1b5a45d2cdcec1f" + ], + "priority_revision": 4, + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "refined_scope_key": "7f5f4426ef796683c485/Q8-r3-two-central-one-generator-through-4", + "task_id": "bit-new-register-model", + "selected_record_review": "docs/research/community-batch1099-review.md", + "selected_source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "selected_assembly_certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "selected_reproduction": "make frontier1094-verify", + "overlap_refresh": { + "open_prs": 478, + "open_prs_fetched_at_utc": "2026-10-15T02:02:52Z", + "open_prs_complete_pagination": true, + "discussions": 952, + "discussions_fetched_at_utc": "2026-10-15T02:02:40Z", + "discussions_complete_pagination": true, + "warnings": [], + "exact_target_query": "No exact target-profile predecessor beyond the own claim #2243; adjacent Q8 PR #2047 is one central plus two order-four outputs." + } + }, + "chosen_method": "Construct the smallest exact identity in a newly specified legal operation alphabet; refined to the Q8 three-role target profiles and a complete exact depth-four search." +} diff --git a/research/q8-r3-two-central-one-generator-seed809fc39d/TASK.md b/research/q8-r3-two-central-one-generator-seed809fc39d/TASK.md new file mode 100644 index 0000000000..55122a575e --- /dev/null +++ b/research/q8-r3-two-central-one-generator-seed809fc39d/TASK.md @@ -0,0 +1,13 @@ +# Cycle AF task card — Q8 three-role target minima + +- **Track / accepted seed / task:** `bit-mechanisms` / `809fc39d62870d18f94dd48473f46972` / `bit-new-register-model`. +- **Rejected draws:** `32a7d05d2b903f5daacf986466a79cec` (`adversarial-audit`); `b32046774b2ca700559da2da0f578f15` and `0ec44474f0ad98eef1b5a45d2cdcec1f` (`independent-verification`). +- **Priority revision / catalogue SHA-256:** 4 / `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`. +- **Exact base / selected-record SHA-256:** `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2` / `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- **Selected chain:** review `docs/research/community-batch1099-review.md`; source manifest `research/community-frontier1094-audit/SELECTED-SOURCE.json`; assembly certificate `research/community-frontier1094-audit/ASSEMBLY.json`; cold replay `make frontier1094-verify`. `research_baseline.py` passed bindings-only; complex is the binding primitive. +- **Refined object:** In `F2[Q8]`, `x=i`, `y=j`, `z=-1`, all 28 rank-one idempotents and paid labels `{x,y}`. Find exact minima for all coordinate permutations of `diag(z,z,x)` and `diag(z,z,y)` at three arbitrary dirty roles. One evidence-driven pivot also closes the predecessor's listed `diag(z,z,z)` endpoint. +- **Optimistic bill:** coordinate bills 5, 5 and 6. Each paid factor costs one; no clean roles, free address maps, COPY/ERASE, setup, hosting, precision, restoration, or supplier mapping. A local saving would require at most 4 calls for every target. No selected kappa can follow without a supplier translation and improvement of the currently nonbinding bit primitive. +- **Method / stopping rule:** exact coefficientwise BFS over distinct full `F2[Q8]` matrix products through depth four, followed by a trace-parity lower bound; stop at complete layer-four coverage. No claim for other groups, labels, roles or longer words. +- **Result:** exact minima are 5 for the six mixed maps and 6 for `diag(z,z,z)`. The direct coordinate words attain; the depth-four certificate excludes shorter words. +- **Nearest overlap:** merged PR #1822 (Q8 central pair), merged PR #1925 (one extra role for mixed targets), open PR #2047 (one central plus two order-four targets for all `r>=3`), and the expired adjacent claims in Discussions #2034 and #1997. Active Discussion #1999 uses the binary tetrahedral group; current A5 Discussion #2242 / PR #2246 uses another group and target. The final refresh at 2026-10-15 02:02 UTC covered 478 open PRs and 952 Discussions with complete pagination and no warnings. The exact Q8 query found only the claim in #2243 and those adjacent Q8 scopes, not this target pattern. +- **Expected artifact:** exact verifier, layer digests, parity proof and source pins; no physical supplier, new bound, or kappa. diff --git a/research/q8-r3-two-central-one-generator-seed809fc39d/VERIFY.json b/research/q8-r3-two-central-one-generator-seed809fc39d/VERIFY.json new file mode 100644 index 0000000000..6c77a3ccc6 --- /dev/null +++ b/research/q8-r3-two-central-one-generator-seed809fc39d/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/q8-central-commutator-pair/CERTIFICATE.json", + "research/q8-central-commutator-pair/README.md", + "research/q8-central-commutator-pair/TASK.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Exact Q8 table, coefficientwise state BFS to depth four, layer counts and sorted-state digests, GL3 conjugation closure, abelianization parity, generic matrix-product cross-checks, direct target controls and certificate equality." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Repeat the exact coefficientwise verifier under optimized Python; require identical layer digests, minima and certificate." + } + ] +} diff --git a/research/q8-r3-two-central-one-generator-seed809fc39d/verify.py b/research/q8-r3-two-central-one-generator-seed809fc39d/verify.py new file mode 100644 index 0000000000..db6618b739 --- /dev/null +++ b/research/q8-r3-two-central-one-generator-seed809fc39d/verify.py @@ -0,0 +1,423 @@ +#!/usr/bin/env python3 +"""Exact depth-four word search for a mixed Q8 three-register target.""" +from __future__ import annotations + +import hashlib +import itertools +import json +from pathlib import Path +import sys + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +CERTIFICATE = PACKAGE / "CERTIFICATE.json" + + +def require(condition: bool, message: str) -> None: + if not condition: + raise RuntimeError(message) + + +def q8_tables(): + # Hamilton basis order 1, i, j, k; signs occupy the high bit of each index. + basis = [ + (1, 0, 0, 0), + (0, 1, 0, 0), + (0, 0, 1, 0), + (0, 0, 0, 1), + ] + elements = basis + [tuple(-x for x in q) for q in basis] + to_index = {q: i for i, q in enumerate(elements)} + + def hamilton(a, b): + a0, a1, a2, a3 = a + b0, b1, b2, b3 = b + return ( + a0*b0 - a1*b1 - a2*b2 - a3*b3, + a0*b1 + a1*b0 + a2*b3 - a3*b2, + a0*b2 - a1*b3 + a2*b0 + a3*b1, + a0*b3 + a1*b2 - a2*b1 + a3*b0, + ) + + table = [[to_index[hamilton(a, b)] for b in elements] for a in elements] + require(table[1][1] == 4 and table[2][2] == 4, "i^2 and j^2 must be -1") + require(table[1][2] == 3 and table[2][1] == 7, "ij=k and ji=-k") + require(all(table[4][g] == (g ^ 4) and table[g][4] == (g ^ 4) for g in range(8)), "-1 must be central") + for a, b, c in itertools.product(range(8), repeat=3): + require(table[table[a][b]][c] == table[a][table[b][c]], "Q8 associativity") + return elements, table + + +def mul_mask(left: int, right: int, table) -> int: + out = 0 + for a in range(8): + if (left >> a) & 1: + for b in range(8): + if (right >> b) & 1: + out ^= 1 << table[a][b] + return out + + +def right_times_generator_plus_one(mask: int, generator: int, table) -> int: + out = mask + for a in range(8): + if (mask >> a) & 1: + out ^= 1 << table[a][generator] + return out + + +def rankone_idempotents(): + result = [] + for u in range(1, 8): + for v in range(1, 8): + if ((u & v).bit_count() & 1) == 1: + result.append((u, v)) + require(len(result) == 28, "M3(F2) must have 28 rank-one idempotents") + return result + + +def mat_mul2(left, right): + out = [] + for row in left: + acc = 0 + for k in range(3): + if (row >> k) & 1: + acc ^= right[k] + out.append(acc) + return tuple(out) + + +def rank2(rows): + rows = list(rows) + r = 0 + for c in range(3): + pivot = next((i for i in range(r, 3) if (rows[i] >> c) & 1), None) + if pivot is None: + continue + rows[r], rows[pivot] = rows[pivot], rows[r] + for i in range(3): + if i != r and ((rows[i] >> c) & 1): + rows[i] ^= rows[r] + r += 1 + return r + + +def inverse2(rows): + aug = [rows[i] | (1 << (3+i)) for i in range(3)] + r = 0 + for c in range(3): + pivot = next((i for i in range(r, 3) if (aug[i] >> c) & 1), None) + if pivot is None: + return None + aug[r], aug[pivot] = aug[pivot], aug[r] + for i in range(3): + if i != r and ((aug[i] >> c) & 1): + aug[i] ^= aug[r] + r += 1 + return tuple((row >> 3) & 7 for row in aug) + + +def check_gl3_closure(idempotents): + ns = {tuple(v if ((u >> i) & 1) else 0 for i in range(3)) + for u, v in idempotents} + gl = [] + for rows in itertools.product(range(8), repeat=3): + if rank2(rows) == 3: + inv = inverse2(rows) + require(inv is not None, "invertible matrix lacked inverse") + gl.append((rows, inv)) + require(len(gl) == 168, "GL3(F2) order mismatch") + for s, sinv in gl: + for n in ns: + require(mat_mul2(mat_mul2(s, n), sinv) in ns, + "rank-one idempotent alphabet not closed under GL3 conjugation") + return len(gl) + + +def pack_matrix(matrix): + out = 0 + for i, row in enumerate(matrix): + for j, value in enumerate(row): + out |= value << (8 * (3*i+j)) + return out + + +def unpack_matrix(state): + return [[(state >> (8*(3*i+j))) & 255 for j in range(3)] for i in range(3)] + + +def identity_matrix(): + return [[1 if i == j else 0 for j in range(3)] for i in range(3)] + + +def target_matrix(diagonal): + out = [[0, 0, 0] for _ in range(3)] + for i, group_element in enumerate(diagonal): + out[i][i] = 1 << group_element + return out + + +def generic_matrix_product(left, right, table): + out = [[0, 0, 0] for _ in range(3)] + for i in range(3): + for j in range(3): + for k in range(3): + out[i][j] ^= mul_mask(left[i][k], right[k][j], table) + return out + + +def gate_matrix(descriptor): + generator, u, v = descriptor + a = 1 ^ (1 << generator) + out = identity_matrix() + for i in range(3): + if (u >> i) & 1: + for j in range(3): + if (v >> j) & 1: + out[i][j] ^= a + return out + + +def generic_word(word, table): + result = identity_matrix() + for descriptor in word: + result = generic_matrix_product(result, gate_matrix(descriptor), table) + return result + + +def fast_step(state, descriptor, shifts): + generator, u, v = descriptor + out = state + rows_u = [k for k in range(3) if (u >> k) & 1] + cols_v = [j for j in range(3) if (v >> j) & 1] + for i in range(3): + coefficient = 0 + for k in rows_u: + coefficient ^= (state >> (8 * (3*i+k))) & 255 + delta = shifts[generator][coefficient] + if delta: + for j in cols_v: + out ^= delta << (8 * (3*i+j)) + return out + + +def digest_states(states): + h = hashlib.sha256() + for state in sorted(states): + h.update(state.to_bytes(9, "little")) + return h.hexdigest() + + +def path_to(state, depth, parents): + path = [] + for d in range(depth, 0, -1): + previous, generator_index = parents[d][state] + path.append(generator_index) + state = previous + return list(reversed(path)) + + +def direct_word(diagonal): + # Coordinate projectors: two x calls make z=x^2; one produces x or y. + x = 1 + word = [] + for i, g in enumerate(diagonal): + if g == 4: + u = v = 1 << i + word.extend([(x, u, v), (x, u, v)]) + elif g in (1, 2): + u = v = 1 << i + word.append((g, u, v)) + else: + raise ValueError("direct witness covers only z,z and x/y targets") + return word + + +def run_search(): + _elements, table = q8_tables() + x, y, z = 1, 2, 4 + ns = rankone_idempotents() + gl3_order = check_gl3_closure(ns) + abelianization = [(0, 0), (1, 0), (0, 1), (1, 1), + (0, 0), (1, 0), (0, 1), (1, 1)] + require(all(abelianization[table[a][b]] == + (abelianization[a][0] ^ abelianization[b][0], + abelianization[a][1] ^ abelianization[b][1]) + for a in range(8) for b in range(8)), + "Q8 abelianization map to C2 x C2 is not a homomorphism") + generators = [(g, u, v) for g in (x, y) for u, v in ns] + require(len(generators) == 56, "paid alphabet size mismatch") + shifts = [[0] * 256 for _ in range(8)] + for g in range(8): + for mask in range(256): + shifts[g][mask] = right_times_generator_plus_one(mask, g, table) + + target_specs = [] + for g in (x, y): + for diagonal in sorted(set(itertools.permutations((z, z, g)))): + target_specs.append((g, diagonal, pack_matrix(target_matrix(diagonal)))) + target_specs.append((None, (z, z, z), pack_matrix(target_matrix((z, z, z))))) + require(len(target_specs) == 7, "expected six mixed maps plus the triple-central pivot") + target_by_state = {state: (g, diagonal) for g, diagonal, state in target_specs} + targets = set(target_by_state) + + identity = pack_matrix(identity_matrix()) + known_control = pack_matrix(target_matrix((z, z, 0))) + seen = {identity} + frontier = {identity} + parents = {} + layer_counts = [1] + layer_digests = [digest_states(frontier)] + raw_extensions = [0] + witnesses = {} + target_depths = {} + control_depth = 0 if identity == known_control else None + + for depth in range(1, 5): + next_layer = set() + parent_layer = {} + extensions = len(frontier) * len(generators) + for state in sorted(frontier): + for gen_index, descriptor in enumerate(generators): + candidate = fast_step(state, descriptor, shifts) + if candidate not in seen: + seen.add(candidate) + next_layer.add(candidate) + if depth < 4: + parent_layer[candidate] = (state, gen_index) + if candidate in targets and candidate not in witnesses: + witness_indices = path_to(state, depth-1, parents) + witness_indices.append(gen_index) + witnesses[candidate] = witness_indices + target_depths[candidate] = depth + if candidate == known_control and control_depth is None: + control_depth = depth + parents[depth] = parent_layer + frontier = next_layer + layer_counts.append(len(frontier)) + layer_digests.append(digest_states(frontier)) + raw_extensions.append(extensions) + print(f"depth={depth} new_states={len(frontier)} raw_extensions={extensions}", file=sys.stderr, flush=True) + + require(layer_counts[:4] == [1, 56, 2324, 89574], + f"Q8 predecessor layer control mismatch: {layer_counts[:4]}") + require(control_depth == 4, "known Q8 diag(z,z,e) depth-four control failed") + + # Check fast transitions against generic noncommutative group-algebra matrix products. + samples = [identity, *sorted(seen)[:8], *sorted(frontier)[:8]] + transition_checks = 0 + for state in samples: + matrix = unpack_matrix(state) + for descriptor in generators: + expected = pack_matrix(generic_matrix_product(matrix, gate_matrix(descriptor), table)) + require(fast_step(state, descriptor, shifts) == expected, + "packed transition differs from generic F2[Q8] multiplication") + transition_checks += 1 + + results = [] + for g, diagonal, target in target_specs: + word = direct_word(diagonal) + expected_direct_calls = sum(2 if label == z else 1 for label in diagonal) + require(len(word) == expected_direct_calls, "coordinate baseline call count mismatch") + require(pack_matrix(generic_word(word, table)) == target, + "five-call coordinate positive control failed") + deletion_controls = 0 + for remove in range(len(word)): + shortened = word[:remove] + word[remove+1:] + require(pack_matrix(generic_word(shortened, table)) != target, + "a one-call deletion unexpectedly preserved the direct target") + deletion_controls += 1 + linear_x = sum(abelianization[label][0] for label in diagonal) & 1 + linear_y = sum(abelianization[label][1] for label in diagonal) & 1 + length_parity = linear_x ^ linear_y + entry = { + "diagonal": list(diagonal), + "direct_calls": len(word), + "direct_word": [list(item) for item in word], + "minimum_through_four": target not in seen, + "found_depth": target_depths.get(target), + "linear_target_trace_x_mod2": linear_x, + "linear_target_trace_y_mod2": linear_y, + "realizing_word_length_mod2": length_parity, + "exact_minimum": None, + "candidate_word": None, + "deletion_controls": deletion_controls, + } + if target not in seen: + exact_minimum = 5 if length_parity else 6 + require(len(word) == exact_minimum, + "BFS/parity lower bound does not match the coordinate upper bound") + entry["exact_minimum"] = exact_minimum + else: + entry["exact_minimum"] = target_depths[target] + if target in witnesses: + ids = witnesses[target] + candidate_word = [generators[i] for i in ids] + require(len(candidate_word) == target_depths[target], "witness length mismatch") + require(pack_matrix(generic_word(candidate_word, table)) == target, + "candidate witness fails independent generic product") + entry["candidate_word"] = [list(item) for item in candidate_word] + results.append(entry) + + result = { + "schema_version": 1, + "status": "PASS_Q8_EXACT_MIXED_TARGET_FLOORS", + "model": { + "group": "Q8={+/-1,+/-i,+/-j,+/-k}", + "x": x, + "y": y, + "z": z, + "registers": 3, + "dirty_roles": 3, + "rank_one_idempotents": len(ns), + "paid_generators": len(generators), + "paid_labels": [x, y], + "equality": "coefficientwise in full F2[Q8]", + "free_scalar_mixing": "normalized; all 168 GL3 conjugations preserve the 28 idempotents", + }, + "search": { + "max_depth": 4, + "raw_words_lengths_0_to_4": sum(56**i for i in range(5)), + "raw_extensions_by_depth": raw_extensions, + "new_states_by_depth": layer_counts, + "layer_sha256_sorted_9_byte_states": layer_digests, + "known_diag_z_z_e_depth": control_depth, + "transition_crosschecks": transition_checks, + }, + "targets": results, + "parity_obstructions": { + "diag_z_z_x_or_y": "The x and y coefficient matrices in J/J^2 are E_kk for the one noncentral role and zero for the other label; trace forces odd count of that label and even count of the other, so every realizing word has odd length.", + "diag_z_z_z": "Both first-order coefficient matrices vanish; trace forces even counts of x and y calls, so every realizing word has even length.", + }, + "scope": "Six coordinate permutations of diag([z],[z],[x]) or diag([z],[z],[y]), plus diag([z],[z],[z]), in the stated three-register alphabet; no statement for other labels, groups, roles, or longer words.", + "cost": { + "direct_calls_mixed": 5, + "direct_calls_triple_central": 6, + "candidate_gate_mixed": "at most 4 paid calls, saving at least 1/5 of this local word", + "candidate_gate_triple_central": "at most 5 paid calls, saving at least 1/6 of this local word; parity makes an odd saving length impossible, so a saving requires at most 4", + "setup_copy_hosting_precision_restoration_supplier_mapping": "zero in this optimistic formal-model screen; must be separately charged for physical adoption", + "selected_kappa_change": False, + }, + } + return result + + +def main(): + write = len(sys.argv) == 2 and sys.argv[1] == "--write" + if len(sys.argv) > 2 or (len(sys.argv) == 2 and not write): + raise SystemExit("usage: verify.py [--write]") + result = run_search() + encoded = json.dumps(result, indent=2, sort_keys=True) + "\n" + if write: + CERTIFICATE.write_text(encoded) + else: + require(CERTIFICATE.is_file(), "CERTIFICATE.json missing; generate with --write") + expected = CERTIFICATE.read_text() + require(expected == encoded, "recomputed result differs from CERTIFICATE.json") + print(result["status"]) + print("targets=" + ",".join(str(x["diagonal"]) + ":min=" + str(x["exact_minimum"]) for x in result["targets"])) + print("layers=" + str(result["search"]["new_states_by_depth"])) + + +if __name__ == "__main__": + main()