Admit delayed carrier retirement to the full logical BIT recursion

[RossRichardson]

Change and mathematical scope

The changed downstream compensation saves one local recursive query (2913 → 2912) and 58 unit ADDs. The new owner/controller admission assigns all 126,144 helper occurrences and charges every idle return. The full nine-stage, 32-replica template therefore uses 902,592 paid requests instead of 902,880, with unchanged rank mass 1,808,352 and live stock 28,416. Both original rank-two helper queries remain.

The new Catalogue/Topology adapter binds this word to the retained all-size logical p=1 caller, including the current source50 reads, arbitrary dirty inputs, coefficient grammar, complete spectator packets, compatible row stock, private cleanup, active ancestors and logical storage. The proof gives < 11 V_root + F_q' live logical symbols on its stated canonical, root-coupled domain.

After conservative BIT fallback, the matched moment root improves from (0.001737388318390108294399, 0.001737388318390108294400) to (0.001737631818486007553483, 0.001737631818486007553484). The separating rate b=139/80000 gives the actual logical bound

T(n,w) <= 200 C n + 2400000 C n^(1-b) w.

Here T is logical Tape work normalized by fresh-row payload. The constant C is uniform on the stated input domain for fixed prime q > 2^80; it is not the finite scalar invoice coefficient. This improves the sufficient power bound; it does not order total invocations or runtimes at every finite width. At parent width 640 the new rank-seven child has width 70 and recurses, while the removed rank-six child had width 60.

The finite invoice includes 5,760 additional returned idle ranks, source selectors, chart inverses, bridges and private work under its retained implementation contracts and selector-factorization prime exclusions. Scalar envelopes are charged at 128/256 bits, with a 512-bit depth-two allowance; these are separate from variable address precision w. Those historical selector exclusions do not restrict the actual logical caller's dyadic routes. Fixed physical-tape lowering, stronger primitive tariffs, exact rounded-child cleanup and outer assembly remain open. No new selected κ is claimed: the unchanged complex supplier remains limiting.

Admission and next questions · Caller proof · Independent source review · Complete recurrence.

Task and overlap

User-assigned recursive admission of PR4183; catalogue card bit-new-register-model is retained with declared changed scope. Scientific base: 12fa8c5c844be21bfefb38a19503fbd867a11244. The admission package pins the original local result at 928066009267fb32ab2c1a29b50fa3093ea18aef; its source package and integer-output-preserving variant remain unchanged.

• PR4068, 5a34918402ae2c0c683d8820ad832970e77f6382: the shared-source packet.
• PR4021, c01f97ecfc7fa64847f6abd8f7b231e1df8c7b70: five rank-four terminals; their returned idle work is now admitted and paid.
• PR4179, de9deae2b787143923c0a504fbcc3871d01cff0b: its fixed complete-join floor is unaffected; this changes downstream compensation.

The final overlap refresh at 13:04 UTC on 2026-10-20 covered 312 open PRs and 2,709 Discussions with complete pagination, plus local metadata. These title/body matches are leads, not a novelty certificate. Exact source pins and retained caller/component notices are included.

Validation

Python 3.12, standard library only:

python3.12 -B scripts/research_package.py --package research/bit-carrier-owner-admission
python3.12 -B scripts/check_research_commit.py --package research/bit-carrier-owner-admission --check-source-history

At commit 59a1d97a86ea82b4d62958d705709ea46d7509f1, both complete registered modes (normal and optimized Python), committed-byte/source-history checks and metadata/source pins passed. The committed export passed integrity checks and the complete normal replay in a fresh, inode-disjoint, read-only Git-free tree.

Coverage includes independent serialized owners, all 660 signed input columns, both orientations/inverse orders, complete 5/9/11-stage Boolean columns, source-cut restoration controls and two independent rational interval methods. The caller checks all 11,193,984 candidate literal events, 549 split bases and 444 exact chart identities, plus Consumer/route/threshold bindings. Frame fixtures execute the actual context/return machinery with controlled 23-bit child bodies and test-only stock 11; they do not run the enormous complete compatible-stock GL64 payload. The all-parameter claim uses the written induction. The four threshold fixtures additionally check 391,086 complete ordered events against uncached reference goldens. Only those finite fixtures memoize repeated addresses; this checker acceleration does not enter production cost or storage claims. The caller and registered-command limits remain 540 and 600 seconds.

