Research: staged544 helpers 600 and 601 are not signed-proportional

research/staged544-helper600-sign-columns/README.md

@@ -0,0 +1,96 @@
+# Signed columns of staged544 helpers 600 and 601
+
+**Negative result. No new kappa.** The selected record is unchanged.
+
+## Scope
+
+The drawn catalogue card was `p104-side-correction`. Its named experiment, one
+collection from #2981 with acquisition times, coefficients and dirty
+restoration, is already open for flag 0 in #3915, #3669 and #3683. The same
+present-head scan covers flags 1, 9 and 43, so another flag pass is the
+card's pending-follow-up trigger.
+
+The next catalogue suggestion is `complex-rank-shape-decoder`. Its ideal
+rank-16 screen already clears 5% in `levers.py`, and repacking the selected
+word's idle remainder is a scope-change trigger of that card. The live handoff
+in discussion 1166, comment 19038903, names a smaller unclaimed test on the
+same alphabet that #4045 just bound: whether the complete consumer columns of
+actual helpers 600 and 601 are signed-proportional under one common native
+frame. This package runs that test. It does not emit a capture.
+
+## What is established
+
+Both frozen PR3945 words used by #4045 (`91afbb643f7f4ccf6f34b685ecd959eb790a0f94`)
+carry the same consumer adds for helpers 600, 601, 602 and 604. Each helper is
+read by exactly seven `add` events. The only frame common to the 600 and 601
+reads is `(45,)`, and on that frame the consumers are exactly 123, 175, 183
+and 202, each with coefficient ±1.
+
+In that consumer order the columns are
+
+| helper | 123 | 175 | 183 | 202 |
+| --- | ---: | ---: | ---: | ---: |
+| 600 | -1 | +1 | +1 | -1 |
+| 601 | +1 | +1 | +1 | +1 |
+| 602 | -1 | +1 | +1 | +1 |
+| 604 | -1 | -1 | +1 | -1 |
+
+On both frozen PR3945 words, the frame-(45,) consumer columns of helpers 600 and 601 are neither equal nor opposite.
+
+The same split holds for every pair among the four helpers: each pair agrees
+on some of these consumers and disagrees on others. A capture that needs one
+global sign, as in the H6 same-frame sum/difference of #4048, therefore does
+not apply to this group. Flipping the two disagreeing entries of column 601
+makes it equal to column 600, so the checker is not rejecting every pattern.
+
+The two word files are not identical. Their SHA-256 values are
+`08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0` and
+`d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299`, matching
+git blobs `806784bf99d9d15004d2d227d06268556a0726c8` and
+`c531be7383ad3ba941600c7ced14e5e10d6d1c67` at the #4045 head. Only the named
+consumer columns were compared.
+
+## Reproduce
+
+Python 3.12, standard library only, from the repository root:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/staged544-helper600-sign-columns
+```
+
+The direct check also works without Git:
+
+```sh
+python3.12 -B research/staged544-helper600-sign-columns/verify.py
+```
+
+Expected marker: `PASS_STAGED544_HELPER600_SIGN_COLUMNS`.
+
+## Limits
+
+This does not rerun the #4045 support obstruction, the #4031 rank-4 screen, or
+the #4048 H6 lattice. It does not price a partial capture, a nonmonomial
+encoder, or any other helper pair. Adds where these helpers are destinations
+are productions, not consumer columns, and are not part of the sign test.
+No supplier, hosting bill, or selected-frontier change is claimed. The selected
+baseline replay was not run: this checkout does not contain the assembly roots
+that `research_baseline.py` imports.
+
+## Open next questions
+
+Can a capture that keeps the disagreeing consumers 123 and 202, and merges
+only the agreeing consumers 175 and 183, reduce the complete child and
+restoration bill? Those two consumers already share a sign, but the other two
+do not, so both helpers stay necessary. A first step is to price one explicit
+partial capture of consumers 175 and 183, including cleanup, against the
+0.03825 allowance in #4045. No such map is exhibited here.
+
+## Credit
+
+Dugongue / #3945 supplies the two words. Chris R / Clear1nsight / #4045
+identifies helpers 600, 601, 602 and 604 and the rank-16 support obstruction.
+Tekalign / #4048 supplies the same-frame signed-capture idea that this test
+refuses to transfer. Gonzalo Mier / #4031 supplies the zero-charge screen
+#4045 already separated from this interface. Riquelme Soares (@hevlyo), with
+substantial AI assistance in the extraction, checker and write-up. Apache-2.0.
+No independent human review is claimed.

research/staged544-helper600-sign-columns/SOURCES.json

@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    }
+  ]
+}

research/staged544-helper600-sign-columns/TASK.json

@@ -0,0 +1,72 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-rank-shape-decoder",
+  "priority_revision": 6,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "original_card": {
+    "id": "complex-rank-shape-decoder",
+    "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/complex-local-word-ceiling/README.md",
+      "research/complex-decoder-field-extension-seed44/README.md",
+      "research/complex-frame-pair-decoders/README.md",
+      "research/selected-k8-unrestricted-ends/README.md",
+      "research/eisenstein-reduction-copy-floor/README.md"
+    ],
+    "methods": [
+      "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.",
+      "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration."
+    ],
+    "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound. 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",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).",
+    "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.",
+    "allowed_variations": [
+      "One masked, overcomplete or block decoder family with exact labels and supports.",
+      "A scoped lower bound on effective rank for one alphabet.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Repacking idle remainders of an unchanged word (covered by the packing ceiling).",
+      "Repeating the eight-term all-pairs search inside its proved scope.",
+      "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.",
+      "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder.",
+      "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."
+    ],
+    "overlap_terms": [
+      "rank shape",
+      "block climb",
+      "masked decoder",
+      "overcomplete",
+      "effective rank"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "On the actual PR3945 consumer columns of helpers 600 and 601, is there one common native frame where the two coefficient columns are equal or opposite?",
+  "scope_change_reason": "The drawn card was p104-side-correction. Its named first experiment, one #2981 collection with times, coefficients and dirty restoration, is already open for flag 0 in #3915, #3669 and #3683, and the same present-head scanner covers flags 1, 9 and 43. Repeating that scan is the card's pending-follow-up trigger. The second suggestion is this rank-shape card. Its ideal rank-16 ceiling already clears the 5% screen in levers.py, and repacking the selected word's idle remainder is a stated scope-change trigger. The live handoff at discussion 1166 comment 19038903 names an unclaimed test on this same alphabet: signed proportionality of the complete consumer columns of actual helpers 600 and 601. This package runs that test and stops.",
+  "bottleneck_link": "Helpers 600 and 601 are two of the four actual rank-4 climbs whose one-call rank-16 transfer is already blocked. A same-frame signed capture would be a copy saving on that fixed alphabet. If their consumer columns are not equal or opposite, that capture cannot replace either climb, so the group's effective child rank stays four rank-4 calls.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop when every consumer add of helpers 600 and 601 on both frozen words is classified at its frame. Do not emit a capture, retimed provider or search of other helpers.",
+  "outcome": "negative-result",
+  "evidence": "Both frozen words, SHA-256 08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0 and d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299, give the same frame-(45,) columns. In consumer order 123,175,183,202 the signs are 600=(-1,+1,+1,-1) and 601=(+1,+1,+1,+1). Both ratios +1 and -1 occur, so no single sign matches them. The same split occurs for every pair among 600,601,602,604. A one-entry sign flip of 601 makes it equal to 600, so the checker is not vacuously negative.",
+  "author": "Riquelme Soares (@hevlyo)",
+  "ai_assistance": "Substantial AI assistance was used for the overlap check, column extraction, verifier and write-up. No independent human review is claimed.",
+  "open_questions": [
+    {
+      "question": "Can a capture that keeps the disagreeing consumers 123 and 202, and merges only the agreeing consumers 175 and 183, reduce the complete child and restoration bill?",
+      "why_it_matters": "Those two consumers already have the same sign on helpers 600 and 601, but the other two do not, so a full-column capture is impossible. A partial merge would still leave both helpers alive.",
+      "first_step": "Price one explicit partial capture of consumers 175 and 183 only, including its cleanup, and compare it with the 0.03825 allowance recorded by PR4045.",
+      "blocked_by": "No such partial map is exhibited, and both helpers remain necessary for consumers 123 and 202."
+    }
+  ]
+}

research/staged544-helper600-sign-columns/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": "Hashes both frozen words, reconstructs every consumer add of helpers 600 and 601, rejects a single sign on frame (45,), and accepts the one-entry sign-flip control."
+    }
+  ]
+}

research/staged544-helper600-sign-columns/verify.py

@@ -0,0 +1,100 @@
+"""Consumer-column sign test for staged544 helpers 600 and 601."""
+
+import gzip
+import hashlib
+import json
+from pathlib import Path
+
+PACKAGE = Path(__file__).resolve().parent
+HELPERS = (600, 601, 602, 604)
+FRAME = (45,)
+ORDER = (123, 175, 183, 202)
+SIGNS = {
+    600: (-1, 1, 1, -1),
+    601: (1, 1, 1, 1),
+    602: (-1, 1, 1, 1),
+    604: (-1, -1, 1, -1),
+}
+HASHES = {
+    "WORD-base.json.gz": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0",
+    "WORD-extra.json.gz": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299",
+}
+LEMMA = (
+    "On both frozen PR3945 words, the frame-(45,) consumer columns of "
+    "helpers 600 and 601 are neither equal nor opposite."
+)
+
+
+def require(ok, why):
+    if not ok:
+        raise SystemExit(why)
+
+
+def load_word(name):
+    raw = (PACKAGE / "frozen" / name).read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == HASHES[name], "word hash changed: " + name)
+    return json.loads(gzip.decompress(raw))
+
+
+def consumer_adds(word, helper):
+    found = []
+    for section, rows in word.items():
+        if not isinstance(rows, list):
+            continue
+        for index, row in enumerate(rows):
+            if not isinstance(row, list) or not row or row[0] != "add":
+                continue
+            require(len(row) >= 6, "short add")
+            if row[2] == helper:
+                require(isinstance(row[3], int), "non-integer coefficient")
+                require(isinstance(row[5], list), "frame is not a list")
+                found.append((section, index, row[1], row[3], tuple(row[5])))
+    return found
+
+
+def frame_column(adds, frame):
+    column = {}
+    for _section, _index, destination, coefficient, row_frame in adds:
+        if row_frame == frame:
+            column[destination] = column.get(destination, 0) + coefficient
+    require(set(column) == set(ORDER), "frame-(45,) consumers changed")
+    return tuple(column[destination] for destination in ORDER)
+
+
+def single_sign(left, right):
+    ratios = []
+    for x, y in zip(left, right):
+        require(x != 0 and y != 0 and abs(x) == abs(y), "column is not a sign pattern")
+        ratios.append(y // x)
+    return len(set(ratios)) == 1
+
+
+def main():
+    require(LEMMA in (PACKAGE / "README.md").read_text(encoding="utf-8"), "README dropped the lemma")
+    columns = []
+    for name in HASHES:
+        word = load_word(name)
+        one = {}
+        for helper in HELPERS:
+            adds = consumer_adds(word, helper)
+            require(len(adds) == 7, "expected 7 consumer adds for " + str(helper))
+            column = frame_column(adds, FRAME)
+            require(column == SIGNS[helper], "frame column changed for " + str(helper))
+            one[helper] = column
+        columns.append(one)
+    require(columns[0] == columns[1], "the two words disagree on these columns")
+    require(not single_sign(SIGNS[600], SIGNS[601]), "600 and 601 unexpectedly match")
+    for left in HELPERS:
+        for right in HELPERS:
+            if left < right:
+                require(not single_sign(SIGNS[left], SIGNS[right]), "pair unexpectedly matches")
+    flipped = (1, 1, 1, -1)
+    # Consumers 123 and 202 are the disagreements. Flipping both makes 601 equal 600.
+    repaired = (-1, 1, 1, -1)
+    require(repaired == SIGNS[600] and single_sign(SIGNS[600], repaired), "sign-flip control failed")
+    require(not single_sign(SIGNS[600], flipped), "partial flip must stay unmatched")
+    print("PASS_STAGED544_HELPER600_SIGN_COLUMNS")
+
+
+if __name__ == "__main__":
+    main()