Improve conditional T530 κ through two commuting release retimings

[roger-sato]

Change and mathematical scope

Summary. Two adjacent shared-source ADD pairs in each pinned PR3605 supplier commute exactly. Retiming their releases changes the relevant helper frame paths from 1 → 2 → 4 to 1 → 4, preserving the operator, helper identities, widths and boundary interfaces. Each invocation replaces 2H1 + 2H2 with 2H3.

Applied to PR3626's actual 4,770-call T530 allocation, this yields the conditional endpoint

κ = 0.001730394391813963415120 − 10^-46 − 10^-70, an absolute improvement of 3.2252710818353258e-7 (about 0.0186424%) over that pinned direct predecessor.

The exact commuting/frame argument, complete paid profile, two-engine root enclosure and transfer chain are in PROOF.md. The full profile is {1:11747920,2:3453480,3:1112042,4:486540,5:103690,8:38160,48:202828}; live/physical stock is 474,880/475,389; global prefix/reserve/payload is 1,479/1,512/2,048 bits.

Remaining assumptions: inherited all-size dispatch/compiler and recursive rounding; common-label/mutable-source realization and whole-call hosting; SCALAR/COPY/CLEAR and zero-allocation contracts; uniform coefficient/stock, bootstrap, precision, tape/recovery, and analytic/BIT H1–H5 premises. Finite checks do not discharge these general premises. This draft makes no unconditional theorem, formal-kernel, independent human review, global-best or priority claim. The selected frontier is unchanged.

Task and overlap

• Base: 20ecf2891d80b5acf18d980b2164fb44ea7faa90.
• Supplier source: Reduce helpers 644/660 from width 8 to 7; conditional κ > 0.00173 #3605 at 3efbb5de06a49ffeea6684482f2d3fe48cdca3fb.
• Direct predecessor/allocation: Combine T37 and T16 chronology: conditional κ > 0.00173007186470 #3626 at 659fd5e7064d9466b668d7188cbb013b333a415a.
• Comparison: Combine T37, T8 and T16: conditional κ > 0.00173009636352 #3633 at 46c5aaca40117a4ca90a3316771ae52cf9a6801e reaches the old inventory's ceiling. This change improves the local bill underlying that ceiling; combining with its T488 allocation is untested.
• Bound staged-supplier packing for every replica count #3630 supplies the fixed-inventory dual basis. The new relaxed ceiling is a scoped bound, not an additional achieved κ.

This is user-directed research, retrospectively classified under scalar-to-moment with refined scope. The improvement is in the complete paid profile, not scalar addition count alone. The overlap refresh covered open PRs/discussions and local records; it is not a novelty certificate. At publication, #3633 had advanced to 72c268f113368ea0387d188225e3f81ba6d6ef73 for an attribution correction; its stated endpoint was unchanged from our comparison pin.

Validation

Test plan and results. Reproduction instructions and per-component scope are in README.md. Bounded checks use Python 3.12 / NumPy 2.5.4:

python3 -B scripts/research_package.py --package research/staged-release-retiming-t530 --check-only
python3 -B scripts/research_package.py --package research/staged-release-retiming-t530

• The original bounded package replay passed in about 24.2 seconds; no package writes. Committed bytes match all package files and declared inputs. Declared Git pins are ancestors of this publication.
• Exact local proof, both complete free-operator words, 632 arbitrary input columns in both orientations, 91 zero buffers, and rejection controls.
• Fresh reconstruction and independent audit of all 1,946,160 owner roles, capacities, chronological prefixes and complete invoice. The inherited five rejection-control claim is corrected below; current coverage uses five actual-gate mutations and five gate-disable sensitivity tests.
• Two rational root engines, 63 strict transfer inequalities, 17 rejection controls, and independent balance derivation.
• All 2,551 scoped packing patterns: 2,539 strictly positive reduced costs and 12 symbolic zeros.
• In the original scientific run, both changed native providers were freshly checked; all seven admission stages exit 0, terminal PASS_RELEASE. Two unchanged native chains and the retained parent were authenticated and reused. Full admission took about 20.3 minutes excluding earlier native generation.
• Public source reconstruction reproduces the identical 654-file source manifest fb47533a401d1d13719be8b9aab91fe5313931ca62d40dba336eab6a96275aa0.
• The published full wrapper completed end to end in 1,271.67 seconds (21m 12s) on macOS 27.0 arm64 / Python 3.12.14, from publication commit abc12f62e4fe9bfcb2e33c84703253c918668351, in a fresh external work directory without a supplied allocation. All seven wrapper stages and seven nested admission stages exited 0. Terminal PASS_RETIMER_T530_COMPLETE_CONDITIONAL_RELEASE / PASS_RELEASE reproduced the same exact κ and 654-file source manifest. Both changed native providers and all 1,946,160 owner roles were regenerated; two unchanged native chains and the retained parent remained authenticated reuse. All 295 original package files stayed unchanged; no wrapper code fix was needed. See the separate full-replay record. This long replay remains outside bounded CI.
• The updated bounded package verification also checks the new receipt chain and four semantic rejection controls (unfinished attempt, external allocation, missing nested gate, stale terminal receipt). The compact evidence checker and controls passed under normal Python and -O; those checks validate recorded evidence, not another long scientific run.

