Prove native-history action coupling and reduce the QQ16 comparison

[Clear1nsight]

Result and construction decision

#4167 left a concrete obstruction to pricing QQ16 against fair B/B*: closed Ordinary engines retain different free-slot orders, and native parking serializes those slot identities. This package supplies a source-bound phased allocator/codec action theorem, with actual fitted and recursive-return evidence. No queue reset, new engine or physical tape is introduced. It also proves successful coefficient-payload action opacity at fixed complete geometry, so the retained changed-core calls do not require separate numerical body prices.

This is one Class C substantial enabling context result, not another caller installation, parking comparison or ownership exchange. It removes the body/history residual on all 510,646 Gamma retained occurrences, including the complete 493,097 Gamma later suffix. It does not establish QQ16's total incremental sign. The fixed recovery mechanism stops here until the remaining necessary comparison is priced.

Native history and actual evidence

The relation pairs active logical numerical handles, aliases, values, widths and heads, then pairs free stacks by position. On recursive suspension it saves the parent map, permits a different active child map, and restores the original parent Word objects from their encoded slot records. One fixed global permutation is neither required nor asserted. Sorted parking changes record order, but equal per-bank record extents and the literal codec's bit-shape law preserve R/W/unit-move counts.

All 490 actual parking transitions are checked for binary-counterpart completeness and collapse to 360 action-shape classes. Missing-counterpart and bit-dependent-movement controls reject. Actual legal source allocations/frees followed by park, child reuse and restore produce different slot labels but identical action triples (1273,460,1168); the child-excluded complete park/restore bill is (1179,428,1068).

The genuine fitted Ordinary discriminator reaches five different entry queues, including both native runtime arenas, through completed fallback/fitted histories. Both identical target calls use 79,543,744 reads; 23,380,814 writes; 82,873,286 unit moves. An additional complement of the nonconstant payload has the same action counts. These are finite observations, not the universal proof. The reduced declared grammar uses execute_plan, not production select admission. All six arenas are inventoried; the remainder arena is unused in this zero-remainder fixture.

A separate actual width-four native root reaches its first real width-two child return. Its independent child endpoint, original parent slots/values/heads, saved PC/mode/root, borrowed input and paused roles pass. The parent program is deliberately not completed; explicit disposal is separately metered. The inherited #4167 reduced prefix/both-bridge-legs/suffix fixture is replayed in a separate authenticated process.

The exact BLANK-versus-LEFT output correction is one write. Actual complex calls have matched warm-erased Ordinary markers. A new whole-epoch proof prices original controller first use at 703 writes once; B and D each retain one original child backend, so those potentials cancel globally. Empty live sets still do not prove absence of escaped PhysicalWord references; source ownership remains explicit.

Complete incremental consequence

With the source-bound descriptor equality and successful-payload proof, all retained complete C bodies can cancel. Their caller headers still cost 14,298,088 Gamma extra actions. Let E_r(g) be the complete original external C call at its actual geometry and named marker class, including descendants once. Then:

T_D - T_B = Delta_N + Delta_shell + 14298088 Gamma
              + 368 Gamma E_1(g) - 16 Gamma E_8(g).

Delta_N retains acquisition/compiler work, all producer/service nonchild arithmetic and bank movement, publication/disposal, constructors and final cleanup. Delta_shell retains unmatched child preparation/return protocols. The service descriptor compiler recovers the same per-owner unused rows U as the producer; rank alone is not used to aggregate E_1. Unrelated upper-bound subtraction is not performed.

Frozen D versus stronger B* additionally owes B*'s already proved return saving. A fair both-adopt equation is stated only for a separately implemented compatible D*, not silently credited to frozen D. The earlier whole-bank and generic parking savings remain credited exactly once. Finite-control tariffs and historical per-role backing remain separate; equal source actions are not equal Python runtime or equal space.

The actual Ordinary invocation count is zero for one-column monomials, otherwise outer_rows*(4*early+12*late). Root callbacks are not reset sites. The signed full-bank group-volume increase is (281593/816) Gamma B_bank, labelled a geometric diagnostic rather than the total action difference. No wider decoder/recovery search is justified while E_1/E_8 and the complete nonchild/shell prices remain unpriced.

Verification and source scope

