[rohanarun]

Change and mathematical scope

Composition of PR #3642's retimed suppliers with PR #3633's literal T488 allocation. Conditional κ = 0.001730418899766071163804 − 10^-46 − 10^-70, an absolute improvement of 0.000000024507952107748684 over pinned PR #3642. The original full scientific admission and the separate end-to-end replay of the published wrapper both passed. The wrapper returned PASS_T488_RETIMER_COMPLETE_CONDITIONAL_RELEASE, including all seven admission stages. Ready for review.

The complete paid profile is {1:10817496,2:3179808,3:1024434,4:447984,5:94794,8:35136,48:186782} across 4,392 calls and 1,791,936 helper roles; 437,248 live and 437,757 physical families, including 91 private zero buffers.

All inherited all-size dispatch/compiler, recursive rounding, common-label/mutable-source realization, whole-call hosting, SCALAR/COPY/CLEAR/zero-allocation, uniform coefficient/stock, bootstrap, precision/tape/recovery and analytic/BIT H1–H5 assumptions remain. No unconditional theorem, formal-kernel proof, independent human review or selected-frontier update is claimed.

Task and overlap

User-directed work, retrospectively classified under scalar-to-moment, refined scope. Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90; exact dependencies PR #3642 abc12f62e4fe9bfcb2e33c84703253c918668351 and PR #3633 72c268f113368ea0387d188225e3f81ba6d6ef73. This composes existing local and allocation advances; neither is claimed as newly discovered here. PR #3642 has since advanced to 80c0f2906d4ecd66325c42fcf3cfd5070a088bdb; this submission retains its explicit original pin.

Validation

• Fresh bounded aggregate passed: local operator, literal owners, two rational moment engines, 63 strict outer inequalities and 17 outer rejection controls, plus authenticated full-replay input closure.
• Both changed native providers passed fresh checks. Unchanged ancestry is authenticated reuse.
• All seven full scientific admission stages passed. Raw source/native/owner/package/release evidence and a strict cross-binding checker are published under evidence/recorded-admission. The exact released κ is 0.0017304188997660711638039999999999999999999998999999999999999999999999.
• Portable source reconstruction matches the exact 654-file manifest. The packaged all-in-one full wrapper passed end-to-end on an export of published commit 2695d36521e4c9e196c84fef24b31e0607b4904a: source reconstruction, literal ownership, both fresh native providers, and complete seven-stage admission all exited successfully. Its full-replay Git tree is identical to current head 607a09ff441c79b215a8127a81f4cc70021d0d9b (tree d9c47c062b897e2639e626598ddec84c83c2bd3e).
• Hosted bounded CI passed for current head 607a09ff441c79b215a8127a81f4cc70021d0d9b (run). The evidence checker also passed locally with actual complete receipts and twelve targeted mutation tests. Hosted bounded CI and the local full-wrapper replay are distinct checks.

Reproduce bounded checks with Python 3.12 / NumPy 2.5.4:

python3 -B scripts/research_package.py --package research/retimed-t488-composition --check-only
python3 -B scripts/research_package.py --package research/retimed-t488-composition

See package README, PROOF and full-replay/README for exact evidence and full reproduction instructions.

Credit

Credit roger-sato's PR #3642 and #3633, Ross Richardson's PR #3605, hexapode's PR #3626, and all retained infrastructure contributors. Apache-2.0 notices are preserved. Substantial OpenAI Codex assistance was used for proof, implementation, independent agent checks and packaging.

Open next questions

Independent review of the source-bound construction and complete replay receipts remains welcome; both full runs passed. Further gains require a distinct paid-profile or interface change; proving inherited general premises would strengthen theorem status. See TASK.json for concrete follow-ups.

Full-wrapper result SHA-256: 7a67cc7047c22967d9475396112babe54f3c68094200904e8b51f7240313892f; strict release receipt SHA-256: d861dcf6f296fae5b785739c22d7a6c0528d99d81a2e0772c2819b88804db639. Full-wrapper receipts are retained locally; the original full admission evidence remains published under evidence/recorded-admission.

[thakrarsagar]

FYI, an independent check relevant to this draft (no κ): PR3694 audits PR3633's literal T488 journal, which this PR reuses (vendored EXPECTED.json sha 924493b6…). At your head 607a09ff, both RETIMED644-660-* words recount, in my own word lineage, to exactly PR3633's helper widths, with local bill {1:2437, 2:724, 3:226, 4:102, 5:20, 8:8}. So the audited journal hosts them unchanged. The resulting profile {1:10817496, 2:3179808, 3:1024434, …} has endpoint 0.001730418899766071163804 in two enclosures, equal to your κ.

