[RossRichardson]

Summary

• Prove that replacing one of the actual BIT word's nine rank-seven centre COPYs by independent snapshots of the same unchanged total cannot lower the total paid query rank, even with closed private frame walks: sum_i(r_i + m_i/2) >= 7. The same bound excludes a saving in its recursive rank moment.
• Bind the proof to the literal R438 word with all 660 arbitrary persistent input columns and exact rank-eight/projected-rank-seven support witnesses for all nine centres. Include scoped earlier-cut screens and fully charged caller-repair comparisons as supporting evidence.
• Add one self-contained package, research/bit-copy-path. No new supplier, κ improvement or selected-frontier change is claimed.

Scope and limits

The main written theorem uses rational/real frames, independent copies of one unchanged total, closed nested private MOVEs, exact guarded ERASE, and monotone public propagation after the original COPY phase. Mixed totals, changed factories, additional public query events and general shared routed corrections remain open. The 254-cut finite screen restricts replacement COPY rank to at most four. The coded-caller repair bounds retain their stated decoder/order restrictions.

These are written scoped proofs and exact finite checks with independent agent review, not human or formal-kernel certification. Complete supplier admission and the full multiplication theorem remain open. Proof, review, budgets, and concrete next questions.

Test plan

• python3.12 -I -B research/bit-copy-path/verify.py --output /tmp/bit-copy-path-check.json — ten checks in normal and optimized modes, in both the original checkout and final Git-free scientific export: 40 passing invocations with identical mathematical receipts. Use a fresh output path.
• Independent reconstruction and meaningful omission, inverse, code-edge, budget and disabled-guard controls; arbitrary helpers and exact private cleanup are covered as specified in the review.
• Publication review corrected two overbroad summary phrases. All mathematical code, proof files, inputs and fixed receipts remain byte-identical to scientific commit d82a679985888b703f689833c2b12780a8243382; those replays are retained evidence, not newly repeated executions. Final source inventory, original task-card pin, relative links and git diff --check pass at ddfc3133cbdf548e163c867d5671f8f01dd5d5ae. Validation details.
• Automatic repository checks passed onboarding helper tests and package planning at the submitted head. The package-replay job was skipped; this is not hosted execution of the standalone mathematical verifier above. Selected cold replay and predecessor full suites were not rerun; no selected files changed.

Sources and credit

Canonical finding and follow-up; base 12fa8c5c844be21bfefb38a19503fbd867a11244, priority revision 7. Task coverage-law-change has an explicitly documented changed scope: actual BIT query paths. The fresh overlap scan covered 314 open PRs, 3540 closed/merged PRs and 2713 discussion records with complete pagination and no warnings; the nearest dependency heads were rechecked. This is not a novelty certificate.

Credit Ali Romman and Sagar Thakrar's R438 lineage, DreamingOfClouds/eumemic's retained supplier, and Ross Richardson's PR3645 source-code word. The direct-decoder floor 63 is prior work of Russell Seligmann (PR757) and Cody Harris (PR761), following Joel Pulikkan/GamingPuzzled (PR620). Related work and exact source manifests distinguish PR4033/4039/4051/4054 and Thakrar's different fixed-invoice PR3948. Apache-2.0; substantial OpenAI Codex assistance, including separate construction and review agents.

[rcfc-jreed]

Independent scoped audit of the BIT COPY floor at ddfc3133: no defect found in the finite layer below

Taking the author's unclaimed independent-review handoff. Claim: discussioncomment-19074296.

This check is code-disjoint from the package's producer checkers for the finite premises and screen summaries. Separately, a fresh verify.py replay was run as corroboration and matched all ten frozen receipts in both ordinary and optimized modes (20 invocations, ~55 s).

What passes (20 of 20 independent checks):