Fresh unchanged C++ legality/cohort checks passed for both native words. The old 104-bit scalar checker rejects both with payloadfiniteprefix2^104; that is a rejection control, not a passing historical H1–H5 replay. Portable replay does not invoke C++. No formal-kernel proof or full physical multiplication theorem is claimed. Hosted CI is reported separately on the published commit.

Credit

Retain Ali Romman's R438/PR1043 source; Sagar Thakrar's allocation/windows; commdata2338's projector census; CubeJerry's native rehost; cheesegrader's framed owners; PR540/589 hosting and the retained controller authors; Jose Manuel's complete packets and compatible stock; David Arias's executable recursive caller; and the prior five-terminal charts. The original package retains its earlier kernel-entrance and R437-carrier credit.

Ross Richardson, with substantial OpenAI Codex assistance in mathematics, implementation, writing and separate AI reviews. No independent human review is claimed. Apache-2.0; frozen sources and notices are unchanged.

Open next questions

Lower the logical tapes and arenas to fixed physical tapes with paid access and head/template return; supply stronger route/leaf costs and exact rounded COPY cleanup; then bind the outer wrapper and address the limiting complex supplier. The package README and TASK.json give the concrete starting points and blockers.

[rcfc-jreed]

Independent scoped audit of delayed carrier retirement at 59a1d97a: no defect found in the finite query/owner/price layer

Code-disjoint reimplementation over pinned receipts; does not import package verify.py / native.py / owner.py / caller.py. CLAIM.

What passes (35 of 35):

1. Pins / statuses. canonical_scientific_base is 12fa8c5c. NATIVE / PRICING / CALLER / INDEPENDENT-OWNERS / RESULT all PASS. no_new_kappa everywhere. selected_kappa equals the frozen selected κ.
2. Local word. Paid queries 2913→2912; ADDs 36005→35947 (save 58); local rank mass stays 5101. Histogram delta {1:−1,6:−1,7:+1} on both orientations; COPYs=9, columns=660; both integer inverse orders.
3. Global bill. Children 902880→902592 (Δ=−288 = 1×288 calls); rank mass stays 1,808,352. matched_profile_delta {-288@1,−288@6,+288@7} has mass 0 and matches frozen→candidate. Live stock W=28416; m=64.
4. Owners. 126,144 helper occurrences (independent audit agrees); 28,416 live families; returned idle 180/replica → 5760 global; same-family pairs 5648×32=180736.
5. Price direction. Matched root gain > 0; RESULT Phi_m(1)+Phi_m(6)−Phi_m(7) saving_lower > 0.

Not covered: full logical p=1 caller induction as formal-kernel proof; Catalogue/Topology adapter semantics beyond status receipts; physical supplier admission; κ race (package correctly claims none).

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

check_4183.py