The fixed-inventory LP's reduced costs do not involve the local bill. Your profile is exactly 488 × the LP minimum with the retimed bill, and the PR3633 dual, re-certified on your endpoint's 24-digit step, shows that this allocation is at its packing ceiling. Further gains need changed widths or a further bill change.

Note also that owners/independent_literal.py (adapted) carries the same five tautological reject() controls and the gzip-file native_canonical pin (findings 1 and 2 there).

This does not check the retimed words' exactness or native lowering.

[rcfc-jreed]

Independent scoped audit of the retimed T488 composition package at 607a09ff: no defect found in the finite pin / ARTIFACTS / κ-arithmetic / profile-seal layer

Code-disjoint checks; does not import package verify.py. Package bytes from head 607a09ff441c79b215a8127a81f4cc70021d0d9b via GitHub contents API. CLAIM. Hosted full admission wrapper was not re-run.

What passes (12 of 12):

1. Pins / digests. Base 20ecf289…; VERIFY ready; TASK outcome partial; all 231 ARTIFACTS.json digests match local bytes.
2. Status seals. PASS_SOURCE_BOUND_TWO_ENGINE_RETIMED_T488_ARITHMETIC, PASS_T488_RETIMER_COMPLETE_CONDITIONAL_RELEASE, PASS_FRESH_BOUNDED_RETIMED_T488; PUBLIC/PORTABILITY validations contain PASS.
3. κ arithmetic (exact Fraction). New conditional κ − prior PR3642 κ equals recorded absolute_gain; κ = endpoint 0.001730418899766071163804 − 10⁻⁴⁶ − 10⁻⁷⁰; outer/BOUNDED/COMPLETE pins agree; gain ≈ 2.4507952107748684×10⁻⁸.
4. Profile. Paid profile {1:10817496,…,48:186782} agrees across seals; 4392 calls / 437248 live; local deltas {-2,-2,+2} on ranks 1/2/3 conserve under delta × calls.

Not covered: live full admission / native controller replay; unconditional theorem; selected-frontier update; formal-kernel proof.

This is a finite seal/arithmetic replay, not a formal proof. The package’s own scope correctly leaves inherited premises and unconditional claims untouched.

check_3653.py

#!/usr/bin/env python3
"""Independent finite controls for PR3653 (retimed T488 conditional κ).

Recomputes pin / ARTIFACTS digests / κ-arithmetic / profile seals from committed
package files. Does not import package verify.py; does not re-run full admission.

Package head 607a09ff441c79b215a8127a81f4cc70021d0d9b via GitHub API.

James Reed (@rcfc-jreed), with substantial AI assistance (Claude, in Cursor).
Apache-2.0.
"""
from __future__ import annotations

import argparse, hashlib, json, sys
from fractions import Fraction
from pathlib import Path

HEAD = "607a09ff441c79b215a8127a81f4cc70021d0d9b"
BASE = "20ecf2891d80b5acf18d980b2164fb44ea7faa90"
NEW_KAPPA = Fraction(
    "17304188997660711638039999999999999999999998999999999999999999999999"
    "/10000000000000000000000000000000000000000000000000000000000000000000000"
)
OLD_KAPPA = Fraction(
    "17303943918139634151199999999999999999999998999999999999999999999999"
    "/10000000000000000000000000000000000000000000000000000000000000000000000"
)
GAIN = Fraction("6126988026937171/250000000000000000000000")
ENDPOINT = Fraction("432604724941517790951/250000000000000000000000")
PROFILE = {"1": 10817496, "2": 3179808, "3": 1024434, "4": 447984, "5": 94794, "8": 35136, "48": 186782}
results = []


def check(name, ok, detail=""):
    results.append((name, bool(ok), detail))
    print(("PASS " if ok else "FAIL ") + name + ((": " + str(detail)) if detail else ""), flush=True)
    return bool(ok)


def load(pkg, name):
    return json.loads((pkg / name).read_text(encoding="utf-8"))


def sha(path: Path) -> str:
    return hashlib.sha256(path.read_bytes()).hexdigest()