The lean public package omits regenerated large archives/fill and retains required pinned dependencies, code, proof and evidence. Execution-path metadata is normalized with original/public SHA256 maps. The quick recorded-summary check verifies public integrity and internal references; it does not authenticate omitted archive bytes or rerun native/controller/outer admission. Original scientific inputs and earlier receipts remain unchanged. The public-wrapper run has its own new receipt chain; its raw local source/runtime/native/log bytes were checked before publishing normalized metadata. A later independent run in another environment and all general theorem assumptions remain open.

CI investigation and fix — 2026-10-18

Previous verified head: 044d24f12e74f228dd462c07ae2d7f3ea35e2be9. The fork-hosted Registered research packages run succeeded on Ubuntu 24.04 x86_64 / CPython 3.12.15 / NumPy 2.5.4. It used this exact PR head, the unchanged registered workflow, and base 20ecf2891d80b5acf18d980b2164fb44ea7faa90.

• plan: PASS, 265 helper tests discovered, 254 passed and 11 native-Windows-only tests skipped; the selector chose exactly research/staged-release-retiming-t530.
• replay: PASS, all three registered commands: bounded local/owner/numerics/packing checks, recorded public-wrapper receipt-chain check, and four semantic rejection controls. Terminal PASS_REGISTERED_RESEARCH_PACKAGE; subsequent git diff --exit-code also passed. The package execution step took about 79 seconds; the complete hosted workflow took about 4m 40s.
• Fixed an inherited workflow-validation failure in separate commit 044d24f1: the earlier fork run rejected .github/workflows/p112-common-slice.yml:19 because runner.temp is unavailable in job-level env. The file was byte-identical to the pinned base. Initialization now runs in a step using $RUNNER_TEMP and $GITHUB_ENV. Actionlint 1.7.12 reproduces the old failure and accepts the fix; a path-with-spaces shell check passed. Triggers, permissions, repository guard and scientific replay commands are unchanged. P112's historical scientific replay was not run.
• Fork Actions was enabled, but this workflow had no registered ID and get/enable/dispatch returned 404. A temporary fork-only branch registered the workflow with bootstrap jobs skipped; the real run above then dispatched the original workflow on the verified PR head. That temporary branch was deleted. The registration change is not in this PR, and neither default branch was modified.

At that previous head, upstream CI required maintainer action. The CrocSwap PR workflow is action_required, awaiting approval, with zero jobs started. The earlier run explicitly reports “awaiting approval from a maintainer”; this is not a test failure or a draft/path-filter issue. The contributing account has no upstream write access and cannot approve it. A maintainer with write access must review the changes and choose Approve workflows to run on this PR, following GitHub's approval procedure. The successful fork run is additional execution evidence; it does not satisfy or replace that upstream approval/check.

To reproduce the successful fork run:

gh workflow run research-packages.yml --repo roger-sato/integer-mult-bounds \
  --ref codex/staged-release-retiming-t530 \
  -f base=20ecf2891d80b5acf18d980b2164fb44ea7faa90

At 044d24f1, the research package was byte-for-byte unchanged from 80c0f290. That CI run did not repeat the 21-minute full wrapper above and does not discharge the remaining theorem assumptions. The PR's existing ready-for-review state is preserved.

Owner negative-control correction and current CI — 2026-10-19

Current head: 6568db75adbb61437190545f6fef1534c70e91e5. No change to κ, the paid profile, native words, frozen source manifests or previous scientific receipts.

Sagar Thakrar's independent PR3694 identified that the inherited owner auditor's five rejection lambdas do not call the actual validation gates. We independently reproduced this: replacing all five production predicates with True still lets those old controls report success. The earlier description of those lambdas as effective rejection tests was incorrect. The positive scientific ownership checks remain present.

