From 580670ad5ea25be4f65cf2473396abe8c42dc2fe Mon Sep 17 00:00:00 2001 From: Riquelme Soares <104222380+hevlyo@users.noreply.github.com> Date: Wed, 21 Oct 2026 09:06:11 -0300 Subject: [PATCH] Classify the sharp diagonal floors in the paid S3 alphabet. One hundred twenty-five of the 216 targets meet the representation rank with a coordinate word, and eight of them have sharp floor 6. --- research/s3-diagonal-rank-screen/README.md | 72 +++++++ research/s3-diagonal-rank-screen/SOURCES.json | 24 +++ research/s3-diagonal-rank-screen/TASK.json | 64 ++++++ research/s3-diagonal-rank-screen/VERIFY.json | 18 ++ research/s3-diagonal-rank-screen/verify.py | 182 ++++++++++++++++++ 5 files changed, 360 insertions(+) create mode 100644 research/s3-diagonal-rank-screen/README.md create mode 100644 research/s3-diagonal-rank-screen/SOURCES.json create mode 100644 research/s3-diagonal-rank-screen/TASK.json create mode 100644 research/s3-diagonal-rank-screen/VERIFY.json create mode 100644 research/s3-diagonal-rank-screen/verify.py diff --git a/research/s3-diagonal-rank-screen/README.md b/research/s3-diagonal-rank-screen/README.md new file mode 100644 index 0000000000..bb7d255229 --- /dev/null +++ b/research/s3-diagonal-rank-screen/README.md @@ -0,0 +1,72 @@ +# Sharp floors for the 216 diagonal S3 targets + +**Finite screen in one nonabelian alphabet; no new kappa.** The selected +record is unchanged. + +## Scope + +Chooser seed `69b1df962b206506adae7d9b1954dd8f` drew `r437-carrier-integration` +on priority revision 7, base `12fa8c5c844be21bfefb38a19503fbd867a11244`. +That card's compiler, caller and stock obligations are already open in #4176 +and #4183, and #4147 already gives the reverse coefficient 1123650. This +package takes the next suggestion, `bit-new-register-model`, at the screening +question left by open #3893. + +The paid alphabet is the same one: labels `s = (1 2)` and `t = (2 3)`, and +the 28 rank-one idempotents are not needed for the coordinate words below. +The two-dimensional representation is the one stated in that PR, + +```text +rho(s) = [[1, 1], [0, 1]], rho(t) = [[1, 0], [1, 1]]. +``` + +A coordinate word writes one register at a time. Its length is the sum of the +generator lengths. The representation rank of a diagonal target is the sum of +`rank(rho(g) + I)`. Equality makes that coordinate word sharp. + +## What is established + +Generator length and represented rank agree on five of the six group elements. +They disagree only on the transposition `(1 3) = (2, 1, 0)`, which has length +3 and represented rank 1. + +Eight diagonal S3 targets, those whose three labels all lie in the two length-two elements, have representation rank 6 and a six-call coordinate word. One hundred twenty-five of the 216 diagonal targets match in the same way. + +The other 91 targets each contain `(1 3)`. Their generator bill exceeds the +rank bound by 2 for every copy of that label, so this comparison does not +prove those bills sharp. The published target `diag(s, t, st)` remains one of +the 36 sharp floors of 4; its four-call word is rechecked here and is not +claimed as new. The new maximum is 6, on exactly the eight targets with every +label in `{st, ts}`. + +## Reproduce + +Python 3.12, standard library only, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/s3-diagonal-rank-screen +``` + +Expected marker: `PASS_S3_DIAGONAL_RANK_SCREEN matched=125 floor6=8 gap=91`. + +## Limits + +No shared-word search for `(1 3)`, no native implementation, and no transfer +to the rational-frame three-register theorem. The selected baseline was not +run in this partial checkout. No selected-frontier change is claimed. + +## Open next questions + +Can a shared word shorter than length 3 write `(1 3)` on one register in this +same paid alphabet? A one-register word cannot, because the reduced generator +length is 3. A first step is to allow one specified scratch register and +search length 2. No such scratch contract is pinned here. + +## Credit + +The alphabet, representation and four-call target are from the open package +`research/bit-s3-three-register-rank-target-seed57b2` (#3893). The +three-register rational-frame bound is the catalogue starting point and is +not replayed. Riquelme Soares (@hevlyo), with substantial AI assistance in +the classification and write-up. Apache-2.0. No independent human review is +claimed. diff --git a/research/s3-diagonal-rank-screen/SOURCES.json b/research/s3-diagonal-rank-screen/SOURCES.json new file mode 100644 index 0000000000..f401d210f6 --- /dev/null +++ b/research/s3-diagonal-rank-screen/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "provenance", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + } + ] +} diff --git a/research/s3-diagonal-rank-screen/TASK.json b/research/s3-diagonal-rank-screen/TASK.json new file mode 100644 index 0000000000..cd4e0ee4b3 --- /dev/null +++ b/research/s3-diagonal-rank-screen/TASK.json @@ -0,0 +1,64 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "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. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "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": "For which of the 216 diagonal three-register targets in the paid S3 alphabet of open PR #3893 does the two-dimensional representation rank equal the direct generator bill, and what is the largest sharp floor?", + "scope_change_reason": "The drawn card was r437-carrier-integration. Its compiler, caller and reverse-coefficient stock obligations are already open in #4176 and #4183, and #4147 already derived the coefficient 1123650. This package takes the next suggestion and the screening question left by open #3893: the same S3 alphabet, every diagonal target, without a new construction round.", + "bottleneck_link": "A sharp floor above the published four-call target would be a stronger obstruction inside this nonabelian alphabet. A gap between generator length and represented rank shows where that obstruction is not yet sharp.", + "budget_minutes": 60, + "stop_rule": "Stop after classifying all 216 diagonal targets and checking the coordinate words that meet the rank bound. Do not search shared words for the gapped transposition.", + "outcome": "completed", + "evidence": "Every label except the transposition (13) has generator length equal to rank(rho(g)+I). Exactly 125 of 216 triples match, and the coordinate concatenation attains the bound for each of them. Eight triples, all labels in the two length-two elements, have sharp floor 6. The transposition (13) has length 3 and represented rank 1, so the other 91 triples are not sharp by this comparison.", + "author": "Riquelme Soares (@hevlyo)", + "ai_assistance": "Substantial AI assistance was used for the classification, the group-algebra check and the write-up. No independent human review is claimed.", + "open_questions": [ + { + "question": "Can a shared word shorter than length 3 write the transposition (13) on one register in this same paid alphabet?", + "why_it_matters": "That element is the only label whose generator length exceeds its represented rank. A shorter word would lower the direct bill of every triple that contains it.", + "first_step": "Search words in the two paid labels whose product is (13), allowing more than one register of scratch, and stop at the first word shorter than 3 or at an exhaustive length-2 miss.", + "blocked_by": "A one-register word cannot be shorter than 3, and no legal scratch register is specified by the #3893 alphabet." + } + ] +} diff --git a/research/s3-diagonal-rank-screen/VERIFY.json b/research/s3-diagonal-rank-screen/VERIFY.json new file mode 100644 index 0000000000..ac967cdcf4 --- /dev/null +++ b/research/s3-diagonal-rank-screen/VERIFY.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Rebuilds the S3 representation, checks the published four-call control, classifies all 216 diagonal targets, and multiplies every matching coordinate word in F2[S3]." + } + ] +} diff --git a/research/s3-diagonal-rank-screen/verify.py b/research/s3-diagonal-rank-screen/verify.py new file mode 100644 index 0000000000..c7a7424bb5 --- /dev/null +++ b/research/s3-diagonal-rank-screen/verify.py @@ -0,0 +1,182 @@ +"""Screen all 216 diagonal targets in the paid two-generator S3 alphabet.""" + +from collections import deque +from itertools import permutations, product +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +LEMMA = ( + "Eight diagonal S3 targets, those whose three labels all lie in the two " + "length-two elements, have representation rank 6 and a six-call coordinate " + "word. One hundred twenty-five of the 216 diagonal targets match in the same way." +) + + +def require(ok, why): + if not ok: + raise SystemExit(why) + + +def rank(matrix): + rows = [list(row) for row in matrix] + pivot_row = 0 + for col in range(len(rows[0])): + pivot = next((i for i in range(pivot_row, len(rows)) if rows[i][col] & 1), None) + if pivot is None: + continue + rows[pivot_row], rows[pivot] = rows[pivot], rows[pivot_row] + for i in range(len(rows)): + if i != pivot_row and rows[i][col] & 1: + rows[i] = [x ^ y for x, y in zip(rows[i], rows[pivot_row])] + pivot_row += 1 + if pivot_row == len(rows): + break + return pivot_row + + +def mul2(left, right): + return tuple(tuple(sum(left[i][k] * right[k][j] for k in range(2)) & 1 + for j in range(2)) for i in range(2)) + + +def compose(later, earlier): + return tuple(later[earlier[i]] for i in range(3)) + + +def zero_matrix(): + return [[0, 0, 0] for _ in range(3)] + + +def identity_matrix(identity_index): + out = zero_matrix() + for i in range(3): + out[i][i] = 1 << identity_index + return out + + +def algebra_mul(left, right, table): + out = 0 + for a in range(6): + if (left >> a) & 1: + for b in range(6): + if (right >> b) & 1: + out ^= 1 << table[a][b] + return out + + +def matrix_mul(left, right, table): + out = zero_matrix() + for i in range(3): + for j in range(3): + value = 0 + for k in range(3): + value ^= algebra_mul(left[i][k], right[k][j], table) + out[i][j] = value + return out + + +def paid(label, projector, identity_index): + out = identity_matrix(identity_index) + delta = (1 << label) ^ (1 << identity_index) + for i in range(3): + for j in range(3): + if projector[i][j]: + out[i][j] ^= delta + return out + + +def diagonal(labels): + out = zero_matrix() + for i, label in enumerate(labels): + out[i][i] = 1 << label + return out + + +def main(): + require(LEMMA in (PACKAGE / "README.md").read_text(encoding="utf-8"), "README dropped the lemma") + group = sorted(permutations(range(3))) + index = {item: i for i, item in enumerate(group)} + identity = (0, 1, 2) + s = (1, 0, 2) + t = (0, 2, 1) + generators = (s, t) + eye = ((1, 0), (0, 1)) + rho = {identity: eye} + pending = [identity] + while pending: + current = pending.pop() + for generator, matrix in ((s, ((1, 1), (0, 1))), (t, ((1, 0), (1, 1)))): + nxt = compose(current, generator) + image = mul2(rho[current], matrix) + if nxt in rho: + require(rho[nxt] == image, "representation drift") + else: + rho[nxt] = image + pending.append(nxt) + require(len(set(map(tuple, rho.values()))) == 6, "representation is not faithful") + table = [[index[compose(left, right)] for right in group] for left in group] + identity_index = index[identity] + + def plus(element): + return tuple(tuple(rho[element][i][j] ^ eye[i][j] for j in range(2)) for i in range(2)) + + length = {identity: 0} + steps = {identity: ()} + queue = deque([identity]) + while queue: + current = queue.popleft() + for generator in generators: + nxt = compose(current, generator) + if nxt not in length: + length[nxt] = length[current] + 1 + steps[nxt] = steps[current] + (generator,) + queue.append(nxt) + + def represented_rank(element): + return rank(plus(element)) + + gap = (2, 1, 0) + require(length[gap] == 3 and represented_rank(gap) == 1, "transposition gap changed") + length_two = tuple(element for element in group if length[element] == 2) + require(len(length_two) == 2, "expected two length-two elements") + for element in length_two: + require(represented_rank(element) == 2, "length-two rank changed") + + projectors = tuple(tuple(tuple(int(i == row and j == row) for j in range(3)) + for i in range(3)) for row in range(3)) + matched = 0 + floor_six = 0 + for labels in product(group, repeat=3): + direct = sum(length[label] for label in labels) + bound = sum(represented_rank(label) for label in labels) + if direct != bound: + require(gap in labels, "gap without the long transposition") + continue + matched += 1 + word = [] + for register, label in enumerate(labels): + for generator in steps[label]: + word.append((index[generator], projectors[register])) + state = identity_matrix(identity_index) + for label_index, projector in word: + state = matrix_mul(state, paid(label_index, projector, identity_index), table) + require(state == diagonal(tuple(index[label] for label in labels)), "coordinate word missed") + if bound == 6: + floor_six += 1 + require(set(labels) <= set(length_two), "floor 6 left the length-two set") + require(matched == 125 and floor_six == 8, "classification counts changed") + + # Published four-call control: diag(s, t, st) with st = s then t. + st = compose(s, t) + published = [(index[s], projectors[0]), (index[t], projectors[1]), + (index[s], projectors[2]), (index[t], projectors[2])] + state = identity_matrix(identity_index) + for label_index, projector in published: + state = matrix_mul(state, paid(label_index, projector, identity_index), table) + require(state == diagonal((index[s], index[t], index[st])), "published witness drifted") + require(length[s] + length[t] + length[st] == 4, "published bill is not 4") + print("PASS_S3_DIAGONAL_RANK_SCREEN matched=125 floor6=8 gap=91") + + +if __name__ == "__main__": + main()