Conditional κ = 0.001734770557111513160495: R438 bit supplier with #3190's idle-remainder donors (complex binds again, +0.0775%)

research/rank7-idle-donors-r438-bit/CLAIM.json

@@ -0,0 +1,11 @@
+{
+ "kappa": "17347705571115131604949999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+ "kappa_decimal": "0.0017347705571115131604949999999999999999999998999999999999999999999999",
+ "complex_root": [
+  "17347705571115131604951/10000000000000000000000000",
+  "17347705571115131604952/10000000000000000000000000"
+ ],
+ "bit_supplier": "R438 (PR1043 + PR2423, research/r438-native-rehost) 0.001734846264120199151475",
+ "binding": "complex",
+ "gain_over_pr3190": "671758760834462873/500000000000000000000000"
+}

research/rank7-idle-donors-r438-bit/README.md

@@ -0,0 +1,87 @@
+# R438 bit supplier with PR3190's idle-remainder donors: the complex side binds again at κ = 0.001734770557111513160495 − 10⁻⁴⁶ − 10⁻⁷⁰
+
+**Author-checked conditional composition; not maintainer-reviewed.** The selected record on
+`main` is still #1094. This package stacks on the open PR3190
+(`research/rank7-idle-remainder-donors-t740`).
+
+| | complex endpoint | bit endpoint | binds | κ headline |
+|---|---|---|---|---|
+| PR3190 | 0.0017347705571115131604951 | PR589 0.001733427039589844234749 | bit | 0.001733427039589844234749 − … |
+| **this** | 0.0017347705571115131604951 | **R438 0.001734846264120199151475** | **complex** | **0.001734770557111513160495 − 10⁻⁴⁶ − 10⁻⁷⁰** |
+
+The gain is **+1.3435e-6 (+0.0775%) over PR3190**, +4.58e-6 over PR3184 and +4.99e-6 over
+PR3148.
+
+## Idea
+
+PR3190's idle-remainder exchanges pushed the complex root of PR3133's words above the PR589 bit
+saving, so its κ was capped by the bit supplier. A stronger certified bit supplier already exists on
+main.
+
+The R438 word:
+
+- comes from Ali Romman's PR1043, with helper 470 deleted;
+- adds Sagar Thakrar's PR2423 transport and optimal re-hosting;
+- has a complete native, parent and hosted replay in `research/r438-native-rehost`.
+
+Its bit endpoint is 0.001734846264120199151475, accepted at c and rejected at c + 10⁻²⁴. That is
+above the new complex root, so with R438 the complex side binds again.
+
+## Verification
+
+`verify.py` uses the standard library only and runs in about 1 s:
+
+1. **Complex endpoint.** It recomputes PR3190's complex root bracket on its declared complete
+   profile, with its own interval arithmetic at 10⁻⁷².
+2. **Bit endpoint.** It re-derives the R438 endpoint from the certificate's own bit profile:
+   m = 64, live = 28,416, with the 10⁻¹⁶·32m² bad-edge fallback envelope. The endpoint is accepted
+   at c and rejected at c + 10⁻²⁴.
+3. **Composed κ.** It computes `κ = min(floor₂₄(complex), floor₂₄(bit)) − 10⁻⁴⁶ − 10⁻⁷⁰`, checks it
+   equals CLAIM.json, and gates it against PR3148, PR3184 and PR3190.
+
+Three mutation controls are rejected: the complex next grid point, the bit next grid point, and
+the PR589 endpoint on the R438 profile. PR3190's moves and profile are checked by its own
+registered verifier.
+
+```sh
+python3 -B research/rank7-idle-donors-r438-bit/verify.py
+```
+
+## Scope
+
+**Conditional on two unreviewed claims:**
+
+- PR3190 and its stack: PR3148, PR3133, and the hosted-remainder donor hypothesis.
+- R438: PR1043 is open, and `r438-native-rehost` does not promote a selected supplier.
+
+The R438 bill fits the inherited row bound: row coefficient 18,355 < 20,161, maxchild 42 with
+`2·42² < 64²`.
+
+The T74 outer ledger currently pins the PR589 bit constant, and only uses it to assert
+`complex < bit`. With R438 that assertion holds directly, but the release needs the constant
+re-pinned. All inherited all-size, compiler, realization, precision and analytic obligations
+remain.
+
+## Open next questions
+
+- **Does the T74 outer release accept R438 in place of PR589?** First step: rerun PR3148's outer
+  release with the R438 bit endpoint and its finite bill. Blocked by: PR1043 is open, and the outer
+  ledger pins PR589.
+- **Can the complex side close the remaining 7.6e-8 gap to the R438 endpoint?** First step: drain
+  more of the 149,514 rank-1 remainders that are blocked by commuting legality, or widen the
+  receiver set.
+- **Bit side.** R438's own idle remainder (`{34:32, 42:320}`, cap 45 at m = 64) admits the same
+  axis-exchange question, should the bit side bind again.
+
+## Credit
+
+- Ali Romman (PR1043): the R438 word.
+- Sagar Thakrar (PR2423): transport and re-hosting.
+- commdata2338 (PR2653): native emission.
+- The `r438-native-rehost` authors.
+- PR3190 / PR3184 and their credits: PR1252 Gonzalo-Mier; Guéorgui Maissouradze; PR3148 Jeremy
+  Diviney; PR3133 dcharb78; PR2979 Marius-Paul Dumitrean.
+- DreamingOfClouds and eumemic (PR589/PR555).
+
+Prepared by Rohan Arun. Done with help from **OpenCode (Space bunny free)**, and with Anthropic
+Claude assistance. Apache-2.0.

