[1337isnot1337]

Summary

Adds one exact full-frame end-cut I-G/2 correction for the 104 source and 104
target endpoints represented by PR #2981's 208 static flags. At the cut after
the pinned 4,058-event channel, every source is in F9, and every target is in
its final eight-dimensional output frame. For each target, the word raises it
to F9, applies its 48 exact coefficients, and returns it to the original
frame.

The correction has 4,992 scalar additions: 3,376 coefficients -1/2 and 1,616
coefficients +1/2. Exact rational composition gives Y_t = y_t + x_t for all
104 targets; all sources and 72 arbitrary dirty helpers are restored. The 208
new target transports are individually compiled as rank-one native recipes
and checked for signed Pauli action and global phase.

Finite invoice

• Base channel: 4,058 events, 2,624 scalar additions, 1,410 transports, rank
  mass 2,368.
• Correction suffix: 4,992 scalar additions and 208 H1 transports, with no
  new dirty or private register.
• Combined word: 9,258 events, 7,616 scalar additions, 1,618 transports, rank
  mass 2,576. The paid profile changes by +208 H1.
• Under the documented endpoint frame-coordinate convention, peak width is
  1,769 and the 5,200-event suffix has 9,198,800 frame-coordinate event-holds.

The last quantity is a finite scheduling count; it is not presented as the
selected recursive owner/idle tariff. No supplier admission or new κ is
claimed.

Scope relative to existing P104 work

PR #3618 already supplies a 48-add correction for flag 9, row 23, at its
earlier event-3489 cut. This contribution extends the direct word to all 104
target rows at the later post-channel cut. It uses paid target-frame lifts and
descents, so it changes the monotone equal-frame contract used by the fixed
cover support cut reviewed in PR #3810. The 208 internal bases and 1,872-step
static screen from PR #2981 are not treated as an executable program.

The exact selected recursive owner/idle charge, consumer composition,
precision, and all-size lifting remain open. No selected frontier or κ changes.

Reproduction

python3 -B scripts/research_package.py --package research/p104-fullframe-endcut-correction --check-only
python3 scripts/research_package.py --package research/p104-fullframe-endcut-correction

Both commands passed locally on the pinned base. The package pins all live
inputs and retains the exact 4,992-entry correction and 208 transport recipes.

Credit and review limits

Credits: Rohan Arun / PR #1972 for the scalar/frame channel; Chafik Boukhalfa /
PR #1991 for its concrete native realization; Nick Petalas / PR #2981 and the
PR #2920 endpoint geometry; and the related flag-specific work in PRs #3614,
#3618, #3601, and #3610. This package was produced with Codex assistance. No
independent human or formal-kernel review is claimed.

Current overlap

Open PR #3882 packages a source-consuming correction tail with eight residual replacements. This package contributes the explicit 104-target full-frame I-G/2 endpoint word and its 4,992-addition, 208-transport invoice. These are distinct finite methods; neither establishes physical supplier admission.

Publication validation

python3.12 scripts/research_package.py --package research/p104-fullframe-endcut-correction passed on CPython 3.12.3, and python3.12 scripts/check_research_commit.py --package research/p104-fullframe-endcut-correction --check-source-history passed. The registered replay left the worktree clean. This supersedes any earlier pending note above for the registered package replay; separate full selected cold-replay limits remain as stated.

[rcfc-jreed]

Independent scoped audit of the P104 full-frame end-cut correction package at 13b397e3: packaging digest defects on CORRECTION.json / TRANSPORTS.json; scientific finite invoice arithmetic otherwise consistent

Code-disjoint checks; does not import package audit.py / compile_transports.py. Package bytes from head 13b397e36d43f2a91b9e6d42b3ca67f0ec50cea7 via GitHub contents API. CLAIM. Remote native-channel inputs were not re-fetched.

Defects:

pin	sealed	actual
RESULT.correction_sha256	31ba28ca…7c583d41	cbe13b62…8815f8a0
TRANSPORT-RESULT.transport_sha256	2b2047ab…071be02	4a3c4907…bbd0b62e

Suggested fix: refresh both digests to the current artifact bytes (or re-emit artifacts to match the sealed digests).

What passes (12 of 12 with D1/D2 asserting the defects):

1. Pins. Base 20ecf289…; VERIFY ready; RESULT/TRANSPORT PASS; scope excludes recursive tariff/κ.
2. Invoice. Base 4058 events / rank mass 2368; combined 9258=4058+5200; rank 2576; transports 1618=1410+208.
3. Correction. 4992 entries (3376×−1/2 + 1616×1/2); degrees 48; +208 rank-1; C=I−G/2; 208 native transports on 104 targets.

Not covered: live audit/compile re-execution; remote LOWRANK/CERTIFICATE auth; recursive owner/idle tariff; new κ.

This is a finite replay of committed receipts, not a formal proof.

check_3894.py