Scientific main 12fa8c5c844be21bfefb38a19503fbd867a11244, priority revision 7. Frozen #4167 6749e458800f461535d64cc91c017552d9f55e5f is retained as an authenticated executable archive; #4166 remains 0b082d22a0e9a442d264ab0633e35ef26c790630. Canonical inputs are blob/SHA-bound and authenticated before execution. Publication head: 59b46625a8b2f0dfff3e38ba0949b4247423938a.

python3.12 -B scripts/research_package.py --package research/qq16-native-history runs fresh ordinary and optimised scientific replays plus source/export/typed-receipt boundaries. Fresh ordinary and optimised scientific replays and all six boundary groups passed under CPython 3.12.3 (final boundary run 47.948 seconds). Committed-byte/source-history preflight passed for 108 files at 59b46625a8b2f0dfff3e38ba0949b4247423938a, with scientific base 12fa8c5c844be21bfefb38a19503fbd867a11244 ancestry. The official export/check passed for 108 payload files plus manifest. Actual committed ordinary/optimised Git-free read-only replays passed in 274.784/270.929 seconds, empty stderr, unchanged bytes/modes/mtimes/inodes. Archive SHA256 79dbd35b8ea69d1b307f044b23b1fa9c380a720cd7f78319b14d3926a15a9be4. Read-only assisted adversarial review found no unresolved blocker at the frozen source map; it shares sources/checkers and is not human or formal-kernel acceptance. Hosted CI is a separate status.

Production O73, complete RootLayer.run, a completed nonleaf native root, all-node substitution and supplier/bootstrap/exponent consequences were not executed or proved. Original successful source/native/ordinary/Compact, exact width/grid/range, stock/depth, hosting and long-record hypotheses remain. Selected kappa is unchanged at 836330098538459/500000000000000000.

Task, overlap and credit

Assigned joint-query-controller, scope 73442cf25caf1ed45f11, refined to the missing #4167 native-history implication and complete fair-baseline threshold. Entry and pivot main/priority were unchanged; named dependency heads/reviews and bounded all-state PR/Discussion searches were refreshed. Capped/cache-limited results and unavailable helper remote coverage do not establish novelty. The canonical #3985 handoff preserves prior results and will point to this single integrated contribution.

Credit Jose Manuel/#2899/#3385 and the retained numerical/physical/Compact authors; ywz65's numerical parking lineage; Sagar Thakrar/#3464; Tekalign/#3380 and #4167's already credited adaptation; Ali Romman/QQ16, Arham Tahir and #3985/#4015/#4106/#4109/#4129/#4166/#4167. Ross Richardson/#2831, Nick Petalas/#2923/#2982/#2951, commdata2338/#3233 and Wentao Li/#3993 are reused with explicit source/domain limits in REUSE.json. No BIT, Word-array, ADD or wrapper coefficient is transplanted. Chris R/Clear1nsight with substantial coordinated OpenAI Codex assistance. Original notices are retained.

Submission refresh: canonical main remains 12fa8c5c844be21bfefb38a19503fbd867a11244, priority 7. #4167 remains open at its frozen head, #4166 and all seven named dependencies retain their preparation heads, and the connector returned no new review/comment entries. Final bounded all-state searches for PhysicalArena/history and codec/equivariance returned zero and two results respectively; #3967 is a different R437/BIT caller scope and supplies no imported theorem here. The newest #1166 page was checked through visible 20 October entries; the index and #2727 include cached/limited material. Coverage is not exhaustive and does not establish novelty.

Start with PROOF, native context, complete comparison, and the canonical handoff.

Open next questions

Price E_1(g), E_8(g), Delta_shell and Delta_N from the actual geometric source execution, then decide the necessary inequality against B*. A reset study is no longer required for this source-action model. A changed demand is a distinct explicit premise; no fixed-mechanism expansion follows from this context theorem alone.

[rcfc-jreed]

Independent scoped audit of the QQ16 native-history coupling package at 59b46625: packaging defect on bill_sha256; scientific finite census/seal layer otherwise consistent

Code-disjoint reimplementation; does not import package verify.py / comparison.py / lifecycle.py. Package bytes from head 59b46625a8b2f0dfff3e38ba0949b4247423938a via GitHub contents API. CLAIM. Full remote authentication of all 79+ SOURCES inputs was not re-fetched in this run (overlap digests checked locally).