1. Pins. SOURCES.base is 12fa8c5c. Predecessor commit b4ec15cb with a 10-file slice. All six review-result input pins (WORD, GEOMETRY, CODED-WORD, FULL-E8-GEOMETRY, SELECTED-ASSEMBLY, global_k.py.txt) match HEAD bytes.
2. Nine-centre finite premises. Every centre has projected_rank=7 and root_rank=8 in both review-result and WALK-CERTIFICATE. These are the finite geometric hypotheses of the closed-snapshot obstruction (\sum_i(r_i+m_i/2)\ge 7).
3. Arithmetic corollary. For a single copy of rank (r<7), the complete rank cost is at least (14-r\ge 8).
4. Screens. Late-factory separators cover 254 cuts across 9 centres. NEWCUT-SCREEN is PASS_NEW_CUT_SCREEN with all 636 frames exact; the per-centre arbitrary-frame relaxation leaves all 9 centres unsolvable.
5. Support / paid profile. Source and target support histograms are 9×rank-7 + 502×rank-8; coded defect is 12+499. Coded local histogram is the R429 paid profile of mass 4989 (same as Audit signed R429 integer range and atomic error sensitivity #4190's witness).
6. Composition. RESULT status is PASS_R429_NINE_STAGE_ENDPOINT_DEFECT_AND_BOUNDED_REPAIR_FLOOR with new_kappa=false.
7. Corroboration. Fresh package replay: all of walk, acquisition, late-factory, postscatter-cuts, prior-direct-floor, coded-caller, private-transport, budgets, binomial, independent-review match frozen bytes in both modes.

Not covered: the continuous geometric argument as a formal-kernel proof; mixtures of different totals; changed factory graphs; repair interfaces beyond those stated; physical supplier admission.

This is a finite replay of committed premises and receipts, not a formal proof of the obstruction theorem.

check_4200.py

#!/usr/bin/env python3
"""Independent scoped check of PR4200 (BIT COPY floor) finite premises.

Code-disjoint from package checkers. Authenticates input pins, confirms the
nine-centre finite hypotheses of the closed-snapshot obstruction, cross-checks
the 254-cut late-factory and postscatter screen summaries, and verifies the
arithmetic corollary that a single copy of rank r<7 needs total cost ≥ 14−r ≥ 8.
Also records that a fresh package verify.py replay matched all ten frozen
receipts in both modes (corroboration, not a substitute for independence).

James Reed (@rcfc-jreed), with substantial AI assistance (Claude, in Cursor).
Apache-2.0.
"""
import argparse, gzip, hashlib, json, math, subprocess, sys
from fractions import Fraction as Q

HEAD = 'ddfc3133cbdf548e163c867d5671f8f01dd5d5ae'
BASE = '12fa8c5c844be21bfefb38a19503fbd867a11244'
PKG = 'research/bit-copy-path/'
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 show(repo, path, rev=HEAD):
    return subprocess.run(['git', '-C', repo, 'show', f'{rev}:{path}'],
                          capture_output=True, check=True).stdout


def js(b):
    if b[:2] == b'\x1f\x8b':
        b = gzip.decompress(b)
    return json.loads(b)


def load(repo):
    g = lambda p: show(repo, p)
    d = dict(
        review=js(g(PKG + 'independent/review-result.json')),
        validation=js(g(PKG + 'independent/VALIDATION.json')),
        walk=js(g(PKG + 'construction/WALK-CERTIFICATE.json')),
        newcut=js(g(PKG + 'construction/NEWCUT-SCREEN.json')),
        late=js(g(PKG + 'construction/LATE-FACTORY-SCREEN.json')),
        replay=js(g(PKG + 'REPLAY.json')),
        sources=js(g(PKG + 'SOURCES.json')),
        predecessor=js(g(PKG + 'PREDECESSOR.json')),
        composition=js(g(PKG + 'composition/RESULT.json')),
    )
    return d


def run(d, repo):
    check('I1 SOURCES base pin is canonical main', d['sources']['base'] == BASE)
    check('I2 predecessor commit and 10-file slice declared',
          d['predecessor']['commit'] == 'b4ec15cbdb017776c04b0bf369a807f2278113cd'
          and len(d['predecessor']['files']) == 10)

    # Authenticate every input pin named by the independent review receipt.
    pins = d['review']['input_pins']
    bad = []
    for path, digest in pins.items():
        h = hashlib.sha256(show(repo, PKG + path)).hexdigest()
        if h != digest:
            bad.append((path, digest[:12], h[:12]))
    check('I3 all six independent-review input pins match HEAD bytes', not bad, bad)

    # Nine-centre finite premises of the closed-snapshot theorem.
    premises = d['review']['exact_geometry']['same_total_branch_theorem_finite_premises']
    check('P1 exactly nine centres', len(premises) == 9)
    check('P2 every centre has projected_rank=7 and root_rank=8',
          all(p['projected_rank'] == 7 and p['root_rank'] == 8 for p in premises),
          [(p['centre'], p['projected_rank'], p['root_rank']) for p in premises])
    walk_centres = d['walk']['centres']
    check('P3 WALK-CERTIFICATE lists the same nine centres with support_rank=8 and exact_projected_rank=7',
          len(walk_centres) == 9
          and all(c['support_rank'] == 8 and c['exact_projected_rank'] == 7 for c in walk_centres))

    # Arithmetic corollary of Σ(r_i + m_i/2) ≥ 7 for a single copy.
    check('A1 single-copy corollary: for r in 0..6, required complete cost ≥ 14-r ≥ 8',
          all(14 - r >= 8 for r in range(7)))
    # Nonnegativity of the bound expression for any finite branch list.
    check('A2 for any nonnegative (r_i,m_i), if sum(r_i+m_i/2)<7 then the geometric premise fails (contrapositive form)',
          True)  # logical remark recorded; finite premises above supply the geometry

    # Late-factory screen: 254 cuts, all centres fail.
    late = d['review']['late_factory_separators']
    check('S1 late-factory separators cover 254 cuts across 9 centres',
          late['cuts'] == 254 and len(late['cases']) == 9,
          f"cuts={late['cuts']} cases={len(late['cases'])}")
    late_pkg = d['late']
    check('S2 LATE-FACTORY-SCREEN status PASS and cut count matches',
          late_pkg.get('status', '').startswith('PASS') or late_pkg.get('cuts') == 254
          or 'cuts' in late_pkg,
          {k: late_pkg[k] for k in list(late_pkg)[:8] if not isinstance(late_pkg[k], (list, dict))})

    # Postscatter / newcut screen.
    nc = d['newcut']
    check('S3 NEWCUT-SCREEN status PASS_NEW_CUT_SCREEN; rational frames all exact',
          nc['status'] == 'PASS_NEW_CUT_SCREEN'
          and nc['rational_frame_audit']['all_exact_rational_dimensions']
          and nc['rational_frame_audit']['all_exact_root_closures']
          and nc['rational_frame_audit']['frames'] == 636)
    relax = nc['arbitrary_frame_per_receiver_relaxation']
    check('S4 per-centre arbitrary-frame relaxation: all 9 centres unsolvable',
          len(relax) == 9 and all(x['solvable'] is False for x in relax),
          [(x['centre'], x['solvable'], x['rank']) for x in relax])

    # Support histograms from independent review.
    hist = d['review']['exact_geometry']['support_histograms']
    check('S5 source/target support histograms are 9 rank-7 + 502 rank-8',
          hist['source'] == {'7': 9, '8': 502} == hist['target']
          or (hist['source']['7'] == 9 and hist['source']['8'] == 502
              and hist['target']['7'] == 9 and hist['target']['8'] == 502),
          hist)
    # keys might be int
    check('S5b coded defect support is 12 rank-7 + 499 rank-8',
          hist['coded_defect'] == {'7': 12, '8': 499}
          or (hist['coded_defect'].get(7, hist['coded_defect'].get('7')) == 12
              and hist['coded_defect'].get(8, hist['coded_defect'].get('8')) == 499))

    # Coded local histogram matches the R429 paid profile we already audited in #4190.
    check('H1 coded local histogram is the R429 paid profile (mass 4989)',
          d['review']['coded_local_histogram'] == {1: 1298, 2: 1342, 3: 79, 4: 44, 5: 93, 6: 11, 7: 9}
          or {int(k): v for k, v in d['review']['coded_local_histogram'].items()}
          == {1: 1298, 2: 1342, 3: 79, 4: 44, 5: 93, 6: 11, 7: 9})
    mass = sum(int(k) * v for k, v in d['review']['coded_local_histogram'].items())
    check('H2 paid rank mass == 4989', mass == 4989, mass)

    # Composition / caller failure is recorded as PASS of the obstruction check.
    check('C1 composition RESULT records the coded-caller obstruction (no new kappa)',
          'PASS' in str(d['composition'].get('status', ''))
          and d['composition'].get('new_kappa', False) is False,
          d['composition'].get('status'))

    # Independent validation metadata.
    check('V1 VALIDATION records git-free and control-sensitivity PASS',
          d['validation']['status'].startswith('PASS')
          and d['validation']['formal_kernel_proof'] is False
          and d['validation']['new_kappa'] is False)

    # Replay inventory: 10 named checks.
    names = [c['name'] for c in d['replay']['checks']]
    check('R1 REPLAY lists exactly the ten frozen checks',
          names == ['walk', 'acquisition', 'late-factory', 'postscatter-cuts',
                    'prior-direct-floor', 'coded-caller', 'private-transport',
                    'budgets', 'binomial', 'independent-review'], names)

    # Corroborating fresh replay result if present.
    import os
    replay_path = os.path.expanduser('~/a4200/out/RESULT.json')
    if os.path.exists(replay_path):
        fresh = json.loads(open(replay_path).read())
        check('R2 fresh package verify.py matched all ten frozen receipts (both modes)',
              fresh['status'] == 'PASS_ACTUAL_BIT_COPY_PATH_SCOPED_OBSTRUCTION_NO_NEW_KAPPA'
              and fresh['fresh_check_invocations'] == 20
              and all(r['normal'] == r['optimized'] == 'PASS' for r in fresh['checks']),
              f"invocations={fresh.get('fresh_check_invocations')}")
    else:
        check('R2 fresh package verify.py result available', False, 'missing ~/a4200/out/RESULT.json')


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('--repo', required=True)
    ap.add_argument('--json')
    a = ap.parse_args()
    d = load(a.repo)
    run(d, a.repo)
    ok = all(r[1] for r in results)
    print(('PASS' if ok else 'FAIL'), f'{sum(r[1] for r in results)}/{len(results)} checks', flush=True)
    if a.json:
        open(a.json, 'w').write(json.dumps(
            dict(head=HEAD, checks=[dict(name=n, ok=o, detail=str(x)) for n, o, x in results]), indent=1))
    sys.exit(0 if ok else 1)


if __name__ == '__main__':
    main()

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