#!/usr/bin/env python3
"""Independent finite controls for PR3894 (P104 full-frame end-cut correction).

Recomputes invoice arithmetic and package digests. Does not import package
audit.py / compile_transports.py.

Package head 13b397e36d43f2a91b9e6d42b3ca67f0ec50cea7 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 pathlib import Path

HEAD = "13b397e36d43f2a91b9e6d42b3ca67f0ec50cea7"
BASE = "20ecf2891d80b5acf18d980b2164fb44ea7faa90"
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):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def mass(profile: dict) -> int:
    return sum(int(k) * int(v) for k, v in profile.items())


def run(pkg: Path):
    sources = load(pkg, "SOURCES.json")
    result = load(pkg, "RESULT.json")
    verify = load(pkg, "VERIFY.json")
    transport = load(pkg, "TRANSPORT-RESULT.json")
    corr = load(pkg, "CORRECTION.json")
    transports = load(pkg, "TRANSPORTS.json")

    check("I1 SOURCES base_commit == 20ecf289…; VERIFY ready",
          sources["base_commit"] == BASE and verify["status"] == "ready")
    check("I2 RESULT/TRANSPORT PASS; scope_limit excludes recursive tariff/κ admission",
          result["status"] == "PASS_P104_FULLFRAME_ENDCUT_CORRECTION"
          and transport["status"] == "PASS_P104_FULLFRAME_ENDCUT_NATIVE_TRANSPORTS"
          and "No recursive" in result["scope_limit"])

    # Digests (packaging defects)
    corr_actual = sha(pkg / "CORRECTION.json")
    tr_actual = sha(pkg / "TRANSPORTS.json")
    check("D1 RESULT.correction_sha256 stale vs CORRECTION.json bytes (packaging defect)",
          result["correction_sha256"] != corr_actual
          and len(result["correction_sha256"]) == 64,
          {"sealed": result["correction_sha256"], "actual": corr_actual})
    check("D2 TRANSPORT-RESULT.transport_sha256 stale vs TRANSPORTS.json bytes (packaging defect)",
          transport["transport_sha256"] != tr_actual
          and len(transport["transport_sha256"]) == 64,
          {"sealed": transport["transport_sha256"], "actual": tr_actual})

    bc, cf, c = result["base_channel"], result["combined_finite_word"], result["correction"]
    check("C1 base channel: events 4058 == sum(event_counts); rank_mass 2368 == paid_profile mass",
          bc["events"] == 4058 == sum(bc["event_counts"].values())
          and bc["rank_mass"] == 2368 == mass(bc["paid_profile"]))
    check("C2 combined word: 4058+5200=9258 events; rank_mass 2576; transports 1618=1410+208",
          cf["events"] == 9258 == bc["events"] + result["chosen_suffix_occupancy"]["events"]
          and result["chosen_suffix_occupancy"]["events"] == 5200
          and cf["rank_mass"] == 2576 == mass(cf["paid_profile"])
          and cf["transports"] == 1618 == bc["event_counts"]["transport"] + c["target_transports"])
    check("C3 correction: 4992 entries = 3376(-1/2)+1616(1/2); degrees 48; +208 rank-1 transports",
          c["entries"] == 4992 == sum(c["coefficient_counts"].values())
          and c["coefficient_counts"] == {"-1/2": 3376, "1/2": 1616}
          and c["row_degree"] == c["column_degree"] == 48
          and c["target_transports"] == 208 == c["transport_profile_delta"]["1"]
          == cf["paid_profile"]["1"] - bc["paid_profile"]["1"]
          and c["new_dirty_or_private_registers"] == 0
          and c["identity"] == "C = I - G/2, derived from the exact channel output rows")
    check("C4 TRANSPORT-RESULT: 208 native transports; targets 104; rank hist {1:208}; Pauli/phase checked",
          transport["exact_native_transports"] == 208 == transport["targets"] * 2
          and transport["targets"] == 104
          and transport["rank_histogram"] == {"1": 208}
          and transport["all_signed_pauli_actions_and_global_phases_checked"] is True
          and len(transports["records"]) == 208
          and len(corr["rows"]) == 104)

    check("S1 SOURCES rows complete (sha256+git_blob); RESULT.sources digests match SOURCES table where listed",
          all(len(f.get("sha256", "")) == 64 and len(f.get("git_blob", "")) == 40 for f in sources["files"]))
    src_map = {f["path"]: f["sha256"] for f in sources["files"]}
    bad = [p for p, dig in result.get("sources", {}).items() if src_map.get(p) != dig]
    check("S2 RESULT.sources digests agree with SOURCES.json for overlapping paths",
          not bad, bad)

    readme = (pkg / "README.md").read_text()
    check("N1 finite correction/transport invoice only; remote native-channel inputs not re-fetched",
          ("I - G/2" in c["identity"] or "I-G/2" in readme)
          and "No recursive" in result["scope_limit"])

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