#!/usr/bin/env python3
"""Independent finite controls for PR4183 (delayed carrier retirement / BIT recursion).

Recomputes local query/ADD deltas, global child-count and rank-mass identities,
owner-occurrence totals, and pinned no_new_kappa / CALLER statuses from committed
receipts. Does not import package verify.py / native.py / owner.py / caller.py.

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

HEAD = '59a1d97a86ea82b4d62958d705709ea46d7509f1'
BASE = '12fa8c5c844be21bfefb38a19503fbd867a11244'
# Selected κ from the long-running race (#1094 family); PR claims no new kappa.
SELECTED_KAPPA = Q(836330098538459, 500000000000000000)
PKG = 'research/bit-carrier-owner-admission/'
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 mass(h):
    return sum(int(r) * int(c) for r, c in h.items())


def as_int(h):
    return {int(k): int(v) for k, v in h.items()}


def load(repo):
    g = lambda p: show(repo, PKG + p)
    return dict(
        sources=js(g('SOURCES.json')),
        native=js(g('NATIVE.json')),
        owners=js(g('OWNERS.json')),
        pricing=js(g('PRICING.json')),
        caller=js(g('CALLER.json')),
        independent=js(g('INDEPENDENT-OWNERS.json')),
        result=js(g('inputs/PR4183-RESULT.json')),
        verify=js(g('VERIFY.json')),
        manifest=js(g('MANIFEST.json')),
    )


def run(d, repo):
    n, o, p, c = d['native'], d['owners'], d['pricing'], d['caller']
    base_w, cand_w = n['words']['baseline'], n['words']['candidate']

    # --- Pins / status ---
    # This package records a later packaging base_commit but pins the scientific base.
    check('I1 SOURCES.canonical_scientific_base == 12fa8c5c…',
          d['sources']['canonical_scientific_base'] == BASE)
    check('I1b SOURCES.base_commit is recorded (packaging tip)',
          isinstance(d['sources']['base_commit'], str) and len(d['sources']['base_commit']) == 40)
    check('I2 NATIVE status PASS_SIGNED_LITERAL_PROVIDER_AND_BRIDGED_BOOLEAN_COLUMNS',
          n['status'] == 'PASS_SIGNED_LITERAL_PROVIDER_AND_BRIDGED_BOOLEAN_COLUMNS')
    check('I3 PRICING status PASS_COMPLETE_CONDITIONAL_RECURSIVE_PRICE',
          p['status'] == 'PASS_COMPLETE_CONDITIONAL_RECURSIVE_PRICE')
    check('I4 CALLER status PASS_NEW_SOURCE_BOUND_LOGICAL_RECURSIVE_CALLER',
          c['status'] == 'PASS_NEW_SOURCE_BOUND_LOGICAL_RECURSIVE_CALLER')
    check('I5 INDEPENDENT-OWNERS status PASS_INDEPENDENT_SERIALIZED_OWNER_AUDIT',
          d['independent']['status'] == 'PASS_INDEPENDENT_SERIALIZED_OWNER_AUDIT')
    check('I6 RESULT status PASS', d['result']['status'] == 'PASS')
    check('I7 no_new_kappa on NATIVE, PRICING, CALLER, RESULT',
          n['no_new_kappa'] is True and p['no_new_kappa'] is True
          and c['no_new_kappa'] is True and d['result']['no_new_kappa'] is True)
    check('I8 PRICING selected_kappa equals frozen selected κ',
          Q(p['selected_kappa']) == SELECTED_KAPPA, p['selected_kappa'])

    # --- Local word delta (2913→2912, 58 ADDs) ---
    check('L1 baseline paid_queries=2913, candidate=2912 (save one query)',
          base_w['paid_queries'] == 2913 and cand_w['paid_queries'] == 2912)
    check('L2 ADD bill 36005→35947 (save 58)',
          base_w['ADDs'] == 36005 and cand_w['ADDs'] == 35947
          and base_w['ADDs'] - cand_w['ADDs'] == 58)
    check('L3 local rank_mass unchanged at 5101',
          base_w['rank_mass'] == 5101 == cand_w['rank_mass'])
    bh = as_int(base_w['local_checks']['forward']['histogram'])
    ch = as_int(cand_w['local_checks']['forward']['histogram'])
    check('L4 forward histograms both mass 5101',
          mass(bh) == 5101 == mass(ch))
    local_delta = {k: ch.get(k, 0) - bh.get(k, 0)
                   for k in set(ch) | set(bh) if ch.get(k, 0) != bh.get(k, 0)}
    check('L4b hist delta is exactly {1:−1,6:−1,7:+1}',
          local_delta == {1: -1, 6: -1, 7: 1}, local_delta)
    check('L5 reverse histograms match forward for each word',
          as_int(base_w['local_checks']['reverse']['histogram']) == bh
          and as_int(cand_w['local_checks']['reverse']['histogram']) == ch)
    check('L6 both words keep COPYs=9 and columns=660',
          base_w['local_checks']['forward']['COPYs'] == 9
          and cand_w['local_checks']['forward']['COPYs'] == 9
          and base_w['local_checks']['forward']['columns'] == 660
          and cand_w['local_checks']['forward']['columns'] == 660)
    check('L7 both_integer_inverse_orders True on both words',
          base_w['signed_integer_checks']['both_integer_inverse_orders'] is True
          and cand_w['signed_integer_checks']['both_integer_inverse_orders'] is True)

    # --- Global pricing / children ---
    cand_p, froz_p = p['profiles']['candidate'], p['profiles']['frozen']
    check('G1 frozen children 902880 → candidate 902592 (Δ=−288)',
          froz_p['children'] == 902880 and cand_p['children'] == 902592
          and froz_p['children'] - cand_p['children'] == 288)
    check('G2 Δchildren = 1 query × 288 calls',
          1 * 288 == 288 == o['calls'])
    check('G3 rank_mass unchanged at 1808352 for frozen and candidate',
          froz_p['rank_mass'] == 1808352 == cand_p['rank_mass']
          and mass(as_int(froz_p['profile'])) == 1808352
          and mass(as_int(cand_p['profile'])) == 1808352)
    check('G4 matched_profile_delta {-288@1, −288@6, +288@7} has mass 0',
          as_int(p['matched_profile_delta']) == {1: -288, 6: -288, 7: 288}
          and mass(as_int(p['matched_profile_delta'])) == 0)
    fp, cp = as_int(froz_p['profile']), as_int(cand_p['profile'])
    global_delta = {k: cp.get(k, 0) - fp.get(k, 0)
                    for k in set(cp) | set(fp) if cp.get(k, 0) != fp.get(k, 0)}
    check('G5 profile delta equals matched_profile_delta',
          global_delta == as_int(p['matched_profile_delta']), global_delta)
    check('G6 W (live stock) = 28416; m = 64',
          p['W'] == 28416 and p['m'] == 64)
    check('G7 OWNERS live_families == 28416; full_helper_occurrences == 126144',
          o['live_families'] == 28416 and o['full_helper_occurrences'] == 126144)
    check('G8 OWNERS calls == 288; returned_idle_rank_global == 180×32 = 5760',
          o['calls'] == 288
          and o['returned_idle_rank_per_replica'] == 180
          and o['returned_idle_rank_global'] == 5760 == 180 * 32)

    # Matched root gain positive (improvement direction)
    gain_lo = Q(p['matched_root_gain']['lower'])
    check('G9 matched_root_gain lower bound > 0', gain_lo > 0, str(gain_lo))

    # RESULT price saving positive
    sav_lo = Q(d['result']['price']['saving_lower'])
    check('G10 RESULT price saving_lower > 0 (Phi_1+Phi_6−Phi_7)',
          sav_lo > 0 and d['result']['price']['formula'] == 'Phi_m(1) + Phi_m(6) - Phi_m(7)',
          str(sav_lo))

    # --- Owner / independent cross-check ---
    check('O1 occupied_physical_families 28096 ≤ live_families 28416',
          o['occupied_physical_families'] == 28096
          and o['occupied_physical_families'] <= o['live_families'])
    check('O2 same_family_pairs_per_replica 5648; global 5648×32 = 180736',
          o['same_family_pairs_per_replica'] == 5648
          and o['same_family_pairs_all_replicas'] == 5648 * 32 == 180736)
    check('O3 INDEPENDENT helper_occurrences equals OWNERS full_helper_occurrences',
          d['independent'].get('helper_occurrences') == o['full_helper_occurrences']
          or d['independent'].get('helper_occurrences') == 126144,
          d['independent'].get('helper_occurrences'))

    # --- CALLER finite flags ---
    check('C1 CALLER no_new_kappa and recursive probes present',
          c['no_new_kappa'] is True
          and 'recursive_new_rank7_frame_probe' in c
          and 'recursive_rank42_frame_probe' in c)

    # --- Negative controls ---
    check('NEG1 claiming children save without ×288 would miss 288≠1',
          froz_p['children'] - cand_p['children'] != 1)
    broken = dict(bh)
    broken[1] -= 1
    broken[6] -= 1
    check('NEG2 local hist delta without +7 would change rank mass',
          mass(broken) != 5101)
    check('NEG3 selected_kappa drift would fail equality',
          Q(p['selected_kappa']) != SELECTED_KAPPA + 1)

    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('--repo', required=True)
    args = ap.parse_args()
    head = subprocess.run(['git', '-C', args.repo, 'rev-parse', 'HEAD'],
                          capture_output=True, text=True, check=True).stdout.strip()
    check('HEAD is PR4183 tip 59a1d97a…', head == HEAD, head)
    return run(load(args.repo), args.repo)


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

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