Independently recompute #4610's raw crossing in 50-digit Decimal from the pinned controller: 0.00302155511 inside its bracket, PR4535 root reproduced (no new κ)

research/pr4610-crossing-recompute/README.md

@@ -0,0 +1,57 @@
+# Independent recomputation of #4610's raw crossing
+
+**Task:** independent-moment (independent check). **Base:** canonical main `f626db5c`. **No κ is claimed.**
+
+## The claim
+
+intqwq's #4610 (head `4b4c75bc`) inserts its changed paid list into the retained p16 controller:
+
+```text
+Pnew = 2201 H1 + 412 H2 + 506 H3 + 135 H4 + 36 H5 + 8 H8,    helpers unchanged: 28 H4 + 7 H7 + 47 H8 + 326 H9.
+```
+
+It claims a raw crossing in (0.0030215551, 0.0030215552) and selects κ = 0.00302152. My #4614 checked #4610's endpoint frames and profile arithmetic but left this crossing open.
+
+## Method
+
+The two histograms are rebuilt from main's pinned `research/joint-helper-lattice/CONTROLLER.json`:
+
+| event | charge |
+|---|---|
+| LOCAL | adds the helper list to the targets and the local paid list to the paid histogram |
+| QUERY_SHEAR | paid[1] += 112 |
+| IDLE with s retained stages | paid[8s] += 224 |
+| each diagonal term | targets[1 + 8·Σ term] += 112 |
+
+The root of Σ_T n·r^(1−c) = Σ_P n·r^(1−c) is then found by bisection in **50-digit Decimal** arithmetic. This engine differs from #4610's Fraction intervals, and nothing is imported from #4610.
+
+## Results
+
+| profile | raw root | paid calls | rank-mass surplus |
+|---|---|---|---|
+| Pnew (#4610) | **0.00302155511144…** | 64,404 | 752 |
+| Pold (PR4535), control | 0.00302016597701… | 64,620 | 752 |
+
+- **The bracket holds.** The new root lies inside #4610's bracket (0.0030215551, 0.0030215552).
+- **Control.** The old list reproduces PR4535's root.
+- **κ selection.** κ = ⌊root·10⁸⌋ − 3 gives 302152·10⁻⁸ = 0.00302152, which matches.
+- **Failure control.** Dropping the idle charges moves the root far above the bracket. The idle windows are therefore genuinely charged.
+
+## Verify
+
+```text
+python3 -B research/pr4610-crossing-recompute/verify.py
+```
+
+The check takes under 1 s and uses the standard library only.
+
+## Limitations
+
+- **Arithmetic only.** This re-derives the arithmetic from root to κ selection, assuming #4610's local paid list and the retained controller semantics.
+- **Not re-checked here:** the 54 strict outer-ledger inequalities, native phase lowering, the Lean certificates, and the contract admissibility of generator substitution. My #4614 covers the endpoint frames and profile.
+
+## Open next questions
+
+- **Outer ledger.** Re-evaluate the 54 strict outer-ledger checks with an independent engine at #4610's parameters. First step: port `compiler-refill/endpoint.py`'s inequalities to Decimal.
+
+Credit: intqwq (#4610), Cinna Davis (#4470) and the controller lineage. Prepared by Ryanson Jonathan with substantial Claude Code (Claude Opus 5.5) assistance.

research/pr4610-crossing-recompute/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"
+    }
+  ]
+}

research/pr4610-crossing-recompute/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 recomputation of the newest kappa claim's (#4610) raw crossing.",
+  "budget_minutes": 30,
+  "stop_rule": "Stop at the raw crossing and kappa selection.",
+  "outcome": "completed",
+  "evidence": "50-digit Decimal root from main's CONTROLLER.json with Pnew: 0.00302155511144... inside (0.0030215551, 0.0030215552); Pold control reproduces 0.00302016597701...; paid calls 64,404/64,620; surplus 752; kappa = floor(root*1e8)-3 = 302152e-8; idle-dropping control inflates root.",
+  "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": "Outer ledger (54 strict checks) at the new parameters with an independent engine.",
+      "why_it_matters": "Last arithmetic link from root to kappa.",
+      "first_step": "Re-evaluate the compiler-refill ledger's strict checks in Decimal at #4610's parameter set.",
+      "blocked_by": "None."
+    }
+  ]
+}

research/pr4610-crossing-recompute/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": "Histograms from pinned CONTROLLER.json; 50-digit Decimal root for Pnew inside #4610 bracket; Pold control; paid calls; surplus; kappa selection; idle-dropping failure control."
+    }
+  ]
+}