Commit 6568db75 preserves the frozen auditors and adds an owned companion. It executes the authenticated positive auditor once, extracts its five actual unconditional validation statements, mutates helper identity, the strict lower window endpoint, same-call family, chronological prefix and invoice inputs, and requires rejection at the corresponding gate. Each negative test must also fail when that gate is disabled. These are five isolated production-gate semantic tests plus five disable-sensitivity tests, not five end-to-end corrupted-journal replays. The old lambdas are no longer counted as negative coverage.

• Local: all three registered commands passed with Python 3.12.14 / NumPy 2.5.4. Fresh bounded stages took 23.84 seconds, including reconstruction/audit of all 1,946,160 owner rows in 19.61 seconds. Package contents stayed unchanged. Validation record and individual gate receipts.
• Hosted Linux on this exact head: fork run39147915029 SUCCESS. The plan ran265 tests (254passed,11native-Windows skips); the replay passed all three registered commands, including both new five-test counts, and git diff --exit-code.
• Upstream: run39147782102 remains action_required, with zero jobs started. The contributing account cannot approve upstream fork workflows; a maintainer's workflow approval is still required. The successful fork run is separate evidence.

The complete public wrapper and its seven-stage admission use the separately retained owner audit, not this five-lambda companion. This correction does not alter that execution path, and the earlier 21-minute full scientific replay remains separately dated; no new full replay is claimed. The current bounded correction does not discharge any remaining all-size theorem assumptions. Research toward κ ≥0.002730394391813963415120 remains unachieved and is not included in this PR's result.

Credit

Credit Ross Richardson/PR3605 and PR3630, hexapode/PR3626, the PR3531 interval engine, dcharb78/PR3133, Jeremy Diviney/PR3148, and all retained infrastructure contributors. See CREDITS.md and preserved Apache-2.0 notices. The new search, proofs, independent agent cross-checks, integration and package preparation used substantial OpenAI Codex assistance.

Open next questions

The smallest follow-up is to bind these exact words into PR3633's T488 allocation and repeat complete owner/controller/prefix/outer admission; no predicted value from that composition is included here. Further word/inventory changes may exceed the narrow fixed-inventory headroom. Independently proving an inherited all-size premise would strengthen the theorem's status. First steps and blockers are listed in the package's Open next questions.

---

Prepared with OpenAI Codex assistance.

[rcfc-jreed]

Independent scoped audit of the T530 staged-release retiming package at 6568db75: no defect found in the finite pin / κ-arithmetic / profile-seal layer

Code-disjoint checks; does not import package verify.py. Package bytes from head 6568db75adbb61437190545f6fef1534c70e91e5 via GitHub contents API. CLAIM. Full admission wrapper was not re-run here (PUBLIC-FULL-REPLAY seal is checked only as a committed receipt).

What passes (9 of 9):

1. Pins / seals. Base 20ecf289…; VERIFY ready; PUBLIC, FULL-REPLAY, outer, moment, admission, release, owners, and packing all report PASS statuses.
2. κ arithmetic. Conditional κ pins agree across CLAIM/outer/PUBLIC/FULL/admission/release/MOMENT; κ = endpoint 0.00173039439181396341512 − 10⁻⁴⁶ − 10⁻⁷⁰; gain vs T530 predecessor endpoint equals ≈ 3.2252710818353258×10⁻⁷.
3. Profile. Paid profile {1:11747920,…,48:202828} agrees across seals; 530 replicas / 4770 calls / 474880 live; local deltas {-2,-2,+2} conserve under delta × calls.

Not covered: live full-wrapper admission; unconditional theorem; selected-frontier update.

This is a finite seal/arithmetic replay, not a formal proof.

check_3642.py