Defect (D1): RESULT.json bill_sha256 is stale versus current BILL.json bytes. No metadata-addendum records the drift. Local SEALS / REVIEW.frozen_files / physical_receipt_sha256 still bind.

pin	sealed	actual
bill_sha256	d1b141c3…50205f	1ba48938…ad4b6ed

What passes (21 of 21 with D1 asserting the defect):

1. Pins. Base 12fa8c5c…; predecessor #4167 6749e458…; κ unchanged; qq16_sign unresolved; no new supplier/frontier; REVIEW blocking empty.
2. Seals / receipts. 17 SEALS + REVIEW frozen + local_seals match; physical_receipt_sha256 = canonical EXECUTION.json; PR4167.tar matches MANIFEST.
3. Census arithmetic. A/B 510662/1041408; C_D +16/−96; retained 510646; header actions 14298088; changed-core 6972; reduced difference constants match.

Not covered: live verify.py re-execution; remote SOURCES byte fetch for all authenticated inputs; full QQ16 sign; production RootLayer.

This is a finite replay of committed receipts, not a formal proof. Suggested fix: refresh RESULT.bill_sha256 to the current BILL.json digest.

check_4172.py

#!/usr/bin/env python3
"""Independent finite controls for PR4172 (QQ16 native-history coupling).

Recomputes literal census rank masses, seal tables, EXECUTION receipt hash,
and reduced-difference constants. Does not import package verify.py / comparison.py.

Package head 59b46625a8b2f0dfff3e38ba0949b4247423938a via GitHub API.
Full SOURCES remote authentication of 79+ inputs is out of scope for this run.

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 = "59b46625a8b2f0dfff3e38ba0949b4247423938a"
BASE = "12fa8c5c844be21bfefb38a19503fbd867a11244"
KAPPA = "836330098538459/500000000000000000"
PRED = "6749e458800f461535d64cc91c017552d9f55e5f"
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(ranks):
    return sum(int(r) * int(c) for r, c in ranks.items())


def run(pkg: Path):
    sources = load(pkg, "SOURCES.json")
    result = load(pkg, "RESULT.json")
    bill = load(pkg, "BILL.json")
    seals = load(pkg, "SEALS.json")
    review = load(pkg, "REVIEW.json")
    admission = load(pkg, "ADMISSION.json")
    execution = load(pkg, "EXECUTION.json")
    manifest = load(pkg, "inputs/PR4167-MANIFEST.json")
    verify = load(pkg, "VERIFY.json")

    check("I1 scientific_main / SOURCES base == 12fa8c5c…",
          sources["base_commit"] == BASE == result["scientific_main"]
          == admission.get("scientific_base", BASE))
    check("I2 RESULT PASS_QQ16_NATIVE_HISTORY; qq16_sign unresolved; kappa unchanged",
          result["status"] == "PASS_QQ16_NATIVE_HISTORY"
          and result["qq16_sign"].startswith("unresolved")
          and result["unchanged_kappa"] == KAPPA
          and result["runtime_resets"] == 0
          and result["new_physical_tapes"] == 0)
    check("I3 REVIEW PASS; zero blocking defects; ADMISSION no new supplier / frontier",
          review["status"] == "PASS_SCOPED_ASSISTED_ADVERSARIAL_REVIEW"
          and review["blocking_defects"] == []
          and admission["new_supplier_admitted"] is False
          and admission["selected_frontier_changed"] is False
          and verify["status"] == "ready")
    check("I4 frozen predecessor #4167 head + archive pin",
          result["frozen_predecessor"] == PRED
          == sources["retained_predecessor"]["head"]
          == manifest["head"]
          and sources["retained_predecessor"]["archive"] == "inputs/PR4167.tar")

    # Seals
    seal_bad = [k for k, dig in seals.items() if sha(pkg / k) != dig]
    check("S1 SEALS.json matches package bytes (17 entries)",
          not seal_bad and len(seals) == 17, seal_bad)
    local_bad = [k for k, dig in result["local_seals"].items() if sha(pkg / k) != dig]
    check("S2 RESULT.local_seals match package bytes", not local_bad, local_bad)
    frozen_bad = [k for k, dig in review["frozen_files"].items() if sha(pkg / k) != dig]
    check("S3 REVIEW.frozen_files match package bytes", not frozen_bad, frozen_bad)
    check("S4 SEALS == RESULT.local_seals; verify.py binds REVIEW final_verifier",
          seals == result["local_seals"]
          and review["final_verifier_sha256"] == sha(pkg / "verify.py") == seals["verify.py"])

    # Packaging defect: bill_sha256 stale
    actual_bill = sha(pkg / "BILL.json")
    check("D1 RESULT.bill_sha256 stale vs current BILL.json (packaging defect)",
          result["bill_sha256"] != actual_bill
          and len(result["bill_sha256"]) == 64,
          {"sealed": result["bill_sha256"], "actual": actual_bill})

    # EXECUTION receipt
    canon = json.dumps(execution, sort_keys=True, separators=(",", ":")).encode()
    check("E1 physical_receipt_sha256 == canonical JSON of EXECUTION.json",
          hashlib.sha256(canon).hexdigest() == result["physical_receipt_sha256"])
    check("E2 EXECUTION fitted PASS; native nested child endpoint + roles retired",
          execution["fitted"]["status"] == "PASS_LEGAL_FITTED_HISTORY_DISCRIMINATOR"
          and execution["native_nested"]["child_endpoint_checked"] is True
          and execution["native_nested"]["all_engine_roles_retired"] is True)

    # Predecessor archive
    check("A1 inputs/PR4167.tar sha256 matches MANIFEST.archive_sha256",
          sha(pkg / "inputs/PR4167.tar") == manifest["archive_sha256"]
          == "68ff3b4b541434cb9df15884d027838cbc80300e9d78015eb82c395c5168d166")

    # Auth table consistency (local; no remote fetch)
    auth = result["authenticated_inputs"]
    mismatch = [f["path"] for f in sources["files"]
                if f["path"] in auth and auth[f["path"]] != f["sha256"]]
    check("A2 RESULT.authenticated_inputs digests agree with SOURCES.sha256 where overlapping",
          not mismatch and len(auth) == 106 and len(sources["files"]) == 79, mismatch)

    # Literal census
    lc = bill["literal_census"]
    bad_m = []
    for key, row in lc.items():
        if not isinstance(row, dict) or "ranks" not in row:
            continue
        if row["rank_mass"] != mass(row["ranks"]) or row["calls"] != sum(row["ranks"].values()):
            bad_m.append(key)
    check("C1 all literal_census rank_mass/calls match ranks maps", not bad_m, bad_m)
    a, cd, ret = lc["A_original"], lc["C_D_root"], lc["retained"]
    check("C2 A=510662/1041408; C_D=+16 calls/−96 mass; retained=510646",
          a["calls"] == 510662 and a["rank_mass"] == 1041408
          and cd["calls"] - a["calls"] == 16 and a["rank_mass"] - cd["rank_mass"] == 96
          and ret["calls"] == 510646 == a["calls"] - 16
          and lc["changed_core_retained_calls"]["calls"] == 6972)
    check("C3 retained_prefix+suffix == retained; B profiles identical to A",
          lc["retained_prefix"]["calls"] + lc["retained_suffix"]["calls"] == ret["calls"]
          and lc["B_protocol_only"]["ranks"] == a["ranks"]
          == lc["B_shared_protocol_only"]["ranks"])
    cen = bill["census"]
    check("C4 census header actions 14298088; root_installed 510678; changed_core 6972",
          cen["all_retained_header_actions_per_Gamma"] == 14298088
          and cen["root_installed_per_Gamma"] == 510678
          and cen["counts_per_Gamma"]["changed_core"] == 6972
          and cen["counts_per_Gamma"]["original"] == 510662
          and cen["counts_per_Gamma"]["removed"] == 16
          and cen["counts_per_Gamma"]["added"] == 32)

    check("R1 complete_reduced_difference matches README/RESULT constants",
          result["complete_reduced_difference"]
          == "Delta_N + Delta_shell + 14298088 Gamma + 368 Gamma E1(g) - 16 Gamma E8(g)")
    check("R2 BILL scientific_claim keeps QQ16 sign open; remaining_terms nonempty",
          "prevent a full QQ16 sign" in bill["scientific_claim"]
          and len(bill["remaining_terms"]) >= 4)
    check("N1 RESULT.remaining excludes production RootLayer / new exponent / formal kernel",
          any("RootLayer" in x for x in result["remaining"])
          and any("formal-kernel" in x for x in result["remaining"]))

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