From fe0419b0b2b24e996479625d45d0d22146071b25 Mon Sep 17 00:00:00 2001 From: pinterbanget Date: Thu, 22 Oct 2026 17:30:29 +0700 Subject: [PATCH] =?UTF-8?q?Partially=20check=20#4603's=20query-shear=20flo?= =?UTF-8?q?or:=20exact=20Laurent=20identity,=2015=20disjoint=20ADD/IDLE=20?= =?UTF-8?q?windows=20in=20the=20pinned=20controller,=20merge=20saving=200.?= =?UTF-8?q?70=20<=201=20(no=20new=20=CE=BA)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- research/pr4603-shear-floor-check/README.md | 46 +++++++ .../pr4603-shear-floor-check/SOURCES.json | 24 ++++ research/pr4603-shear-floor-check/TASK.json | 100 +++++++++++++++ research/pr4603-shear-floor-check/VERIFY.json | 22 ++++ research/pr4603-shear-floor-check/verify.py | 115 ++++++++++++++++++ 5 files changed, 307 insertions(+) create mode 100644 research/pr4603-shear-floor-check/README.md create mode 100644 research/pr4603-shear-floor-check/SOURCES.json create mode 100644 research/pr4603-shear-floor-check/TASK.json create mode 100644 research/pr4603-shear-floor-check/VERIFY.json create mode 100644 research/pr4603-shear-floor-check/verify.py diff --git a/research/pr4603-shear-floor-check/README.md b/research/pr4603-shear-floor-check/README.md new file mode 100644 index 0000000000..78875380de --- /dev/null +++ b/research/pr4603-shear-floor-check/README.md @@ -0,0 +1,46 @@ +# Partial independent check of #4603's query-shear floor + +**Task:** independent-moment (independent check). **Base:** canonical main `f626db5c`. **No κ is claimed.** + +## The claim + +Matarener's #4603 (head `caab2b42`) argues that the 15 query-only shears of the p16 controllers cannot be removed by three routes: fusion, lazy central frames, or cheap gather-type native words. + +## What is checked here + +Three of its statements are checked independently. Nothing is imported from #4603. + +1. **Exact identity.** S_x(−Q)·S_y(Q⁻¹) = signed_swap·diag(Q⁻¹, Q)·S_x(Q), with: + - S_x(a) = [[1, a], [0, 1]] and S_y(b) = [[1, 0], [b, 1]]; + - signed_swap = [[0, −1], [1, 0]]. + + This is checked by exact symbolic Laurent-polynomial arithmetic, and the product equals [[0, −Q], [Q⁻¹, 1]]. A wrong-sign control is rejected. +2. **The premise of the window bound,** on main's pinned complex `CONTROLLER.json`: + - each of the 15 QUERY_SHEAR events on pair j is preceded, since the last LOCAL event on pair j, by **only ADD and IDLE** events; + - the 15 windows [that LOCAL, the shear] are pairwise disjoint. + + Hence any scheme that pays at least 1 per window pays at least 15, which the controller attains. An inserted SIGNED_SWAP is detected as a control. +3. **The merge bound.** Merging one query's 112 rank-one jobs into 14 rank-eight jobs saves 112 − 14·8^(1−0.0030202) ≈ **0.701 < 1** unit of paid moment, as stated. + +## Verify + +```text +python3 -B research/pr4603-shear-floor-check/verify.py +``` + +The check takes about 1 s and uses the standard library only. + +## Limitations + +**Not re-checked:** + +- #4603's fusion-rank statement (part 1); +- the distinct-query-line census; +- the BIT controller's windows (only the complex controller is checked here); +- the parity model's cost rules themselves (this package checks the window premise those rules use). + +## Open next questions + +- **Fusion composites.** Recompute #4603's Q-coefficient ranks with an independent Laurent-matrix engine, then repeat the window premise for the retained BIT controller. First step: locate the BIT controller's event list among main's records. + +Credit: Matarener (Mark) for #4603; 1337isnot1337 / Cinna Davis (#4440, #4470) and zxv for the controllers. Prepared by Ryanson Jonathan with substantial Claude Code (Claude Opus 5.5) assistance. diff --git a/research/pr4603-shear-floor-check/SOURCES.json b/research/pr4603-shear-floor-check/SOURCES.json new file mode 100644 index 0000000000..ee9a881cd5 --- /dev/null +++ b/research/pr4603-shear-floor-check/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "f626db5c3a3d781d8f7695038776c621651f75e1", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/joint-helper-lattice/CONTROLLER.json", + "usage": "input", + "git_blob": "49a2f0675819f9deeea27ed77be2c2b6ff2e87e5", + "sha256": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f" + } + ] +} diff --git a/research/pr4603-shear-floor-check/TASK.json b/research/pr4603-shear-floor-check/TASK.json new file mode 100644 index 0000000000..4fb18f0dd4 --- /dev/null +++ b/research/pr4603-shear-floor-check/TASK.json @@ -0,0 +1,100 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 7, + "base_commit": "f626db5c3a3d781d8f7695038776c621651f75e1", + "original_card": { + "id": "independent-moment", + "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged-fourth-mixture-ceiling/README.md", + "research/r437-two-window-carrier/README.md" + ], + "methods": [ + "Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.", + "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Calling an aggregate histogram or source archive an independently accepted physical supplier." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering", + "4088", + "4091", + "4067", + "staged544-mixed-fourth-entry", + "staged-fourth-mixture-ceiling", + "r437-two-window-carrier" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "unchanged", + "actual_scope": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "scope_change_reason": null, + "bottleneck_link": "Independent partial coverage of #4603's negative result on removing p16 query shears.", + "budget_minutes": 30, + "stop_rule": "Stop at the identity, window premise and merge bound.", + "outcome": "completed", + "evidence": "Exact Laurent identity S_x(-Q)S_y(Q^-1) = swap diag(Q^-1,Q) S_x(Q); 15 disjoint ADD/IDLE-only windows from each pair's full call to its shear in the pinned complex controller; merge saving 0.701 < 1; controls (wrong sign, inserted SIGNED_SWAP).", + "author": "Ryanson Jonathan, with Claude Code (Claude Opus 5.5) assistance", + "ai_assistance": "Substantial Claude Code (Claude Opus 5.5) assistance; no independent human review.", + "open_questions": [ + { + "question": "Fusion Q-coefficient ranks and BIT windows.", + "why_it_matters": "Remaining parts of #4603.", + "first_step": "Independent Laurent-matrix engine over the controller blocks.", + "blocked_by": "None." + } + ] +} diff --git a/research/pr4603-shear-floor-check/VERIFY.json b/research/pr4603-shear-floor-check/VERIFY.json new file mode 100644 index 0000000000..112d7b0a64 --- /dev/null +++ b/research/pr4603-shear-floor-check/VERIFY.json @@ -0,0 +1,22 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json", + "research/joint-helper-lattice/CONTROLLER.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact Laurent identity with control; window premise on pinned complex controller with control; merge saving bound." + } + ] +} diff --git a/research/pr4603-shear-floor-check/verify.py b/research/pr4603-shear-floor-check/verify.py new file mode 100644 index 0000000000..1838c46ce7 --- /dev/null +++ b/research/pr4603-shear-floor-check/verify.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Independent check of three statements in PR #4603 (Matarener, head caab2b42): p16 query-only shears. + +#4603 argues that the 15 query-only shears of the p16 controllers cannot be removed by lazy central frames or cheap +gather words. Independently of its code (nothing imported), this verifier checks: + 1. the exact identity S_x(-Q) S_y(Q^-1) = signed_swap * diag(Q^-1, Q) * S_x(Q), with S_x(a) = [[1,a],[0,1]], + S_y(b) = [[1,0],[b,1]], signed_swap = [[0,-1],[1,0]], over Laurent monomials in Q (exact symbolic arithmetic + on {exponent: coefficient} polynomials); + 2. the premise of its window bound on main's pinned complex controller: each of the 15 QUERY_SHEAR events on pair j + is preceded, since the last LOCAL event on pair j, only by ADD and IDLE events (no SIGNED_SWAP or other LOCAL); + the 15 windows [that LOCAL, the shear] are pairwise disjoint; so any scheme paying >= 1 per window pays >= 15, + which the controller attains with exactly 15 shears; + 3. merging the 112 rank-one shear jobs of one query into 14 rank-eight jobs saves under one unit of paid moment at + the current root t = 1 - 0.0030202 (112 - 14 * 8^t < 1), as stated. +The fusion-rank statement (part 1 of #4603) and the distinct-query-line census are not re-checked. +Ryanson Jonathan with Claude Code (Claude Opus 5.5) assistance. Apache-2.0. +""" +from collections import Counter +from decimal import Decimal as D, getcontext +import json +from pathlib import Path +import sys + +ROOT = Path(__file__).resolve().parents[2] +getcontext().prec = 40 + + +def need(condition, message): + if not condition: + raise AssertionError(message) + + +def padd(a, b): + out = Counter(a) + for k, v in b.items(): + out[k] += v + return {k: v for k, v in out.items() if v} + + +def pmul(a, b): + out = Counter() + for i, x in a.items(): + for j, y in b.items(): + out[i + j] += x * y + return {k: v for k, v in out.items() if v} + + +def mmul(x, y): + return [[padd(pmul(x[i][0], y[0][j]), pmul(x[i][1], y[1][j])) for j in range(2)] for i in range(2)] + + +ONE, ZERO = {0: 1}, {} + + +def mono(e, c=1): + return {e: c} + + +def identity_check(): + sx = lambda a: [[ONE, a], [ZERO, ONE]] + sy = lambda b: [[ONE, ZERO], [b, ONE]] + lhs = mmul(sx(mono(1, -1)), sy(mono(-1))) + swap = [[ZERO, mono(0, -1)], [ONE, ZERO]] + diag = [[mono(-1), ZERO], [ZERO, mono(1)]] + rhs = mmul(mmul(swap, diag), sx(mono(1))) + need(lhs == rhs, "S_x(-Q) S_y(Q^-1) = signed_swap diag(Q^-1,Q) S_x(Q)") + need(lhs == [[ZERO, mono(1, -1)], [mono(-1), ONE]], "explicit product") + need(mmul(sx(mono(1)), sy(mono(-1))) != rhs, "control: wrong sign is detected") + + +def window_check(): + row = json.loads((ROOT / "research/joint-helper-lattice/CONTROLLER.json").read_text(encoding="utf-8")) + events = row["physical_events"] + windows = [] + for i, e in enumerate(events): + if e[0] != "QUERY_SHEAR": + continue + pair = e[2] + k = i - 1 + while not (events[k][0] == "LOCAL" and events[k][2] == pair): + need(events[k][0] in ("ADD", "IDLE"), "only ADD/IDLE between the pair's full call and its shear") + k -= 1 + windows.append((k, i)) + need(len(windows) == 15, "15 query-only shears") + need(all(a[1] < b[0] for a, b in zip(windows, windows[1:])), "windows pairwise disjoint") + # control: inserting a SIGNED_SWAP into the first window breaks the premise + k, i = windows[0] + broken = events[:k + 1] + [["SIGNED_SWAP", 0, 1]] + events[k + 1:] + j = i + ok = True + while not (broken[j][0] == "LOCAL" and broken[j][2] == broken[i + 1][2]): + ok &= broken[j][0] in ("ADD", "IDLE", "QUERY_SHEAR") + j -= 1 + need(not ok, "control: an inserted SIGNED_SWAP is detected") + return windows + + +def merge_check(): + t = 1 - D("0.0030202") + saving = 112 - 14 * (D(8).ln() * t).exp() + need(0 < saving < 1, "112 rank-one -> 14 rank-eight saves under one unit") + return saving + + +def main(): + identity_check() + windows = window_check() + saving = merge_check() + print(json.dumps({"status": "PASS_PR4603_PARTIAL_CHECK", "identity": True, "windows": windows, + "window_lower_bound": 15, "controller_shears": 15, "merge_saving": str(saving)[:10], + "new_kappa_claimed": False}, indent=1)) + + +if __name__ == "__main__": + sys.exit(main())