def run(pkg: Path):
    task = load(pkg, "TASK.json")
    sources = load(pkg, "SOURCES.json")
    verify = load(pkg, "VERIFY.json")
    arts = load(pkg, "ARTIFACTS.json")
    recorded = load(pkg, "numerics/RECORDED.json")
    bounded = load(pkg, "evidence/BOUNDED-WITH-RECORDED-ADMISSION.json")
    complete = load(pkg, "evidence/recorded-admission/COMPLETE-ADMISSION.json")
    outer = load(pkg, "evidence/recorded-admission/outer_claim.json")
    prior_claim = load(pkg, "numerics/inputs/PR3642-CLAIM.json")
    pub = load(pkg, "PUBLIC-VALIDATION.json")
    port = load(pkg, "full-replay/PORTABILITY-VALIDATION.json")
    readme = (pkg / "README.md").read_text(encoding="utf-8")

    check("I1 TASK/SOURCES base_commit == 20ecf289…; VERIFY ready; outcome partial",
          task["base_commit"] == BASE == sources["base_commit"]
          and verify["status"] == "ready"
          and task["outcome"] == "partial")

    bad = []
    for rel, digest in arts.items():
        local = pkg / rel
        if not local.is_file():
            bad.append(("missing", rel))
        elif sha(local) != digest:
            bad.append(("mismatch", rel))
    check("D1 ARTIFACTS.json digests match every listed package file",
          not bad, {"n": len(arts), "bad": bad[:5]})

    check("S1 RECORDED PASS_SOURCE_BOUND…; COMPLETE PASS_T488…; BOUNDED PASS_FRESH…",
          recorded["status"] == "PASS_SOURCE_BOUND_TWO_ENGINE_RETIMED_T488_ARITHMETIC"
          and complete["status"] == "PASS_T488_RETIMER_COMPLETE_CONDITIONAL_RELEASE"
          and bounded["status"] == "PASS_FRESH_BOUNDED_RETIMED_T488")

    new_k = Fraction(complete["kappa"])
    old_k = Fraction(complete["prior_PR3642"])
    gain = Fraction(complete["absolute_gain"])
    check("K1 complete κ − prior PR3642 κ == absolute_gain (exact Fraction)",
          new_k == NEW_KAPPA and old_k == OLD_KAPPA and gain == GAIN
          and new_k - old_k == gain == GAIN)
    check("K2 outer_claim / BOUNDED candidate_kappa / PR3642-CLAIM pins agree",
          Fraction(outer["kappa_rational"]) == NEW_KAPPA
          and Fraction(bounded["candidate_kappa"]) == NEW_KAPPA
          and Fraction(prior_claim["kappa"]) == OLD_KAPPA
          and complete["comparison_claim_sha256"] == sha(pkg / "numerics/inputs/PR3642-CLAIM.json"))
    check("K3 fixed-grid form: κ = endpoint − 10^-46 − 10^-70",
          NEW_KAPPA == ENDPOINT - Fraction(1, 10 ** 46) - Fraction(1, 10 ** 70)
          and Fraction(recorded["root_interval"][0]) == ENDPOINT
          and recorded["root_decimal_interval"][0] == "0.001730418899766071163804")
    check("K4 absolute gain decimal matches claimed ~2.4507952107748684e-8",
          float(gain) == float(Fraction("0.000000024507952107748684"))
          or abs(float(gain) - 2.4507952107748684e-8) < 1e-30)

    check("P1 paid profile seals agree across RECORDED/BOUNDED/COMPLETE; calls=4392 live=437248",
          recorded["new_profile"] == PROFILE == bounded["profile"] == complete["profile"]
          and recorded["calls"] == 4392 and recorded["live"] == 437248
          and recorded["replicas"] == 488)
    # local bill deltas: -2,-2,+2 on ranks 1,2,3 applied across all 4392 calls
    check("P2 local bill delta per call {-2,-2,+2} on ranks 1/2/3; profile mass conserved under delta*calls",
          recorded["delta_per_call"] == {"1": -2, "2": -2, "3": 2}
          and all(
              recorded["new_profile"][k] - recorded["old_profile"][k]
              == recorded["delta_per_call"].get(k, 0) * recorded["calls"]
              for k in recorded["new_profile"]
          ))

    check("V1 PUBLIC + PORTABILITY validation JSON contain PASS seals",
          "PASS" in json.dumps(pub) and "PASS" in json.dumps(port),
          {"pub_status": pub.get("status"), "port_status": port.get("status")})

    check("N1 README: no unconditional theorem / formal-kernel / human review / selected-frontier update",
          "No unconditional multiplication theorem, formal-kernel verification, independent human peer review or selected-frontier update is claimed." in readme)

    failed = [name for name, ok, _ in results if not ok]
    print(f"\n{len(results) - len(failed)}/{len(results)} PASS", flush=True)
    if failed:
        print("FAILED:", ", ".join(failed), flush=True)
        return 1
    return 0


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--pkg", required=True)
    ap.add_argument("--expect-head", default=HEAD)
    args = ap.parse_args()
    check("HEAD pin recorded (API fetch)", args.expect_head == HEAD, args.expect_head)
    return run(Path(args.pkg))


if __name__ == "__main__":
    sys.exit(main())

James Reed (@rcfc-jreed), with substantial AI assistance (Claude, in Cursor).