research/pr4610-crossing-recompute/verify.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Independent 50-digit recomputation of PR #4610's raw crossing (intqwq, head 4b4c75bc).
+
+#4610 claims that its changed paid list Pnew = 2201 H1 + 412 H2 + 506 H3 + 135 H4 + 36 H5 + 8 H8 (helpers unchanged:
+28 H4 + 7 H7 + 47 H8 + 326 H9), inserted into the retained p16 controller, moves the raw crossing of the complete
+target and paid moments into (0.0030215551, 0.0030215552), and selects kappa = 0.00302152.
+This verifier rebuilds both histograms from main's pinned research/joint-helper-lattice/CONTROLLER.json:
+    LOCAL event: targets += helpers, paid += local list;  QUERY_SHEAR: paid[1] += 112;
+    IDLE with s retained stages: paid[8 s] += 224;  each diagonal term: targets[1 + 8 * sum(term[1:])] += 112,
+and solves sum_T n r^(1-c) = sum_P n r^(1-c) by bisection in 50-digit Decimal arithmetic (a different engine from
+#4610's Fraction intervals; nothing imported from #4610). The old list Pold must reproduce PR4535's root
+0.0030201659770... as a control; paid-call counts and the rank-mass surplus are also 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]
+CONTROLLER = ROOT / "research/joint-helper-lattice/CONTROLLER.json"
+HELPERS = {4: 28, 7: 7, 8: 47, 9: 326}
+P_NEW = {1: 2201, 2: 412, 3: 506, 4: 135, 5: 36, 8: 8}
+P_OLD = {1: 2237, 2: 388, 3: 494, 4: 147, 5: 36, 8: 8}
+getcontext().prec = 50
+
+
+def need(condition, message):
+    if not condition:
+        raise AssertionError(message)
+
+
+def histograms(row, local, idle=True):
+    targets, paid = Counter(), Counter()
+    kinds = Counter(e[0] for e in row["physical_events"])
+    need(kinds["LOCAL"] == 18 and kinds["QUERY_SHEAR"] == 15 and kinds["IDLE"] == 15, "18 calls, 15 shears, 15 idles")
+    for e in row["physical_events"]:
+        if e[0] == "LOCAL":
+            targets.update(HELPERS)
+            paid.update(local)
+        elif e[0] == "QUERY_SHEAR":
+            paid[1] += 112
+        elif e[0] == "IDLE" and idle:
+            paid[8 * len(e[2])] += 224
+    for term in row["diagonal"]:
+        targets[1 + 8 * sum(term[1:])] += 112
+    return targets, paid
+
+
+def margin(targets, paid, c):
+    s = 1 - c
+    moment = lambda h: sum(D(n) * (D(r).ln() * s).exp() for r, n in h.items())
+    return moment(targets) - moment(paid)
+
+
+def root(targets, paid, lo=D("0.0025"), hi=D("0.0035")):
+    need(margin(targets, paid, lo) > 0 > margin(targets, paid, hi), "sign change bracket")
+    for _ in range(70):
+        mid = (lo + hi) / 2
+        if margin(targets, paid, mid) > 0:
+            lo = mid
+        else:
+            hi = mid
+    return lo, hi
+
+
+def main():
+    row = json.loads(CONTROLLER.read_text(encoding="utf-8"))
+    need((row["kind"], row["pairs"], row["prefix_pairs"]) == ("complex", 16, 7), "p16 complex controller")
+    tn, pn = histograms(row, P_NEW)
+    to, po = histograms(row, P_OLD)
+    new_lo, new_hi = root(tn, pn)
+    old_lo, old_hi = root(to, po)
+    need(D("0.0030215551") < new_lo and new_hi < D("0.0030215552"), "#4610 raw crossing bracket")
+    need(D("0.00302016597") < old_lo and old_hi < D("0.0030201659771"), "control: PR4535 root reproduced")
+    need(sum(pn.values()) == 64404 and sum(po.values()) == 64620, "paid calls 64,404 / 64,620")
+    mass = lambda h: sum(r * n for r, n in h.items())
+    need(mass(tn) - mass(pn) == mass(to) - mass(po) == 752, "rank-mass surplus 752")
+    kappa = (new_lo * 10 ** 8).to_integral_value(rounding="ROUND_FLOOR") - 3
+    need(kappa == 302152, "kappa = floor(root * 1e8) - 3 = 0.00302152")
+    t_bad, p_bad = histograms(row, P_NEW, idle=False)
+    need(root(t_bad, p_bad, hi=D("0.5"))[0] > new_hi, "failure control: dropping idle charges inflates the root")
+    print(json.dumps({"status": "PASS_PR4610_CROSSING_RECOMPUTED", "new_root": str(new_lo)[:22],
+                      "old_root_control": str(old_lo)[:22], "gain": str(new_lo - old_lo)[:12],
+                      "paid_calls": [64620, 64404], "rank_mass_surplus": 752, "kappa_e8": 302152,
+                      "new_kappa_claimed": False}, indent=1))
+
+
+if __name__ == "__main__":
+    sys.exit(main())