research/rank7-idle-donors-r438-bit/SOURCES.json

@@ -0,0 +1,31 @@
+{
+  "schema_version": 1,
+  "base_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "research/r438-native-rehost/CERTIFICATE.json",
+      "usage": "input",
+      "git_blob": "674ef36f723fbcc593e7d2319dca131da09181e5",
+      "sha256": "6da8c593257c8440f0fe35488d941715d953d715e2e464ffdfffff7ed31eee9c"
+    },
+    {
+      "path": "research/rank7-idle-remainder-donors-t740/RESULT.json",
+      "usage": "input",
+      "git_blob": "2bbb2926bbd892129e988c962bc71632e42b2094",
+      "sha256": "3380908be142237abead45abddfb28c8a8804b61496040e8a8a8c5ef5edc5dc9",
+      "pin": "head:5e4a3235169edddd033889da4e9f47635ff50c3e:research/rank7-idle-remainder-donors-t740/RESULT.json"
+    }
+  ]
+}

research/rank7-idle-donors-r438-bit/TASK.json

@@ -0,0 +1,72 @@
+{
+  "schema_version": 1,
+  "task_id": "independent-moment",
+  "priority_revision": 6,
+  "base_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a",
+  "original_card": {
+    "id": "independent-moment",
+    "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?",
+    "starting_points": [
+      "certificates/selected-result.json",
+      "research/rank7-joint-endframes/README.md",
+      "docs/research/research-family-status.md"
+    ],
+    "methods": [
+      "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.",
+      "Implement certified moment inequalities through a different exact enclosure method."
+    ],
+    "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": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.",
+    "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.",
+      "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing."
+    ],
+    "overlap_terms": [
+      "independent moment",
+      "rank histogram",
+      "exact enclosure",
+      "2979",
+      "rank7 joint endframes",
+      "paired extraction",
+      "joint lowering"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Supplier composition: PR3190's idle-remainder complex endpoint for PR3133's words on PR3148's T740 fill (0.0017347705571115131604951) with the R438 bit supplier natively replayed on main (research/r438-native-rehost, 0.001734846264120199151475). Independent re-derivation of both endpoints and of the composed kappa.",
+  "scope_change_reason": "PR3190 made the complex side exceed the PR589 bit saving, so the useful next check is which certified bit supplier binds; R438 is above the new complex root.",
+  "bottleneck_link": "kappa = min(complex, bit) minus slacks; swapping in the stronger R438 bit supplier lets the complex side bind again.",
+  "budget_minutes": 45,
+  "stop_rule": "Stop after independent endpoint checks and the composed kappa; no new construction.",
+  "outcome": "partial",
+  "evidence": "verify.py: complex root bracket recomputed, R438 bit endpoint accepted at c and rejected at c+1e-24 (with fallback envelope), kappa gates; 3 mutation controls rejected.",
+  "author": "Rohan Arun",
+  "ai_assistance": "Substantial Anthropic Claude (Claude Code) assistance; done with help from OpenCode (Space bunny free).",
+  "open_questions": [
+    {
+      "question": "Is R438 (conditional on open PR1043) compatible with the rank-seven T74 outer release when substituted for PR589?",
+      "why_it_matters": "The composed kappa needs the outer ledger to accept the R438 bit row bill (row coefficient 18,355 < 20,161).",
+      "first_step": "Rerun PR3148's outer release with the R438 bit endpoint and its finite bill.",
+      "blocked_by": "PR1043 is open; the T74 outer pins the PR589 bit constant."
+    },
+    {
+      "question": "Can the complex side be pushed the remaining 7.6e-8 to the R438 bit endpoint?",
+      "why_it_matters": "Beyond that the bit side binds again.",
+      "first_step": "Drain more of the 149,514 rank-1 remainders (legality-blocked) or extend receivers.",
+      "blocked_by": "Commuting-rule legality."
+    }
+  ]
+}

research/rank7-idle-donors-r438-bit/VERIFY.json

@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/r438-native-rehost/CERTIFICATE.json",
+    "research/rank7-idle-remainder-donors-t740/RESULT.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Recomputes PR3190 complex root bracket and the R438 bit endpoint (accept at c, reject at c+1e-24, fallback envelope) with its own interval arithmetic; kappa = min(floor24(complex), floor24(bit)) - 1e-46 - 1e-70 equals CLAIM.json and exceeds PR3148/PR3184/PR3190; 3 mutation controls rejected."
+    }
+  ]
+}

