Research: sharp floors for the 216 diagonal S3 targets

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.

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"
+    }
+  ]
+}

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."
+    }
+  ]
+}

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]."
+    }
+  ]
+}

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()