#!/usr/bin/env python3
"""Independent finite controls for PR3642 (T530 staged release retiming κ).

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

Package head 6568db75adbb61437190545f6fef1534c70e91e5 via GitHub API.

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

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

HEAD = "6568db75adbb61437190545f6fef1534c70e91e5"
BASE = "20ecf2891d80b5acf18d980b2164fb44ea7faa90"
NEW_KAPPA = Fraction(
    "17303943918139634151199999999999999999999998999999999999999999999999"
    "/10000000000000000000000000000000000000000000000000000000000000000000000"
)
OLD_ENDPOINT = Fraction(
    "17300718647057798825399999999999999999999998999999999999999999999999"
    "/10000000000000000000000000000000000000000000000000000000000000000000000"
)
ENDPOINT = Fraction("21629929897674542689/12500000000000000000000")  # 0.00173039439181396341512
GAIN = NEW_KAPPA - OLD_ENDPOINT
PROFILE = {"1": 11747920, "2": 3453480, "3": 1112042, "4": 486540, "5": 103690, "8": 38160, "48": 202828}
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 run(pkg: Path):
    task = load(pkg, "TASK.json")
    sources = load(pkg, "SOURCES.json")
    verify = load(pkg, "VERIFY.json")
    pub = load(pkg, "PUBLIC-VALIDATION.json")
    full = load(pkg, "PUBLIC-FULL-REPLAY.json")
    claim = load(pkg, "numerics/recorded/outer/CLAIM.json")
    outer = load(pkg, "numerics/recorded/outer/RESULT.json")
    moment = load(pkg, "numerics/recorded/MOMENT.json")
    expected = load(pkg, "numerics/t530/EXPECTED.json")
    admission = load(pkg, "full-admission/evidence/ADMISSION-RESULT.json")
    release = load(pkg, "full-admission/evidence/RETIMING-COMPLETE-RELEASE.json")
    owners = load(pkg, "owner-audit/RESULT.json")
    packing = load(pkg, "packing-cap/RETIMED-PACKING-CAP.json")
    readme = (pkg / "README.md").read_text(encoding="utf-8")

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

    check("S1 PUBLIC / FULL-REPLAY / outer / moment / admission / release / owners / packing PASS seals",
          pub["status"] == "PASS_STAGED_RELEASE_RETIMING_T530_BOUNDED_CHECKS"
          and full["status"] == "PASS_PUBLIC_FULL_WRAPPER_END_TO_END"
          and outer["status"] == "PASS_RETIMED_MODERN_OUTER_ARITHMETIC"
          and moment["status"] == "PASS_TWO_ENGINE_EXACT_MOMENT"
          and admission["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE"
          and release["status"] == "PASS_STAGED_RELEASE_RETIMING_T530_COMPLETE_CONDITIONAL_RELEASE"
          and owners["status"] == "PASS_INDEPENDENT_LITERAL_OWNER_WINDOWS_FAMILIES_PREFIXES_AND_INVOICE"
          and packing["status"] == "PASS_RETIMED_ALL_2551_FIXED_INVENTORY_PATTERNS")

    check("K1 κ pins agree across CLAIM/outer/PUBLIC/FULL/admission/release/MOMENT",
          Fraction(claim["kappa"]) == NEW_KAPPA
          == Fraction(outer["kappa"])
          == Fraction(pub["kappa"])
          == Fraction(full["kappa"])
          == Fraction(admission["kappa"])
          == Fraction(release["kappa"])
          == Fraction(moment["candidate_modern_kappa"]))
    check("K2 fixed-grid form: κ = endpoint − 10^-46 − 10^-70",
          NEW_KAPPA == ENDPOINT - Fraction(1, 10 ** 46) - Fraction(1, 10 ** 70)
          and Fraction(moment["root_interval"][0]) == ENDPOINT
          and moment["root_decimal"] == "0.00173039439181396341512")
    check("K3 gain vs T530 predecessor endpoint == NEW−OLD; float matches 3.2252710818353258e-7",
          Fraction(expected["candidate_endpoint"]) == OLD_ENDPOINT
          and NEW_KAPPA - OLD_ENDPOINT == GAIN
          and abs(float(GAIN) - float(moment["gain_vs_predecessor"])) < 1e-30
          and abs(float(GAIN) - 3.2252710818353258e-7) < 1e-30)

    check("P1 profile seals agree; replicas=530; calls=4770; live=474880",
          pub["profile"] == PROFILE == full["profile"] == admission["profile"]
          == release["profile"] == owners["profile"] == moment["new_profile"]
          and moment["replicas"] == full["replicas"] == owners["replicas"] == 530
          and moment["calls"] == full["calls"] == owners["calls"] == 4770
          and moment["live"] == 474880)
    check("P2 delta_per_call {-2,-2,+2}; profile mass conserved under delta×calls; EXPECTED holds old profile",
          moment["delta_per_call"] == {"1": -2, "2": -2, "3": 2}
          and expected["profile"] == moment["old_profile"]
          and all(
              moment["new_profile"][k] - moment["old_profile"][k]
              == moment["delta_per_call"].get(k, 0) * moment["calls"]
              for k in moment["new_profile"]
          ))

    check("N1 conditional scope: no selected-frontier update; inherited hypotheses retained",
          "no selected frontier update" in release.get("source_status", "").lower()
          and "conditional" in claim["scope"].lower()
          and "inherited_hypotheses" in release)

    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).