research/rank7-idle-donors-r438-bit/verify.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Compose the PR3190 idle-remainder complex endpoint with the R438 bit supplier.
+
+PR3190 (research/rank7-idle-remainder-donors-t740) raised the complex root of PR3133's words on
+PR3148's T740 fill to 0.0017347705571115131604951, past the PR589 bit saving, so its kappa was
+bit-capped at 0.001733427039589844234749.  The R438 bit supplier (PR1043 word, PR2423 transport and
+re-hosting, natively replayed in research/r438-native-rehost on main) has bit endpoint
+0.001734846264120199151475, above that complex root.  With it the complex side binds again.
+
+This verifier (standard library only):
+  1. re-derives the complex root bracket of PR3190's declared profile with its own interval arithmetic;
+  2. re-derives the R438 bit endpoint from the certificate's own bit profile (m = 64, live = 28,416,
+     with the 10^-16 * 32 m^2 fallback envelope): accepted at c, rejected at c + 1e-24;
+  3. computes kappa = min(floor24(complex_lower), floor24(bit_lower)) - 1e-46 - 1e-70 and gates it.
+The moves and profile of PR3190 are checked by that package's own registered verifier.
+"""
+import argparse, hashlib, json
+from fractions import Fraction as F
+from pathlib import Path
+
+PKG = Path(__file__).resolve().parent
+ROOT = PKG.parents[1]
+COMPLEX = ROOT / 'research/rank7-idle-remainder-donors-t740/RESULT.json'
+BITCERT = ROOT / 'research/r438-native-rehost/CERTIFICATE.json'
+GATES = dict(PR3148=F('0.0017297774946785970118859999999999999999999998999999999999999999999999'),
+             PR3184=F('0.0017301890612338507600949999999999999999999998999999999999999999999999'),
+             PR3190=F('0.0017334270395898442347489999999999999999999998999999999999999999999999'))
+
+
+class Reject(Exception): pass
+def req(ok, why):
+    if not ok: raise Reject(why)
+
+Q72 = 10 ** 72
+def rd(x): return F(x.numerator * Q72 // x.denominator, Q72)
+def ru(x): return F(-((-x.numerator * Q72) // x.denominator), Q72)
+def atanh2(z, n):
+    s, p = F(0), z
+    for j in range(n): s += p / (2 * j + 1); p *= z * z
+    return 2 * s, 2 * p / ((2 * n + 1) * (1 - z * z))
+L2 = atanh2(F(1, 3), 130)
+def ln_box(y):
+    k = 0
+    while y >= 2: y /= 2; k += 1
+    a, e = atanh2((y - 1) / (y + 1), 90)
+    return rd(a + k * L2[0]), ru(a + e + k * (L2[0] + L2[1]))
+def exp_box(x0, x1):
+    def tay(x):
+        s, t = F(1), F(1)
+        for j in range(1, 34): t = t * x / j; s += t
+        return s, t * x / 34 * 3
+    a, _ = tay(x0); b, t = tay(x1)
+    return rd(a), ru(b + t)
+def moment(prof, m, W, b, bad=False):
+    lo = hi = F(0)
+    items = sorted(prof.items())
+    if bad:  # bad-edge Gaussian fallback envelope, 10^-16 * 32 m^2 rank-1 children per child (bit pricing)
+        items = items + [(1, F(32 * m * m * sum(prof.values()), 10 ** 16))]
+    for r, n in items:
+        l0, l1 = ln_box(F(m, r)); e0, e1 = exp_box(b * l0, b * l1)
+        lo += n * r * e0; hi += n * r * e1
+    return lo / (m * W), hi / (m * W)
+
+
+def compose(cx, bit):
+    prof = {int(k): v for k, v in cx['profile'].items()}
+    req(sum(r * n for r, n in prof.items()) == 65088 * 740 and max(prof) <= 51, 'PR3190 profile mass/halving')
+    lo, hi = F(cx['complex_root'][0]), F(cx['complex_root'][1])
+    req(hi - lo == F(1, 10 ** 25) and moment(prof, 73, 896 * 740, lo)[1] < 1 < moment(prof, 73, 896 * 740, hi)[0], 'complex root bracket')
+    inv = bit['pipeline']['candidate']['hosted']['invoice']
+    bprof = {int(k): v for k, v in json.loads(inv['bit_profile'].replace("'", '"')).items()} if isinstance(inv['bit_profile'], str) else {int(k): v for k, v in inv['bit_profile'].items()}
+    c = F(inv['bit_lower']); c_next = F(inv['next_grid_point_rejected'])
+    req(c == F(inv['bit_lower_decimal']) and c_next - c == F(1, 10 ** 24), 'bit certificate fields')
+    W = 28416
+    req(64 * W - sum(r * n for r, n in bprof.items()) > 0 and 2 * max(bprof) ** 2 < 64 ** 2, 'bit profile deficit/halving')
+    req(moment(bprof, 64, W, c, True)[1] < 1 and moment(bprof, 64, W, c_next, True)[0] > 1, 'bit endpoint accepted at c, rejected at c+1e-24')
+    floor24 = lambda x: F(x.numerator * 10 ** 24 // x.denominator, 10 ** 24)
+    C = min(floor24(lo), floor24(c))
+    req(C == floor24(lo) and floor24(lo) < c, 'complex binds below the R438 bit endpoint')
+    kappa = C - F(1, 10 ** 46) - F(1, 10 ** 70)
+    for n, g in GATES.items(): req(kappa > g, 'kappa must exceed ' + n)
+    return kappa, lo, c
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__); ap.parse_args()
+    if not __debug__: raise SystemExit('assertions required')
+    cx = json.loads(COMPLEX.read_text()); bit = json.loads(BITCERT.read_text())
+    claim = json.loads((PKG / 'CLAIM.json').read_text())
+    kappa, lo, c = compose(cx, bit)
+    req(F(claim['kappa']) == kappa == F(claim['kappa_decimal']), 'CLAIM kappa')
+    rej = {}
+    import copy
+    for name, mut in [('complex_next_grid', lambda x, b: x.__setitem__('complex_root', [str(lo + F(1, 10**25)), str(lo + F(2, 10**25))])),
+                      ('bit_next_grid', lambda x, b: b['pipeline']['candidate']['hosted']['invoice'].update(
+                          bit_lower=str(F(b['pipeline']['candidate']['hosted']['invoice']['next_grid_point_rejected'])),
+                          bit_lower_decimal=str(F(b['pipeline']['candidate']['hosted']['invoice']['next_grid_point_rejected'])),
+                          next_grid_point_rejected=str(F(b['pipeline']['candidate']['hosted']['invoice']['next_grid_point_rejected']) + F(1, 10**24)))),
+                      ('pr589_bit', lambda x, b: b['pipeline']['candidate']['hosted']['invoice'].update(
+                          bit_lower='1733427039589844234749/1000000000000000000000000', bit_lower_decimal='1733427039589844234749/1000000000000000000000000',
+                          next_grid_point_rejected='1733427039589844234750/1000000000000000000000000'))]:
+        x, b = copy.deepcopy(cx), copy.deepcopy(bit); mut(x, b)
+        try: compose(x, b)
+        except Reject as e: rej[name] = str(e)
+        else: raise SystemExit('mutation accepted: ' + name)
+    print('PASS_R438_COMPOSITION kappa=%s complex=%s bit=%s controls=%d' % (float(kappa), float(lo), float(c), len(rej)))
+    print(json.dumps(rej, sort_keys=True))
+
+
+if __name__ == '__main__':
+    try: main()
+    except Reject as e: raise SystemExit('FAIL: ' + str(e))

research/rank7-idle-remainder-donors-t740/AUDIT.json

@@ -0,0 +1,18 @@
+{
+ "binding": "bit",
+ "complex_root_lower": "17347705571115131604951/10000000000000000000000000",
+ "fill_rebound": true,
+ "kappa": "17334270395898442347489999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+ "moves": 391964,
+ "rejected_controls": {
+  "axis_moved_twice": "axis not in donor remainder",
+  "dropped_move": "declared profile",
+  "foreign_axis": "axis not in donor remainder",
+  "hosted_axis_from_used_prefix": "axis not in donor remainder",
+  "hosted_receiver": "receiver must be unhosted",
+  "kappa_above_bit": "headline kappa",
+  "next_root_grid": "complex root bracket",
+  "receiver_donates": "receiver must be unhosted"
+ },
+ "status": "PASS_IDLE_REMAINDER_DONOR_AUDIT"
+}

research/rank7-idle-remainder-donors-t740/CLAIM.json

@@ -0,0 +1,30 @@
+{
+ "kappa": "17334270395898442347489999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+ "kappa_decimal": "0.0017334270395898442347489999999999999999999998999999999999999999999999",
+ "binding": "bit (PR589 0.001733427039589844234749)",
+ "complex_root": [
+  "17347705571115131604951/10000000000000000000000000",
+  "2168463196389391450619/1250000000000000000000000"
+ ],
+ "baseline": "PR3184 / PR3148 (open)",
+ "gain_over_pr3184": "1618989177996737327/500000000000000000000000",
+ "gain_over_pr3148": "3649544911247222863/1000000000000000000000000",
+ "profile": {
+  "1": 16353294,
+  "2": 4837720,
+  "3": 1533431,
+  "4": 679320,
+  "5": 147055,
+  "8": 53280,
+  "42": 32303,
+  "45": 34720,
+  "48": 48434,
+  "49": 47026,
+  "50": 15320,
+  "51": 104766
+ },
+ "T": 740,
+ "changed_hypothesis": "idle remainders of partially hosted bins donate axes (PR1252 rule) to unhosted idle children; receivers capped at 51",
+ "status": "author-checked conditional candidate; native admission, overlay-aware controller audit and bit-binding outer release not rerun",
+ "credits": "PR1252 Gonzalo-Mier; star class Gueorgui Maissouradze; PR3148 Jeremy Diviney; PR3133/PR3042 dcharb78; PR2979 Marius-Paul Dumitrean; OpenCode (Space bunny free); Anthropic Claude"
+}