From daa9b0e773b53f36d5b4c3f1c7524600e5714deb Mon Sep 17 00:00:00 2001 From: Peter Carpenter Date: Mon, 12 Oct 2026 22:27:23 -0700 Subject: [PATCH] Speed up exact retired-slot eligibility checks Add an opt-in source-pinned coordinate-mask index, complete word and candidate-sequence comparisons, negative controls, and same-input benchmarks against base sorting and PR175 buckets. No construction or kappa change. Prepared with substantial OpenAI Codex assistance. --- .../CLAIM.json | 80 + .../NOTICE.md | 36 + .../reclamation-priority-performance/PROOF.md | 100 + .../README.md | 126 + .../SOURCE.json | 13 + .../VALIDATION.json | 46 + .../adapter.py | 65 + .../audit_index.py | 52 + .../benchmark.py | 71 + .../evidence/AUDIT-23.json | 8 + .../evidence/AUDIT-25.json | 8 + .../evidence/BENCHMARK.json | 2732 +++++++++++++++++ .../evidence/LEGACY-CONTROLS.log.txt | 21 + .../evidence/PILOT.json | 329 ++ .../PUBLIC-REPRODUCTION-BENCHMARK.json | 956 ++++++ .../evidence/PUBLIC-REPRODUCTION.log.txt | 55 + .../evidence/SELECTED-RECORD.log.txt | 2 + .../priority.py | 87 + .../reference-pr175.py | 257 ++ .../reclamation-priority-performance/run.py | 60 + .../test_priority.py | 206 ++ .../verify.py | 28 + 22 files changed, 5338 insertions(+) create mode 100644 research/reclamation-priority-performance/CLAIM.json create mode 100644 research/reclamation-priority-performance/NOTICE.md create mode 100644 research/reclamation-priority-performance/PROOF.md create mode 100644 research/reclamation-priority-performance/README.md create mode 100644 research/reclamation-priority-performance/SOURCE.json create mode 100644 research/reclamation-priority-performance/VALIDATION.json create mode 100644 research/reclamation-priority-performance/adapter.py create mode 100644 research/reclamation-priority-performance/audit_index.py create mode 100644 research/reclamation-priority-performance/benchmark.py create mode 100644 research/reclamation-priority-performance/evidence/AUDIT-23.json create mode 100644 research/reclamation-priority-performance/evidence/AUDIT-25.json create mode 100644 research/reclamation-priority-performance/evidence/BENCHMARK.json create mode 100644 research/reclamation-priority-performance/evidence/LEGACY-CONTROLS.log.txt create mode 100644 research/reclamation-priority-performance/evidence/PILOT.json create mode 100644 research/reclamation-priority-performance/evidence/PUBLIC-REPRODUCTION-BENCHMARK.json create mode 100644 research/reclamation-priority-performance/evidence/PUBLIC-REPRODUCTION.log.txt create mode 100644 research/reclamation-priority-performance/evidence/SELECTED-RECORD.log.txt create mode 100644 research/reclamation-priority-performance/priority.py create mode 100644 research/reclamation-priority-performance/reference-pr175.py create mode 100644 research/reclamation-priority-performance/run.py create mode 100644 research/reclamation-priority-performance/test_priority.py create mode 100644 research/reclamation-priority-performance/verify.py diff --git a/research/reclamation-priority-performance/CLAIM.json b/research/reclamation-priority-performance/CLAIM.json new file mode 100644 index 0000000000..4a8ae8c850 --- /dev/null +++ b/research/reclamation-priority-performance/CLAIM.json @@ -0,0 +1,80 @@ +{ + "track": "verification engineering", + "assignment_seed": 85, + "randomness": "python3 secrets.randbelow(100), operating-system randomness, drawn once", + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "started_utc": "2026-10-13T04:51:11Z", + "expected_finish_utc": "2026-10-13T05:36:00Z", + "verification_reserve_starts_utc": "2026-10-13T05:24:45Z", + "coordination": "No pinned issues and no sprint coordination issue; only issue 650 requesting Discussions. Local claim recorded before implementation.", + "candidates": [ + "Avoid repeated exact data_corners.cpp checks in five historical producers", + "Replace repeated sorting of retired slots in joint_dual_reclaim_compiler.acquire with an exact rank/slot index", + "Accelerate quadratic_affine.rank_witness orthogonality-row construction" + ], + "selection": "85 mod 3 = 1, zero-based in the above list; inspect the ranked-reclamation bottleneck identified but not changed by PR154", + "object": "scripts/experiments/joint_dual_reclaim_compiler.py, retired-slot iteration in acquire; h=23 and h=25 PR55 graph", + "hypothesis": "Per-coordinate core/union membership bitsets can exclude exactly the ineligible retired slots before ordered rank/slot iteration, avoiding both the base's repeated sorts and PR175's repeated scans of ineligible candidates.", + "method": "Optional source-pinned in-memory adapter; preserve matching, eligibility, span elimination, clearing XORs, frames, dirty-basis checks and generated words. Benchmark reference and indexed engines sequentially on identical complete axes.", + "deliverable": "One tooling PR with exact word/receipt comparisons, an index invariant argument, seed-85 state-machine controls, source pins and before/after timing evidence. No new kappa.", + "stopping_rule": "Complete both shipped axes; stop or report a negative performance result if the exact index fails equivalence or does not reduce cost. At most one implementation pivot. No new mathematical search.", + "initial_overlap": { + "open_prs_read": 544, + "metadata_refreshed_through_pr": 732, + "relevant_pr154_head": "f571bcbd6e06618aeae0b8279da48060032dc74b", + "pr154_scope": "Reports repeated sorting in acquire as an unchanged bottleneck; optimizes concurrency and paired-cube frame algebra instead.", + "other_distinct_tooling_prs": [ + 367, + 452, + 662, + 667, + 672, + 704, + 707, + 709, + 721, + 727 + ], + "ledger": "PR154 partially reviewed; PR367 and PR452 unreviewed at base. These proposals are background, not accepted performance premises or code dependencies.", + "negative_result_check": "Read preserved-research.md and searched the research index and archived negative-result summaries; this replays a fixed historical construction, without reopening a closed mathematical search." + }, + "scope_refinement": { + "reason": "The closed-PR ledger identified incorporated PR175 after the initial open-PR scan. Its ordered buckets already solve sorting, so sorting alone is not a new contribution.", + "predecessor": "Chafik Boukhalfa, PR175 at f1081fabbfadaaaaf7292a40d428dbbb865ce920, compiler SHA256 f0696953d057239ed5a75e28d857b814d43ca43deaaf7b7b8fd191aa115112ff", + "distinct_work": "Exact coordinate-membership filtering, with per-slot frame updates; compare against both the unoptimized base and the exact PR175 compiler. The complete eligible candidate sequence must match a sorted-set oracle at every acquisition in an untimed audit." + }, + "status": "Candidate Ready", + "result": { + "kind": "tooling improvement", + "new_kappa": false, + "core": "Exact coordinate-membership filtering before unchanged retired-slot selection", + "compile_speedup_over_pr175": [ + 4.525399396610507, + 4.871103587001165 + ], + "benchmark_runs": 18, + "additional_public_reproduction_runs": 6, + "all_query_audits": 71519, + "focused_tests": 12, + "unchanged_historical_tests": 16, + "selected_record_check": "PASS", + "review_map": "README.md" + }, + "final_overlap": { + "open_prs_read": 586, + "through_pr": 772, + "new_distinct_tooling": [ + 736, + 752, + 756 + ], + "finding": "No competing coordinate-membership eligibility index found. PR175 is the incorporated predecessor and an exact comparator, not a new claim.", + "later_arrivals_checked": [ + 768, + 769, + 770, + 771, + 772 + ] + } +} diff --git a/research/reclamation-priority-performance/NOTICE.md b/research/reclamation-priority-performance/NOTICE.md new file mode 100644 index 0000000000..9d33c313e5 --- /dev/null +++ b/research/reclamation-priority-performance/NOTICE.md @@ -0,0 +1,36 @@ +# Attribution and license + +Prepared for **Peter Carpenter (PeterCarp320)** with substantial assistance +from **OpenAI Codex (GPT-6 Astra)**, including experiment selection, +implementation, equivalence argument, testing, measurements and documentation. +No independent human mathematical review is claimed. New material is supplied +under the repository's Apache-2.0 license. + +The original source files and their notices remain unchanged: + +- **eumemic** supplied the PR57 joint compiler and identified repeated sorting + in `acquire` as an unchanged bottleneck in PR154. +- **Chafik Boukhalfa (chafreaky)** supplied descending-rank reclamation and its + exact integration, with OpenAI Codex assistance. His **PR175** already + replaced whole-set sorting with ordered per-rank lists and correctly moved + retired anchors when clearing changes their frames. That contribution is + incorporated in an archived prerequisite, as the review ledger records. + This package does not claim that ordering optimization as new. +- `reference-pr175.py` preserves the exact compiler bytes from PR175 commit + `f1081fabbfadaaaaf7292a40d428dbbb865ce920`, SHA256 + `f0696953d057239ed5a75e28d857b814d43ca43deaaf7b7b8fd191aa115112ff`. + Its original compiler credits and the root Apache-2.0 license apply. +- **Rohan Gupta** supplied the PR55 dual-skip producer. The PR48 fixed-basis + geometry and preceding compiler/graph contributors retain their existing + attribution in `research/joint-dual/` and `references/frame-compiler/`. +- **rfu08's PR64 audit** identified the cancelling-scatter failure covered by + the retained independent replay and regression controls. + +The new contribution is exact coordinate-membership filtering before ordered +iteration, its equivalence argument and complete same-input comparison against +both the base compiler and PR175. PR367/452/662/667/672/707/709/721/727 address +other verification workloads and are not dependencies. + +The accepted selected result at the base commit is #626/#543, conditional +κ = 51110230636731/31250000000000000. This package concerns the historical +joint-dual verifier; neither the selected frontier nor `upstream/` is edited. diff --git a/research/reclamation-priority-performance/PROOF.md b/research/reclamation-priority-performance/PROOF.md new file mode 100644 index 0000000000..e4f29a4cbf --- /dev/null +++ b/research/reclamation-priority-performance/PROOF.md @@ -0,0 +1,100 @@ +# Exact geometry filtering and retired-slot order + +This is an equivalence argument for the source-pinned finite compiler in +`SOURCE.json`. It changes its implementation cost, not its mathematical +construction or any conditional exponent. It assumes the pinned compiler's +frame and control-flow contracts. The runtime tests are finite corroboration, +not a formal proof of the full multiplication theorem. + +## Membership invariant + +Let `S` be the retired physical slot set. A slot `s` has current rank `r_s` +and current original-envelope frame `(c_s, u_s)`, where `c_s` and `u_s` are +coordinate subsets of `{0, ..., h-1}`. The index maintains: + +- `all_mask`: exactly the slots in `S`; +- `masks[r]`: exactly the slots in `S` whose current rank is `r`; +- `core_masks[i]`: exactly the slots in `S` for which `i` belongs to `c_s`; +- `union_masks[i]`: exactly the slots in `S` for which `i` belongs to `u_s`. + +Each bit position is a physical slot ID, not a coordinate ID. All masks start +empty. Adding and removing a retired slot sets or clears its rank bit and +toggles exactly its frame-coordinate membership bits. An idempotent duplicate +add leaves the masks alone. Removal of an absent member raises `KeyError`. + +The adapter inserts `move` immediately before the original `raise_` updates +`frames[s]`. Thus the callback still sees the old frame. For a retired slot, +the rank masks change if the rank changes, and coordinate bits toggle exactly +on the symmetric differences of the old and new core/union. Nonretired slots +do not enter the index. Changes within the same rank still update geometry. +The original frame-containment assertion remains before this hook. + +In particular, clearing changes **both** the chosen destination's frame and +each retired source anchor's frame. Both changes pass through the same +`raise_` hook. Removing the chosen slot after clearing uses its new frame. +This is the subtle update obligation already identified by Chafik Boukhalfa's +PR175 ordered-bucket implementation. + +## Exact eligible set + +For a requested frame `(c, u)`, the original predicate is + +``` +not (c & ~c_s) and not (u_s & ~u) +``` + +Equivalently, `c` is a subset of `c_s`, and `u_s` is a subset of `u`. +Therefore the eligible slot set is precisely + +``` +S intersect (intersection of core_masks[i] for i in c) + intersect (intersection of complements of union_masks[i] for i outside u). +``` + +The index computes this expression with integer bit operations. Starting from +`all_mask` bounds every complement to existing slots. `outside` uses the finite +`h`-coordinate universe; all caller frames come from the pinned constructor. +Empty intersections impose no extra restriction. No rank, span, source-access +or paid-frame criterion is approximated by this expression. + +## Same order, same clearing, same word + +Intersecting the eligible set with rank masks in descending rank order, and +extracting each integer mask's least significant set bit, enumerates exactly +the eligible subsequence of `sorted(S, key=(-current_rank, slot_ID))`. + +The original `acquire` builds the same anchor basis first. An ineligible slot +is skipped **before** `ins(s)`, so omitting just those slots cannot change the +basis. Each eligible slot reaches the unchanged elimination in the same order. +Consequently the first dependent candidate, its exact clearing expression, +every clearing XOR, and any decision to allocate a new slot are identical. + +The loop performs no frame or set mutation while searching. Once it finds a +dependent candidate, it clears the slot, removes it and returns immediately. +The generator is never resumed after that mutation. Its partially consumed +mask therefore cannot affect a later query. The standalone index does not +promise general mutation-during-iteration semantics. + +Induction over the unchanged compiler operations gives identical slots, +frames, paid events, XORs and final receipts. The original per-slot containment +test, rank/width accounting, full input and dirty-basis replay in both +orientations remain enabled. No witness, helper or recursive child is removed. + +## What is tested + +The package checks complete equality to the frozen decompressed words at +`h=23` and `h=25`, not just summary counts. Independent serialized-word replay +and event reconstruction consume the newly generated word. An untimed run +also compares **every complete eligible candidate sequence** against an +ordinary sorted-set oracle using the current original frames. + +Separate tests exhaust all pairs of three-coordinate envelope frames, then +exercise additions, removals and frame changes with seed 85, including sparse +physical IDs as large as 40,337. Stale frame updates, stale removals, wrong core +or union masks, and wrong rank masks have explicit negative controls. Source +drift, ambiguous edit sites, disabled assertions and reused output paths fail. + +The `h=23/25` tests do not assert a theorem for every future compiler or graph. +The adapter refuses changed source pins. Inherited all-size compilation, +physical realization, hosting, residual, precision, tape, recovery and analytic +transfer obligations remain outside this tooling contribution. diff --git a/research/reclamation-priority-performance/README.md b/research/reclamation-priority-performance/README.md new file mode 100644 index 0000000000..27f5a1b138 --- /dev/null +++ b/research/reclamation-priority-performance/README.md @@ -0,0 +1,126 @@ +# Exact retired-slot eligibility masks + +**Tooling improvement, no new κ.** This optional adapter accelerates the +historical joint-dual compiler by using coordinate-membership bitsets to +exclude ineligible retired slots before iterating in the unchanged priority +order. All compiler operations, paid frame changes, helper choices, dirty +restoration checks and emitted word bytes must remain identical. + +Chafik Boukhalfa's [PR175](https://github.com/CrocSwap/integer-mult-bounds/pull/175) +already removes repeated sorting using ordered rank buckets. The new step is +geometry filtering before iteration. The comparison includes PR175's exact +archived compiler, as well as the slower compiler still used by the root +historical verifier. This does not claim PR175's ordering improvement as new. + +Base commit: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +OS-random track assignment: **85**, verification engineering. `CLAIM.json` +records the shortlist, scope refinement, overlap checks and stopping rule. +There was no sprint coordination issue, so the claim is local. + +## Measured result + +Three cyclic-order rounds per axis on CPython 3.14.6 / macOS 26.5.2 arm64, +18 fresh processes in total. All generated words and all receipt fields agree. +Medians in seconds: + +| Workload | Base sorting | PR175 buckets | Coordinate masks | +|---|---:|---:|---:| +| h=23 compilation | 54.310 | 19.668 | 4.346 | +| h=25 compilation | 93.476 | 31.894 | 6.548 | +| h=23 complete measured process | 57.422 | 22.499 | 7.443 | +| h=25 complete measured process | 97.542 | 35.837 | 10.875 | + +Compilation is **4.53–4.87× faster than PR175**, and **12.50–14.28× faster +than the base compiler**. The complete measured process includes imports, +source checks, compilation, serialization, exact comparison, independent +word replay and transition reconstruction. Its improvement relative to PR175 +is 3.02–3.30×. These are local measurements under ordinary machine load, not +a cross-platform guarantee. CPU timings and every raw sample are retained in +[`evidence/BENCHMARK.json`](evidence/BENCHMARK.json), together with exact hashes +of all executed adapter/runtime files. No timing result is an admission check. + +The full public command was then run once separately and passed, including +six more matched timing processes. Its complete log and raw timings are in +`evidence/PUBLIC-REPRODUCTION*`. The two independent sequence audits cover +30,770 and 40,749 requests (71,519 total); `AUDIT-23.json` and `AUDIT-25.json` +record their coverage. Their `unfiltered_candidates` counts sum whole retired +set sizes, **not** actual predecessor visits before early return. + +All **12 focused tests** and **16 unchanged historical control tests** pass. +The latter include omitted XORs, nonnested frames, missing/aliased outputs, +unpaid cancelling scatter, omitted transitions and understated width. Local +temporary fixtures were retained for inspection; the assertions were unchanged. +Reproduce those existing controls separately with +`python3 -B -m unittest discover -s tests -p 'test_joint_reclaim.py' -v`. +The selected-record/source-inventory check and staged whitespace check pass. +This is local evidence; remote CI is not asserted to have run. + +## Reproduce + +From a full checkout, using Python 3.11+ and only its standard library: + +```sh +python3 -B research/reclamation-priority-performance/verify.py --out /tmp/reclamation-review +``` + +Use a fresh output directory. Expected final marker: +`PASS_RECLAMATION_PRIORITY`. The command runs focused tests, audits every +eligible candidate sequence on both shipped axes, then runs a sequential +three-engine timing comparison. Every generated word and receipt is retained +under the output directory, including failed-run files for inspection. It +never regenerates a repository certificate. + +For the recorded three-round benchmark alone: + +```sh +python3 -B research/reclamation-priority-performance/benchmark.py --rounds 3 --out /tmp/reclamation-timings +``` + +Expected: `PASS_RECLAMATION_BENCHMARK`. There is no timing threshold. Runtime +depends on machine load; the comparison runs sequential fresh processes and +rotates engine order. OS caches are not flushed. + +## Evidence and implementation + +`priority.py` maintains rank and coordinate-membership bitsets. `adapter.py` +checks the frozen source closure, then applies exactly three checked +in-memory substitutions: create the index, update it before a frame change, +and use its eligible ordered iterator. The original containment test and +elimination remain in place. Default commands and all existing sources, +manifests, certificates and `upstream/` are unchanged. + +`SOURCE.json` pins the base manifest, compiler, consumer verifiers and the +exact PR175 compiler bytes. The original manifest checks and `check_sources()` +also run. Each measured process rebuilds one complete `h=23` or `h=25` axis, +compares the **entire decompressed physical word** to the frozen input, and +compares every compiler-receipt field. The independent serialized-word checker +then replays the fresh word's complete input/dirty basis in both orientations; +the transition consumer independently reconstructs paid events from its XORs. + +The untimed `audit_index.py` compares the full eligible sequence at **every** +acquisition to an ordinary sorted-set oracle using the original current +frames. It checks candidates after the first successful one too. Unit controls +exhaust three-coordinate frame pairs and exercise 2,400 seed-85 set/frame +changes with sparse IDs up to 40,337. Five deliberately stale or incorrect +index mutations are detected. Source tampering, duplicated substitution sites, +disabled assertions and reused outputs are rejected. + +The exact invariant and control-flow argument is in [PROOF.md](PROOF.md). +[NOTICE.md](NOTICE.md) credits eumemic, Chafik Boukhalfa, Rohan Gupta, rfu08 +and inherited contributors, and discloses substantial OpenAI Codex assistance. + +## Limits + +This measures historical axis compilation and its replay/transition process. +It is not a speedup measurement of integer multiplication, the selected +frontier's cold replay, or the full joint-dual verifier with C++ CRT profiles +and assembly. The selected #626/#543 certificate remains +κ = `51110230636731/31250000000000000`. + +The source-pinned adapter is opt-in and sequential. Future compiler versions +require a new source review; mutation during a partially consumed iterator is +only supported under the pinned acquire-and-return control flow. No global +optimality or formal multiplication theorem is asserted. Inherited all-size +compiler, physical realization, hosting, residual, precision, tape, recovery +and analytic obligations remain. The repository-wide `make verify`, supplier +cold rebuild, C++ profile computation and Lean are outside this isolated run. diff --git a/research/reclamation-priority-performance/SOURCE.json b/research/reclamation-priority-performance/SOURCE.json new file mode 100644 index 0000000000..396124533f --- /dev/null +++ b/research/reclamation-priority-performance/SOURCE.json @@ -0,0 +1,13 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "files": { + "research/joint-dual/SOURCE.json": "e60f1f78c9729700ef9606a6576163de0b553792e5e8f24591dce5f51597158c", + "research/reclamation-priority-performance/reference-pr175.py": "f0696953d057239ed5a75e28d857b814d43ca43deaaf7b7b8fd191aa115112ff", + "scripts/experiments/binary_frame_profile_prepare.py": "16dea3d3ef3dc90db928ed3e35d002f6926d2e7388da4766fc2fd725550f739e", + "scripts/experiments/binary_frame_replay.py": "1a572dbb33faba6695b3293768a7e61392d11cb4c2d5f708eedcd2cb95d0aff9", + "scripts/experiments/joint_dual_compiler.py": "853d3fc4a740c5b74c23b3a6af5d4dc9b41fb38e9b55678539a7e0ee71947c13", + "scripts/experiments/joint_dual_reclaim_compiler.py": "9984aaccf880e4840402322d76678bfddb33ce7e494af78430a43429f51b85fd" + }, + "pr175_head": "f1081fabbfadaaaaf7292a40d428dbbb865ce920", + "source_closure": "The pinned joint-dual manifest and original check_sources() validate the inherited PR48/55/58 dependencies and all finite word inputs." +} diff --git a/research/reclamation-priority-performance/VALIDATION.json b/research/reclamation-priority-performance/VALIDATION.json new file mode 100644 index 0000000000..feb79b8415 --- /dev/null +++ b/research/reclamation-priority-performance/VALIDATION.json @@ -0,0 +1,46 @@ +{ + "additional_public_reproduction_runs": 6, + "assignment_seed": 85, + "audited_acquisitions": 71519, + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "benchmark_runs": 18, + "evidence_sha256": { + "AUDIT-23.json": "203df1f29cbc44001d8a2831ce018bd3f19eb1da452799489c6ff7068b266f65", + "AUDIT-25.json": "61dee75406c28605ce4db7e3eb9a75068583c3c8a79bbf867d6fc6d99a929b2c", + "BENCHMARK.json": "b3325db3b187ad497f81fbe341e0f17f4bb8cb31e3feb8e01643f179a9b5b683", + "LEGACY-CONTROLS.log.txt": "9ccffff4d773366b12ddb4ecfad08399616df0d38a283bf0a09cc3492691010b", + "PILOT.json": "906a2317135a499adebc02bf9427ac438aa9faa09b7753dfe626da904c00ffcb", + "PUBLIC-REPRODUCTION-BENCHMARK.json": "3493a3c76359d3e27f3b8456ef231136e0b073acb8450b169698c1ecc91a8be4", + "PUBLIC-REPRODUCTION.log.txt": "e2a592695d783975240e6863160f7e46630f587a76ff5b44a33c241a06f2d9ca", + "SELECTED-RECORD.log.txt": "46c8e861c11b33629b94426a7629d1fddc61f33c1cfe505679ed9efa70c1a93b" + }, + "focused_tests": 12, + "historical_test_note": "Unmodified tests/test_joint_reclaim.py assertions; temporary fixtures retained instead of removed after each test.", + "not_run": [ + "repository-wide make verify", + "selected cold supplier replay", + "C++ CRT profiles", + "47-inequality assembly", + "Lean", + "remote CI" + ], + "package_code_sha256": { + "adapter.py": "bf8101389c2940caa150865b32bf79c695a0c7465cb0a9ef4f200a37f0eda739", + "audit_index.py": "bb7f528b8c6a431a2a6c4cc5c44fa6f6ad9c15f1d1be281aade65e56512705d7", + "benchmark.py": "027ca825c755aec26bc4f6561bbd902b33160767446dc4597c9bc670509803ea", + "priority.py": "9f26a6e6b53272a74dd86f8e6aeddc5668b44bbecde56228307ed725bcfe1770", + "reference-pr175.py": "f0696953d057239ed5a75e28d857b814d43ca43deaaf7b7b8fd191aa115112ff", + "run.py": "acf0b60203a06fe16aeff12cab4b78ce4c242dc954a7b597a95edd72c799a5ba", + "test_priority.py": "aa2a3b3456000b7b35c9f7452d7821a96fafcb6a05cc28c88a60b3d4b5d40501", + "verify.py": "408c4c7167877e36114291668aa9353633ecc94420d6bae3ca3822b0afb23295" + }, + "scope": "No construction or exponent change. Existing compiler/physical/hosting/precision/tape/analytic assumptions remain.", + "selected_record_check": "PASS", + "status": "PASS scoped local verification", + "unchanged_historical_tests": 16, + "utc": "2026-10-13T05:25:40.571255+00:00", + "word_sha256": { + "23": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e", + "25": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + } +} diff --git a/research/reclamation-priority-performance/adapter.py b/research/reclamation-priority-performance/adapter.py new file mode 100644 index 0000000000..3f3471afc9 --- /dev/null +++ b/research/reclamation-priority-performance/adapter.py @@ -0,0 +1,65 @@ +"""Source-pinned, opt-in exact eligibility and ordering adapter.""" + +from hashlib import sha256 +from pathlib import Path +import importlib +import json +import sys + +from priority import RankedSlots + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +EXPERIMENTS = ROOT / "scripts/experiments" +COMPILER = "scripts/experiments/joint_dual_reclaim_compiler.py" +REPLACEMENTS = ( + ("retired=set();", "retired=RankedSlots(h, lambda s: (blocks[frames[s]]['rank'], blocks[frames[s]]['frame']));"), + ("frames[s]=g;events.append((s,old,g))", + "retired.move(s,blocks[g]['rank'],blocks[g]['frame']);" + "frames[s]=g;events.append((s,old,g))"), + ("sorted(retired,key=lambda s:(-blocks[frames[s]]['rank'],s))", "retired.ordered(blocks[g]['frame'])"), +) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def verify_sources(root=ROOT): + require(not sys.flags.optimize, "Assertions must remain enabled") + pins = json.loads((HERE / "SOURCE.json").read_text()) + for name, digest in pins["files"].items(): + require(sha256((root / name).read_bytes()).hexdigest() == digest, + "Changed pinned source: " + name) + # The pinned local manifest binds the original compiler, finite inputs and + # inherited manifests. Check every listed byte before loading the compiler. + manifest = json.loads((root / "research/joint-dual/SOURCE.json").read_text()) + for name, digest in manifest["files"].items(): + require(sha256((root / name).read_bytes()).hexdigest() == digest, + "Changed joint-dual source: " + name) + return pins + + +def transformed_source(source): + for before, after in REPLACEMENTS: + require(source.count(before) == 1, "Adapter source shape changed: " + before) + source = source.replace(before, after) + return source + + +def load(mode): + require(mode in ("reference", "buckets", "indexed"), "Unknown engine") + verify_sources() + require("joint_dual_compiler" not in sys.modules, + "Run each engine in a fresh Python process") + sys.path.insert(0, str(EXPERIMENTS)) + compiler = importlib.import_module("joint_dual_compiler") + composition = importlib.import_module("joint_dual_compose") + composition.check_sources() + if mode != "reference": + source = (HERE / "reference-pr175.py").read_text() if mode == "buckets" else transformed_source((ROOT / COMPILER).read_text()) + namespace = vars(compiler.compiler) + namespace["RankedSlots"] = RankedSlots + exec(compile(source, str(ROOT / COMPILER), "exec"), namespace) + return compiler diff --git a/research/reclamation-priority-performance/audit_index.py b/research/reclamation-priority-performance/audit_index.py new file mode 100644 index 0000000000..d1ef18c52b --- /dev/null +++ b/research/reclamation-priority-performance/audit_index.py @@ -0,0 +1,52 @@ +"""Untimed sorted-set comparison of every complete eligible candidate sequence.""" + +import argparse +import json +from pathlib import Path + +import adapter +from priority import RankedSlots +from run import run + + +class AuditedSlots(RankedSlots): + instances = [] + + def __init__(self, *args): + super().__init__(*args) + self.queries = 0 + self.unfiltered_candidates = 0 + self.eligible_candidates = 0 + self.instances.append(self) + + def ordered(self, frame): + core, union = frame + expected = [] + for slot in self.members: + rank, (old_core, old_union) = self.state_of(slot) + if not (core & ~old_core) and not (old_union & ~union): + expected.append((-rank, slot)) + expected = [slot for _, slot in sorted(expected)] + actual = list(super().ordered(frame)) + adapter.require(actual == expected, "Eligible candidate sequence differs") + self.queries += 1 + self.unfiltered_candidates += len(self.members) + self.eligible_candidates += len(actual) + return iter(actual) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--h", type=int, choices=(23, 25), required=True) + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + adapter.RankedSlots = AuditedSlots + run("indexed", args.h, args.out) + adapter.require(len(AuditedSlots.instances) == 1, "Expected one index") + index = AuditedSlots.instances[0] + result = dict(status="PASS", h=args.h, queries=index.queries, + unfiltered_candidates=index.unfiltered_candidates, + eligible_candidates=index.eligible_candidates, + scope="Every eligible candidate, including candidates beyond the chosen slot; original state/frame oracle") + (args.out / "AUDIT.json").write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + print("PASS_RECLAMATION_INDEX_AUDIT " + json.dumps(result), flush=True) diff --git a/research/reclamation-priority-performance/benchmark.py b/research/reclamation-priority-performance/benchmark.py new file mode 100644 index 0000000000..8f0e0534c0 --- /dev/null +++ b/research/reclamation-priority-performance/benchmark.py @@ -0,0 +1,71 @@ +"""Sequential fresh-process comparison on both complete historical axes.""" + +import argparse +from datetime import datetime, timezone +from hashlib import sha256 +import json +from pathlib import Path +import platform +import statistics +import subprocess +import sys +import time + +from adapter import HERE, require, verify_sources + + +def implementation_hashes(): + names = ("priority.py", "adapter.py", "run.py", "benchmark.py", "reference-pr175.py", "SOURCE.json") + return {name: sha256((HERE / name).read_bytes()).hexdigest() for name in names} + + +def benchmark(rounds, output): + require(1 <= rounds <= 7, "Use one through seven rounds") + require(not output.exists(), "Output must be a fresh directory") + pins = verify_sources() + implementations = implementation_hashes() + output.mkdir(parents=True) + records = [] + modes = ("reference", "buckets", "indexed") + for h in (23, 25): + for repetition in range(rounds): + offset = repetition % len(modes) + order = modes[offset:] + modes[:offset] + for mode in order: + name = f"h{h}-round{repetition + 1}-{mode}" + command = [sys.executable, "-B", str(HERE / "run.py"), + "--mode", mode, "--h", str(h), "--out", str(output / name)] + with (output / (name + ".log")).open("w") as log: + start = time.perf_counter() + subprocess.run(command, check=True, stdout=log, stderr=subprocess.STDOUT) + process_seconds = time.perf_counter() - start + record = json.loads((output / name / "RESULT.json").read_text()) + record.update(round=repetition + 1, process_wall_seconds=process_seconds) + reference = next((r for r in records if r["h"] == h), record) + for key in ("word_sha256", "word_bytes", "compiler_receipt", "independent_replay", "transitions"): + require(record[key] == reference[key], "Engines disagree: " + key) + records.append(record) + print(f"PASS {name} compile={record['compile_wall_seconds']:.3f}s process={process_seconds:.3f}s", flush=True) + require(implementation_hashes() == implementations, "Implementation changed during benchmark") + summary = {} + for h in (23, 25): + summary[h] = {} + for mode in modes: + rows = [r for r in records if r["h"] == h and r["engine"] == mode] + summary[h][mode] = {key: statistics.median(r[key] for r in rows) + for key in ("compile_wall_seconds", "compile_cpu_seconds", "process_wall_seconds")} + result = dict(status="PASS_RECLAMATION_BENCHMARK", utc=datetime.now(timezone.utc).isoformat(), + rounds=rounds, python=sys.version, platform=platform.platform(), + order="reference/buckets/indexed, then cyclic rotations; axes 23 then 25; sequential fresh processes; OS caches not flushed", + source_pins=pins, implementation_sha256=implementations, medians=summary, runs=records, + scope="Complete axis compilation and replay/transition process, not full joint-dual verification, frontier cold replay or multiplication runtime") + (output / "BENCHMARK.json").write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + print("PASS_RECLAMATION_BENCHMARK", flush=True) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--rounds", type=int, default=3) + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + benchmark(args.rounds, args.out.resolve()) diff --git a/research/reclamation-priority-performance/evidence/AUDIT-23.json b/research/reclamation-priority-performance/evidence/AUDIT-23.json new file mode 100644 index 0000000000..7e51d24379 --- /dev/null +++ b/research/reclamation-priority-performance/evidence/AUDIT-23.json @@ -0,0 +1,8 @@ +{ + "eligible_candidates": 530387, + "h": 23, + "queries": 30770, + "scope": "Every eligible candidate, including candidates beyond the chosen slot; original state/frame oracle", + "status": "PASS", + "unfiltered_candidates": 123492336 +} diff --git a/research/reclamation-priority-performance/evidence/AUDIT-25.json b/research/reclamation-priority-performance/evidence/AUDIT-25.json new file mode 100644 index 0000000000..b665f609f9 --- /dev/null +++ b/research/reclamation-priority-performance/evidence/AUDIT-25.json @@ -0,0 +1,8 @@ +{ + "eligible_candidates": 856174, + "h": 25, + "queries": 40749, + "scope": "Every eligible candidate, including candidates beyond the chosen slot; original state/frame oracle", + "status": "PASS", + "unfiltered_candidates": 217004227 +} diff --git a/research/reclamation-priority-performance/evidence/BENCHMARK.json b/research/reclamation-priority-performance/evidence/BENCHMARK.json new file mode 100644 index 0000000000..66b62aa880 --- /dev/null +++ b/research/reclamation-priority-performance/evidence/BENCHMARK.json @@ -0,0 +1,2732 @@ +{ + "implementation_sha256": { + "SOURCE.json": "acc3970bc074dcc5d588d627e13205ce9459f8c08651a733a5b49cf253627cd2", + "adapter.py": "bf8101389c2940caa150865b32bf79c695a0c7465cb0a9ef4f200a37f0eda739", + "benchmark.py": "027ca825c755aec26bc4f6561bbd902b33160767446dc4597c9bc670509803ea", + "priority.py": "9f26a6e6b53272a74dd86f8e6aeddc5668b44bbecde56228307ed725bcfe1770", + "reference-pr175.py": "f0696953d057239ed5a75e28d857b814d43ca43deaaf7b7b8fd191aa115112ff", + "run.py": "acf0b60203a06fe16aeff12cab4b78ce4c242dc954a7b597a95edd72c799a5ba" + }, + "medians": { + "23": { + "buckets": { + "compile_cpu_seconds": 19.252550000000003, + "compile_wall_seconds": 19.668408708000243, + "process_wall_seconds": 22.499194375000116 + }, + "indexed": { + "compile_cpu_seconds": 4.168349, + "compile_wall_seconds": 4.346226042000126, + "process_wall_seconds": 7.4433396659997015 + }, + "reference": { + "compile_cpu_seconds": 53.080556, + "compile_wall_seconds": 54.30994079199991, + "process_wall_seconds": 57.422010708000016 + } + }, + "25": { + "buckets": { + "compile_cpu_seconds": 31.604996, + "compile_wall_seconds": 31.89376750000065, + "process_wall_seconds": 35.83724075000009 + }, + "indexed": { + "compile_cpu_seconds": 6.433548, + "compile_wall_seconds": 6.5475445000001855, + "process_wall_seconds": 10.875163665999935 + }, + "reference": { + "compile_cpu_seconds": 92.57929399999999, + "compile_wall_seconds": 93.475880125, + "process_wall_seconds": 97.54231804199935 + } + } + }, + "order": "reference/buckets/indexed, then cyclic rotations; axes 23 then 25; sequential fresh processes; OS caches not flushed", + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "rounds": 3, + "runs": [ + { + "compile_cpu_seconds": 57.275968, + "compile_wall_seconds": 59.077020542000355, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "reference", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 61.966498917000536, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 19.252550000000003, + "compile_wall_seconds": 19.668408708000243, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "buckets", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 22.499194375000116, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 4.476399, + "compile_wall_seconds": 4.647532416999638, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "indexed", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 8.358681957999579, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 19.720758, + "compile_wall_seconds": 20.38337320899973, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "buckets", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 23.441939792000085, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 2, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 4.0972610000000005, + "compile_wall_seconds": 4.181257250000272, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "indexed", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 7.076795542000582, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 2, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 49.47583100000001, + "compile_wall_seconds": 50.328219291000096, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "reference", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 53.246649791999516, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 2, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 4.168349, + "compile_wall_seconds": 4.346226042000126, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "indexed", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 7.4433396659997015, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 3, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 53.080556, + "compile_wall_seconds": 54.30994079199991, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "reference", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 57.422010708000016, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 3, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 18.585039, + "compile_wall_seconds": 19.28064295799959, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "buckets", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 21.97135704199991, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 3, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 94.150852, + "compile_wall_seconds": 95.03964608299975, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "reference", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 99.19266933299969, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 36.194611, + "compile_wall_seconds": 37.08590020799966, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "buckets", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 41.19570462499996, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 6.433548, + "compile_wall_seconds": 6.5475445000001855, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "indexed", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 10.875163665999935, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 31.604996, + "compile_wall_seconds": 31.89376750000065, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "buckets", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 35.83724075000009, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 2, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 6.307246, + "compile_wall_seconds": 6.344504042000153, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "indexed", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 10.319945166999787, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 2, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 92.57929399999999, + "compile_wall_seconds": 93.475880125, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "reference", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 97.54231804199935, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 2, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 6.612284, + "compile_wall_seconds": 6.7674802089995865, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "indexed", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 11.139692791000016, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 3, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 91.05698600000001, + "compile_wall_seconds": 92.03997962500034, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "reference", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 95.90082566599995, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 3, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 29.556872000000002, + "compile_wall_seconds": 29.72481258300013, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "buckets", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 33.70571279200067, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 3, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + } + ], + "scope": "Complete axis compilation and replay/transition process, not full joint-dual verification, frontier cold replay or multiplication runtime", + "source_pins": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "files": { + "research/joint-dual/SOURCE.json": "e60f1f78c9729700ef9606a6576163de0b553792e5e8f24591dce5f51597158c", + "research/reclamation-priority-performance/reference-pr175.py": "f0696953d057239ed5a75e28d857b814d43ca43deaaf7b7b8fd191aa115112ff", + "scripts/experiments/binary_frame_profile_prepare.py": "16dea3d3ef3dc90db928ed3e35d002f6926d2e7388da4766fc2fd725550f739e", + "scripts/experiments/binary_frame_replay.py": "1a572dbb33faba6695b3293768a7e61392d11cb4c2d5f708eedcd2cb95d0aff9", + "scripts/experiments/joint_dual_compiler.py": "853d3fc4a740c5b74c23b3a6af5d4dc9b41fb38e9b55678539a7e0ee71947c13", + "scripts/experiments/joint_dual_reclaim_compiler.py": "9984aaccf880e4840402322d76678bfddb33ce7e494af78430a43429f51b85fd" + }, + "pr175_head": "f1081fabbfadaaaaf7292a40d428dbbb865ce920", + "source_closure": "The pinned joint-dual manifest and original check_sources() validate the inherited PR48/55/58 dependencies and all finite word inputs." + }, + "status": "PASS_RECLAMATION_BENCHMARK", + "utc": "2026-10-13T05:16:50.322155+00:00" +} diff --git a/research/reclamation-priority-performance/evidence/LEGACY-CONTROLS.log.txt b/research/reclamation-priority-performance/evidence/LEGACY-CONTROLS.log.txt new file mode 100644 index 0000000000..cf75d4b385 --- /dev/null +++ b/research/reclamation-priority-performance/evidence/LEGACY-CONTROLS.log.txt @@ -0,0 +1,21 @@ +test_aliased_terminal_role_is_rejected (test_joint_reclaim.JointReclamationControls.test_aliased_terminal_role_is_rejected) ... ok +test_cancelled_repetitions_of_paid_scatter_are_rejected (test_joint_reclaim.JointReclamationControls.test_cancelled_repetitions_of_paid_scatter_are_rejected) ... ok +test_complete_pr58_profile_fails_new_bit_saving (test_joint_reclaim.JointReclamationControls.test_complete_pr58_profile_fails_new_bit_saving) ... ok +test_missing_copied_center_is_rejected (test_joint_reclaim.JointReclamationControls.test_missing_copied_center_is_rejected) ... ok +test_missing_scatter_is_rejected_by_each_helper (test_joint_reclaim.JointReclamationControls.test_missing_scatter_is_rejected_by_each_helper) ... ok +test_negative_operation_frame_index_is_rejected (test_joint_reclaim.JointReclamationControls.test_negative_operation_frame_index_is_rejected) ... ok +test_non_nested_operation_frame_is_rejected (test_joint_reclaim.JointReclamationControls.test_non_nested_operation_frame_is_rejected) ... ok +test_omitted_literal_xor_is_rejected (test_joint_reclaim.JointReclamationControls.test_omitted_literal_xor_is_rejected) ... ok +test_omitted_transition_cannot_reduce_paid_profile (test_joint_reclaim.JointReclamationControls.test_omitted_transition_cannot_reduce_paid_profile) ... ok +test_optimized_helpers_reject_unchecked_word (test_joint_reclaim.JointReclamationControls.test_optimized_helpers_reject_unchecked_word) ... ok +test_optimized_python_is_rejected_by_every_new_entry (test_joint_reclaim.JointReclamationControls.test_optimized_python_is_rejected_by_every_new_entry) ... ok +test_scatter_order_preserves_the_complete_basis_receipt (test_joint_reclaim.JointReclamationControls.test_scatter_order_preserves_the_complete_basis_receipt) ... ok +test_selected_words_pass_independent_replay (test_joint_reclaim.JointReclamationControls.test_selected_words_pass_independent_replay) ... ok +test_self_cancelling_uncharged_scatter_is_rejected (test_joint_reclaim.JointReclamationControls.test_self_cancelling_uncharged_scatter_is_rejected) ... ok +test_self_xor_is_rejected (test_joint_reclaim.JointReclamationControls.test_self_xor_is_rejected) ... ok +test_understated_physical_width_is_rejected (test_joint_reclaim.JointReclamationControls.test_understated_physical_width_is_rejected) ... ok + +---------------------------------------------------------------------- +Ran 16 tests in 32.340s + +OK diff --git a/research/reclamation-priority-performance/evidence/PILOT.json b/research/reclamation-priority-performance/evidence/PILOT.json new file mode 100644 index 0000000000..9758caa869 --- /dev/null +++ b/research/reclamation-priority-performance/evidence/PILOT.json @@ -0,0 +1,329 @@ +{ + "runs": [ + { + "compile_cpu_seconds": 47.194098, + "compile_wall_seconds": 47.495650957999715, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "reference", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "scope": "Complete axis compilation, exact decompressed word equality and independent dirty-basis/frame replay; no new bound", + "status": "PASS", + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 16.400977, + "compile_wall_seconds": 16.619077708000077, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "buckets", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "scope": "Complete axis compilation, exact decompressed word equality and independent dirty-basis/frame replay; no new bound", + "status": "PASS", + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 3.967285, + "compile_wall_seconds": 4.047971542000596, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "indexed", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "scope": "Complete axis compilation, exact decompressed word equality and independent dirty-basis/frame replay; no new bound", + "status": "PASS", + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + } + ], + "scope": "Exploratory h=23 checks before adding transition reconstruction to run.py; not used in the final benchmark medians. Complete word and independent dirty-basis replay equality passed. These pilot receipts lack the final implementation-hash sidecar." +} diff --git a/research/reclamation-priority-performance/evidence/PUBLIC-REPRODUCTION-BENCHMARK.json b/research/reclamation-priority-performance/evidence/PUBLIC-REPRODUCTION-BENCHMARK.json new file mode 100644 index 0000000000..67b615030f --- /dev/null +++ b/research/reclamation-priority-performance/evidence/PUBLIC-REPRODUCTION-BENCHMARK.json @@ -0,0 +1,956 @@ +{ + "implementation_sha256": { + "SOURCE.json": "acc3970bc074dcc5d588d627e13205ce9459f8c08651a733a5b49cf253627cd2", + "adapter.py": "bf8101389c2940caa150865b32bf79c695a0c7465cb0a9ef4f200a37f0eda739", + "benchmark.py": "027ca825c755aec26bc4f6561bbd902b33160767446dc4597c9bc670509803ea", + "priority.py": "9f26a6e6b53272a74dd86f8e6aeddc5668b44bbecde56228307ed725bcfe1770", + "reference-pr175.py": "f0696953d057239ed5a75e28d857b814d43ca43deaaf7b7b8fd191aa115112ff", + "run.py": "acf0b60203a06fe16aeff12cab4b78ce4c242dc954a7b597a95edd72c799a5ba" + }, + "medians": { + "23": { + "buckets": { + "compile_cpu_seconds": 17.474609, + "compile_wall_seconds": 17.79092700000001, + "process_wall_seconds": 20.389685957999973 + }, + "indexed": { + "compile_cpu_seconds": 3.734946, + "compile_wall_seconds": 3.7426372079999055, + "process_wall_seconds": 6.3606909159998395 + }, + "reference": { + "compile_cpu_seconds": 50.670137000000004, + "compile_wall_seconds": 51.81148787500024, + "process_wall_seconds": 54.46893891699983 + } + }, + "25": { + "buckets": { + "compile_cpu_seconds": 29.561476, + "compile_wall_seconds": 29.77848954199999, + "process_wall_seconds": 33.79865095900004 + }, + "indexed": { + "compile_cpu_seconds": 6.479095, + "compile_wall_seconds": 6.575984499999322, + "process_wall_seconds": 10.396835999999894 + }, + "reference": { + "compile_cpu_seconds": 89.472712, + "compile_wall_seconds": 90.31595962499978, + "process_wall_seconds": 94.21033520800029 + } + } + }, + "order": "reference/buckets/indexed, then cyclic rotations; axes 23 then 25; sequential fresh processes; OS caches not flushed", + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "rounds": 1, + "runs": [ + { + "compile_cpu_seconds": 50.670137000000004, + "compile_wall_seconds": 51.81148787500024, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "reference", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 54.46893891699983, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 17.474609, + "compile_wall_seconds": 17.79092700000001, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "buckets", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 20.389685957999973, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 3.734946, + "compile_wall_seconds": 3.7426372079999055, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 36432, + "baseline_pr57_roles": 31416, + "baseline_pr58_roles": 30790, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 34230, + "elementary_xors": 112534, + "h": 23, + "histogram": { + "0": 224916, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 706330, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 30688, + "scalar": { + "additions": 40099, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "1b72f612aaf99fff5a34f2224cc747324a825032367ffd8b0eebc643d6266b47", + "every_node_has_common_point": true, + "h": 23, + "inputs": 1771, + "merged_additions": 5379, + "partial_outputs": 5336, + "roles": 45435 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 220, + "clearing_xors": 4284, + "matched": 11974, + "multi_node_regions": 4370, + "reclaimed": 1853, + "regions": 36626 + } + }, + "engine": "indexed", + "h": 23, + "independent_replay": { + "elementary_xors": 112534, + "full_basis_vectors": 34230, + "h": 23, + "histogram": { + "0": 121045, + "1": 42027, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 38232, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "output_roles": 5336, + "rank_mass": 706330, + "roles": 30688, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 474930 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 6.3606909159998395, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 30688, + "copied_centers": 23, + "distinct_transitions": 116867, + "frames": 36628, + "h": 23, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 52653, + "10": 2566, + "11": 385, + "12": 2901, + "13": 115, + "14": 3245, + "15": 544, + "16": 1935, + "17": 187, + "18": 8185, + "19": 4473, + "2": 32919, + "21": 27, + "22": 23, + "3": 6306, + "4": 18054, + "5": 8192, + "6": 4437, + "7": 1089, + "8": 3900, + "9": 331 + }, + "rank_mass": 706330, + "singles": 15939, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 1771, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + "word_bytes": 9214638, + "word_sha256": "c83396d1ea5427eed332c45931d59ed0c8ea5eae23d16e0ea909854d41796d1e" + }, + { + "compile_cpu_seconds": 89.472712, + "compile_wall_seconds": 90.31595962499978, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "reference", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 94.21033520800029, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 29.561476, + "compile_wall_seconds": 29.77848954199999, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "buckets", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 33.79865095900004, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + { + "compile_cpu_seconds": 6.479095, + "compile_wall_seconds": 6.575984499999322, + "compiler_receipt": { + "all_physical_frame_inclusions": true, + "baseline_pr48_roles": 48329, + "baseline_pr57_roles": 41264, + "baseline_pr58_roles": 40446, + "complete_dirty_basis_both_orientations": true, + "dirty_basis_vectors": 44938, + "elementary_xors": 148820, + "h": 25, + "histogram": { + "0": 297333, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "mode": { + "matching": true, + "reclaim": true + }, + "rank_mass": 1009050, + "reclamation_order": "descending current frame rank, then slot ID", + "roles": 40338, + "scalar": { + "additions": 53175, + "all_additions_disjoint": true, + "all_partial_outputs_exact": true, + "circuit_sha256": "2344a4fbc7bd47f78d674d54a8b3e56d43918bbea5fe5deceb95e6fb4a655c21", + "every_node_has_common_point": true, + "h": 25, + "inputs": 2300, + "merged_additions": 7008, + "partial_outputs": 6925, + "roles": 60100 + }, + "source_pr55_head": "03e991aa79f9df1a935726213bb6a8631cd0d823", + "stats": { + "augmentations": 286, + "clearing_xors": 5714, + "matched": 16276, + "multi_node_regions": 6025, + "reclaimed": 2711, + "regions": 48675 + } + }, + "engine": "indexed", + "h": 25, + "independent_replay": { + "elementary_xors": 148820, + "full_basis_vectors": 44938, + "h": 25, + "histogram": { + "0": 159745, + "1": 54602, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 50062, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "output_roles": 6925, + "rank_mass": 1009050, + "roles": 40338, + "status": "independent serialized word, exact frames, full input and dirty basis both orientations PASS", + "word_length": 627480 + }, + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "process_wall_seconds": 10.396835999999894, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "round": 1, + "scope": "Complete axis compilation, exact decompressed word equality, independent dirty-basis/frame replay and transition reconstruction; no new bound", + "status": "PASS", + "transitions": { + "R": 40338, + "copied_centers": 25, + "distinct_transitions": 155235, + "frames": 48677, + "h": 25, + "rank_histogram_with_side_growth_split_into_singletons": { + "1": 68402, + "10": 3073, + "11": 85, + "12": 3381, + "13": 310, + "14": 3389, + "15": 113, + "16": 4218, + "17": 630, + "18": 2510, + "19": 369, + "2": 43162, + "20": 10763, + "21": 5705, + "23": 39, + "24": 25, + "3": 8295, + "4": 24232, + "5": 10287, + "6": 4330, + "7": 1843, + "8": 5262, + "9": 860 + }, + "rank_mass": 1009050, + "singles": 20700, + "transition_events_equal_independent_xor_word_reconstruction": true, + "v": 2300, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + }, + "word_bytes": 12402582, + "word_sha256": "6f6dca829728cb01e6c425ada5878884b13bc6362e0ae2144347bde8a5852dbf" + } + ], + "scope": "Complete axis compilation and replay/transition process, not full joint-dual verification, frontier cold replay or multiplication runtime", + "source_pins": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "files": { + "research/joint-dual/SOURCE.json": "e60f1f78c9729700ef9606a6576163de0b553792e5e8f24591dce5f51597158c", + "research/reclamation-priority-performance/reference-pr175.py": "f0696953d057239ed5a75e28d857b814d43ca43deaaf7b7b8fd191aa115112ff", + "scripts/experiments/binary_frame_profile_prepare.py": "16dea3d3ef3dc90db928ed3e35d002f6926d2e7388da4766fc2fd725550f739e", + "scripts/experiments/binary_frame_replay.py": "1a572dbb33faba6695b3293768a7e61392d11cb4c2d5f708eedcd2cb95d0aff9", + "scripts/experiments/joint_dual_compiler.py": "853d3fc4a740c5b74c23b3a6af5d4dc9b41fb38e9b55678539a7e0ee71947c13", + "scripts/experiments/joint_dual_reclaim_compiler.py": "9984aaccf880e4840402322d76678bfddb33ce7e494af78430a43429f51b85fd" + }, + "pr175_head": "f1081fabbfadaaaaf7292a40d428dbbb865ce920", + "source_closure": "The pinned joint-dual manifest and original check_sources() validate the inherited PR48/55/58 dependencies and all finite word inputs." + }, + "status": "PASS_RECLAMATION_BENCHMARK", + "utc": "2026-10-13T05:22:03.984930+00:00" +} diff --git a/research/reclamation-priority-performance/evidence/PUBLIC-REPRODUCTION.log.txt b/research/reclamation-priority-performance/evidence/PUBLIC-REPRODUCTION.log.txt new file mode 100644 index 0000000000..c368cbb9c7 --- /dev/null +++ b/research/reclamation-priority-performance/evidence/PUBLIC-REPRODUCTION.log.txt @@ -0,0 +1,55 @@ +test_disabled_assertions_are_rejected_without_outputs (__main__.AdmissionTests.test_disabled_assertions_are_rejected_without_outputs) ... ok +test_missing_frame_update_hook_fails_real_compilation (__main__.AdmissionTests.test_missing_frame_update_hook_fails_real_compilation) ... ok +test_pinned_sources_and_three_exact_edit_sites (__main__.AdmissionTests.test_pinned_sources_and_three_exact_edit_sites) ... ok +test_reused_output_is_rejected_before_compilation (__main__.AdmissionTests.test_reused_output_is_rejected_before_compilation) ... ok +test_tampered_compiler_and_archive_are_rejected_before_import (__main__.AdmissionTests.test_tampered_compiler_and_archive_are_rejected_before_import) ... ok +test_core_union_and_rank_mutants_are_detected (__main__.PriorityTests.test_core_union_and_rank_mutants_are_detected) ... ok +test_duplicate_add_and_missing_remove_keep_set_semantics (__main__.PriorityTests.test_duplicate_add_and_missing_remove_keep_set_semantics) ... ok +test_exhaustive_three_coordinate_frames (__main__.PriorityTests.test_exhaustive_three_coordinate_frames) ... ok +test_retired_clearing_anchor_moves_then_slot_is_removed (__main__.PriorityTests.test_retired_clearing_anchor_moves_then_slot_is_removed) ... ok +test_same_rank_frame_changes_update_eligibility (__main__.PriorityTests.test_same_rank_frame_changes_update_eligibility) ... ok +test_seed85_state_machine_with_sparse_large_slot_ids (__main__.PriorityTests.test_seed85_state_machine_with_sparse_large_slot_ids) ... ok +test_stale_move_mutant_is_detected (__main__.PriorityTests.test_stale_move_mutant_is_detected) ... ok + +---------------------------------------------------------------------- +Ran 12 tests in 2.764s + +OK +built 23 36626 regions +augment 100 11854 +augment 200 11954 +matched 11974 seconds 1.2715981006622314 +compile 23 0 6 reclaimed 0 seconds 1.2744269371032715 +compile 23 5000 16729 reclaimed 19 seconds 1.5083808898925781 +compile 23 10000 20965 reclaimed 172 seconds 3.301037073135376 +compile 23 15000 22929 reclaimed 607 seconds 5.265166759490967 +compile 23 20000 25536 reclaimed 1200 seconds 8.29860782623291 +compile 23 25000 28333 reclaimed 1562 seconds 13.069516897201538 +compile 23 30000 30127 reclaimed 1786 seconds 17.985254764556885 +compile 23 35000 30688 reclaimed 1853 seconds 20.04032301902771 +PASS_RECLAMATION_AXIS engine=indexed h=23 compile_seconds=21.091443 +PASS_RECLAMATION_INDEX_AUDIT {"status": "PASS", "h": 23, "queries": 30770, "unfiltered_candidates": 123492336, "eligible_candidates": 530387, "scope": "Every eligible candidate, including candidates beyond the chosen slot; original state/frame oracle"} +built 25 48675 regions +augment 100 16090 +augment 200 16190 +matched 16276 seconds 2.0600850582122803 +compile 25 0 6 reclaimed 0 seconds 2.0635108947753906 +compile 25 5000 19564 reclaimed 0 seconds 2.211743116378784 +compile 25 10000 25624 reclaimed 50 seconds 3.971890926361084 +compile 25 15000 28089 reclaimed 718 seconds 6.218401908874512 +compile 25 20000 29883 reclaimed 986 seconds 8.036885976791382 +compile 25 25000 32329 reclaimed 1785 seconds 11.748032808303833 +compile 25 30000 35471 reclaimed 2135 seconds 17.381455898284912 +compile 25 35000 37806 reclaimed 2408 seconds 23.85129690170288 +compile 25 40000 39609 reclaimed 2613 seconds 31.501952171325684 +compile 25 45000 40338 reclaimed 2711 seconds 35.298609018325806 +PASS_RECLAMATION_AXIS engine=indexed h=25 compile_seconds=36.824582 +PASS_RECLAMATION_INDEX_AUDIT {"status": "PASS", "h": 25, "queries": 40749, "unfiltered_candidates": 217004227, "eligible_candidates": 856174, "scope": "Every eligible candidate, including candidates beyond the chosen slot; original state/frame oracle"} +PASS h23-round1-reference compile=51.811s process=54.469s +PASS h23-round1-buckets compile=17.791s process=20.390s +PASS h23-round1-indexed compile=3.743s process=6.361s +PASS h25-round1-reference compile=90.316s process=94.210s +PASS h25-round1-buckets compile=29.778s process=33.799s +PASS h25-round1-indexed compile=6.576s process=10.397s +PASS_RECLAMATION_BENCHMARK +PASS_RECLAMATION_PRIORITY diff --git a/research/reclamation-priority-performance/evidence/SELECTED-RECORD.log.txt b/research/reclamation-priority-performance/evidence/SELECTED-RECORD.log.txt new file mode 100644 index 0000000000..4ec0c12e62 --- /dev/null +++ b/research/reclamation-priority-performance/evidence/SELECTED-RECORD.log.txt @@ -0,0 +1,2 @@ +python3 -B scripts/verify_selected_result.py +PASS selected record, exact kappa, original source inventory and proof supplement: 51110230636731/31250000000000000 diff --git a/research/reclamation-priority-performance/priority.py b/research/reclamation-priority-performance/priority.py new file mode 100644 index 0000000000..39630b575f --- /dev/null +++ b/research/reclamation-priority-performance/priority.py @@ -0,0 +1,87 @@ +"""Exact retired-slot geometry and priority index for the pinned compiler. + +Apache-2.0. Prepared for Peter Carpenter with substantial OpenAI Codex assistance. +The compiler and its original contributor notices are retained unchanged. +""" + + +class RankedSlots: + """A set with descending-current-rank, ascending-slot iteration. + + Call move before changing a retired slot's frame. The compiler does not + resume ordered iteration after a clearing XOR changes any frame. + """ + + def __init__(self, max_rank, state_of): + self.members = set() + self.masks = [0] * (max_rank + 1) + self.core_masks = [0] * max_rank + self.union_masks = [0] * max_rank + self.universe = (1 << max_rank) - 1 + self.all_mask = 0 + self.state_of = state_of + + def __contains__(self, slot): + return slot in self.members + + def __len__(self): + return len(self.members) + + def __iter__(self): + return iter(self.members) + + def add(self, slot): + if slot in self.members: + return + rank, frame = self.state_of(slot) + self.masks[rank] |= 1 << slot + self.all_mask |= 1 << slot + self._change_frame(slot, (0, 0), frame) + self.members.add(slot) + + def remove(self, slot): + self.members.remove(slot) + rank, frame = self.state_of(slot) + self.masks[rank] &= ~(1 << slot) + self.all_mask &= ~(1 << slot) + self._change_frame(slot, frame, (0, 0)) + + def move(self, slot, new_rank, new_frame): + if slot in self.members: + old_rank, old_frame = self.state_of(slot) + bit = 1 << slot + if old_rank != new_rank: + self.masks[old_rank] &= ~bit + self.masks[new_rank] |= bit + self._change_frame(slot, old_frame, new_frame) + + def _change_frame(self, slot, old, new): + for masks, before, after in zip((self.core_masks, self.union_masks), old, new): + changed = before ^ after + while changed: + bit = changed & -changed + masks[bit.bit_length() - 1] ^= 1 << slot + changed ^= bit + + def eligible(self, frame): + core, union = frame + eligible = self.all_mask + while core: + bit = core & -core + eligible &= self.core_masks[bit.bit_length() - 1] + core ^= bit + outside = self.universe ^ union + while outside: + bit = outside & -outside + eligible &= ~self.union_masks[bit.bit_length() - 1] + outside ^= bit + return eligible + + def ordered(self, frame): + eligible = self.eligible(frame) + for mask in reversed(self.masks): + mask &= eligible + while mask: + bit = mask & -mask + yield bit.bit_length() - 1 + mask ^= bit diff --git a/research/reclamation-priority-performance/reference-pr175.py b/research/reclamation-priority-performance/reference-pr175.py new file mode 100644 index 0000000000..4b658dc692 --- /dev/null +++ b/research/reclamation-priority-performance/reference-pr175.py @@ -0,0 +1,257 @@ +"""Exact-envelope block synthesis on the pinned PR48 scalar graph. +Experimental finite compiler; no fixed-I+J profile or multiplication claim. +""" +# Derived from eumemic's PR57 compiler; original notices remain applicable. +# Descending-rank reclamation priority: Chafik Boukhalfa, with OpenAI Codex assistance. +import sys +if sys.flags.optimize: + raise ValueError('Assertions must remain enabled') +sys.dont_write_bytecode=True +from pathlib import Path +ROOT=Path(__file__).resolve().parents[2]/'references/frame-compiler/pr48' +from hashlib import sha256 +import json +manifest=json.loads((ROOT/'SOURCE.json').read_text()) +for name,digest in manifest['files'].items(): + assert sha256((ROOT/name).read_bytes()).hexdigest()==digest, 'Changed producer source: '+name +sys.path[:0]=[str(ROOT/'scripts'),str(ROOT/'research/copied-fixed')] +from changed_graph import graph +from collections import defaultdict,Counter,deque +import argparse,json,time,struct +from bisect import bisect_left, insort + +def independent(rows,vec): + for row in rows: + vec=min(vec,vec^row) + return bool(vec) +def basis(rows): + out=[] + for vec in rows: + for row in out:vec=min(vec,vec^row) + if vec:out.append(vec) + return out + +def build(h): + c=graph(h);groups={};owner={};signal={};blocks=[] + for x in sorted(c.active): + key=(c.core[x],c.union[x]) + if key not in groups: + groups[key]=len(blocks);blocks.append(dict(nodes=[],frame=key,inputs=set(),uses=[])) + g=groups[key];owner[x]=g;blocks[g]['nodes'].append(x) + signal[x]=(signal[c.args[x][0]]^signal[c.args[x][1]])if c.args[x]else 1<<(x-1) + for x in sorted(c.active): + for y in c.args[x]or(): + if owner[y]!=owner[x]:blocks[owner[x]]['inputs'].add(y) + uses=[];value_uses=defaultdict(list) + for g,b in enumerate(blocks): + b['inputs']=sorted(b['inputs']);b['source']=not c.args[b['nodes'][0]] + for y in b['inputs']: + k=len(uses);uses.append((y,g,None));value_uses[y].append(k);blocks[owner[y]]['uses'].append(k) + for target,x in c.outputs.items(): + k=len(uses);uses.append((x,owner[x],target));value_uses[x].append(k);blocks[owner[x]]['uses'].append(k) + for g,b in enumerate(blocks): + b['rank']=1 if b['source']else b['frame'][1].bit_count()-b['frame'][0].bit_count() + order=sorted(range(len(blocks)),key=lambda g:(blocks[g]['rank'],min(blocks[g]['nodes']))) + place={g:i for i,g in enumerate(order)} + def contained(a,b):return not(b[0]&~a[0])and not(a[1]&~b[1]) + for g,b in enumerate(blocks): + coeff={y:1<1 for b in blocks) + # Keep the original descending-rank, ascending-slot selection order. + # A retired anchor can move during clearing: raise_ updates this index too. + retired_by_rank=[[] for _ in range(h+1)] + def retire_add(s): + assert s not in retired + retired.add(s);insort(retired_by_rank[blocks[frames[s]]['rank']],s) + def retire_remove(s): + bucket=retired_by_rank[blocks[frames[s]]['rank']] + i=bisect_left(bucket,s);assert i>s&1;e^=1<>i&1) + if j!=i: + # Synthesize swap as three XORs at the single common frame. + for a,z in ((i,j),(j,i),(i,j)):rr[a]^=rr[z];elim.append((a,z)) + for j in range(len(ins)): + if j!=i and rr[j]>>i&1:rr[j]^=rr[i];elim.append((j,i)) + assert rr==[1<>i&1:xor(s,value_slots[y],g) + assert slots[s]==signal[x];value_slots[x]=s + used=set() + for u in outuses: + x=uses[u][0];s=value_slots[x] + if x in used: + ss=acquire(g,list(value_slots.values()));xor(ss,s,g);s=ss + used.add(x);assert u not in assign;assign[u]=s + if step%5000==0:print('compile',h,step,len(slots),'reclaimed',stats['reclaimed'],'seconds',time.time()-t0,flush=True,file=sys.stderr) + output_slots=[];output_records=[];scatter=[0]*v;J=[] + for u,(x,g,target)in enumerate(uses): + if target is None:continue + s=assign[u];assert slots[s]==signal[x];raise_(s,g);output_slots.append(s) + common,triple=target;output_records.append((s,g,common,triple)) + targets=[i for i,t in enumerate(c.inputs)if common in t]if len(triple)==1 else[c.inputs.index(triple)] + for i in targets:scatter[i]^=slots[s];J.append((v+i,2*v+s)) + rank=blocks[g]['rank'] + if len(triple)==1:hist[rank]+=1;hist[h-rank]+=1 + else:hist[h-1-rank]+=1;hist[1]+=1 + assert len(set(output_slots))==len(output_slots) + for s in retired:hist[h-blocks[frames[s]]['rank']]+=1 + assert len(retired)+len(output_slots)==len(slots) + assert scatter==[1<> i) & 1} + core, union = map(points, target) + admitted = [] + for slot in index.members: + rank, frame = index.state_of(slot) + old_core, old_union = map(points, frame) + if core <= old_core and old_union <= union: + admitted.append((-rank, slot)) + return [slot for _, slot in sorted(admitted)] + + +class PriorityTests(unittest.TestCase): + def assert_order(self, index, target): + self.assertEqual(list(index.ordered(target)), oracle(index, target)) + self.assertEqual(len(index), len(set(index))) + + def test_exhaustive_three_coordinate_frames(self): + frames = [frame_from_digits(d) for d in product(range(3), repeat=3)] + states = {slot * 7: state(frame) for slot, frame in enumerate(frames)} + index = RankedSlots(3, states.__getitem__) + for slot in reversed(states): + index.add(slot) + for target in frames: + self.assert_order(index, target) + for slot in states: + index.remove(slot) + for target in frames: + self.assert_order(index, target) + + def test_seed85_state_machine_with_sparse_large_slot_ids(self): + rng = random.Random(85) + slots = list(range(96)) + [127, 128, 255, 1024, 30687, 40337] + states = {slot: state(frame_from_digits(rng.choices(range(3), k=25))) for slot in slots} + index = RankedSlots(25, states.__getitem__) + for _ in range(2400): + slot = rng.choice(slots) + action = rng.randrange(4) + if action == 0: + index.add(slot) + elif action == 1 and slot in index: + index.remove(slot) + else: + new_state = state(frame_from_digits(rng.choices(range(3), k=25))) + index.move(slot, *new_state) + states[slot] = new_state + targets = [(0, (1 << 25) - 1), states[rng.choice(slots)][1]] + for target in targets: + self.assert_order(index, target) + + def test_same_rank_frame_changes_update_eligibility(self): + states = {7: (1, (1, 3))} + index = RankedSlots(3, states.__getitem__) + index.add(7) + index.move(7, 1, (2, 6)) + states[7] = (1, (2, 6)) + self.assert_order(index, (1, 3)) + self.assert_order(index, (2, 6)) + + def test_retired_clearing_anchor_moves_then_slot_is_removed(self): + states = {3: (1, (1, 3)), 8: (1, (1, 3)), 10: (2, (1, 7))} + index = RankedSlots(3, states.__getitem__) + for slot in states: + index.add(slot) + iterator = index.ordered((1, 7)) + self.assertEqual(next(iterator), 10) + # Match acquire's contract: clearing moves both operands, removes the + # chosen slot and returns without resuming this iterator. + for slot in (10, 3): + index.move(slot, 2, (1, 7)) + states[slot] = (2, (1, 7)) + index.remove(10) + self.assert_order(index, (1, 7)) + self.assertEqual(list(index.ordered((1, 7))), [3, 8]) + + def test_duplicate_add_and_missing_remove_keep_set_semantics(self): + states = {0: (1, (1, 1))} + index = RankedSlots(3, states.__getitem__) + index.add(0) + index.add(0) + self.assert_order(index, (1, 7)) + index.remove(0) + with self.assertRaises(KeyError): + index.remove(0) + self.assert_order(index, (0, 7)) + + def test_stale_move_mutant_is_detected(self): + states = {5: (1, (1, 3)), 6: (2, (1, 7))} + index = RankedSlots(3, states.__getitem__) + for slot in states: + index.add(slot) + states[5] = (3, (0, 7)) # deliberately omit the move hook + self.assertNotEqual(list(index.ordered((1, 7))), oracle(index, (1, 7))) + + def test_core_union_and_rank_mutants_are_detected(self): + states = {2: (1, (1, 3)), 4: (2, (1, 7)), 8: (1, (2, 3))} + for mutation in ("core", "union", "rank", "remove"): + with self.subTest(mutation=mutation): + index = RankedSlots(3, states.__getitem__) + for slot in states: + index.add(slot) + if mutation == "core": + index.core_masks[0] |= 1 << 8 + elif mutation == "union": + index.union_masks[2] &= ~(1 << 4) + elif mutation == "rank": + index.masks[2] &= ~(1 << 4) + index.masks[1] |= 1 << 4 + else: + index.members.remove(2) # deliberately leave stale bits + target = (1, 7) if mutation == "rank" else (1, 3) + self.assertNotEqual(list(index.ordered(target)), oracle(index, target)) + + +class AdmissionTests(unittest.TestCase): + def test_pinned_sources_and_three_exact_edit_sites(self): + verify_sources() + source = (ROOT / COMPILER).read_text() + transformed = transformed_source(source) + self.assertIn("if not contains(blocks[frames[s]]['frame'],blocks[g]['frame']):continue", transformed) + self.assertIn("for dual in (False,True):", transformed) + self.assertIn("assert not slots[s]", transformed) + with self.assertRaisesRegex(ValueError, "source shape changed"): + transformed_source(source + source) + + def test_tampered_compiler_and_archive_are_rejected_before_import(self): + read_bytes = Path.read_bytes + for target in (ROOT / COMPILER, HERE / "reference-pr175.py"): + with self.subTest(target=target): + def altered(path): + data = read_bytes(path) + return data + b"\n# control" if path == target else data + with patch.object(Path, "read_bytes", altered): + with self.assertRaisesRegex(ValueError, "Changed pinned source"): + verify_sources() + + def test_reused_output_is_rejected_before_compilation(self): + with self.assertRaisesRegex(ValueError, "fresh directory"): + run("indexed", 23, HERE) + + def test_disabled_assertions_are_rejected_without_outputs(self): + # Keep generated fixtures available for inspection, including failures. + directory = Path(tempfile.mkdtemp(prefix="reclamation-admission-")) + for flag in ("-O", "-OO"): + output = directory / flag.lstrip("-") + result = subprocess.run([sys.executable, flag, "-B", str(HERE / "run.py"), + "--mode", "indexed", "--h", "23", "--out", str(output)], + capture_output=True, text=True) + self.assertNotEqual(result.returncode, 0) + self.assertIn("Assertions must remain enabled", result.stderr) + self.assertFalse(output.exists()) + + def test_missing_frame_update_hook_fails_real_compilation(self): + directory = Path(tempfile.mkdtemp(prefix="reclamation-stale-hook-")) + code = f""" +import sys +from pathlib import Path +sys.path.insert(0, {str(HERE)!r}) +import adapter +from priority import RankedSlots +from run import run +class StaleSlots(RankedSlots): + def move(self, slot, new_rank, new_frame): + pass +adapter.RankedSlots = StaleSlots +run('indexed', 23, Path({str(directory / 'run')!r})) +""" + result = subprocess.run([sys.executable, "-B", "-c", code], + capture_output=True, text=True, timeout=120) + (directory / "stderr.txt").write_text(result.stderr) + self.assertNotEqual(result.returncode, 0) + self.assertNotIn("PASS_RECLAMATION_AXIS", result.stdout) + self.assertTrue("AssertionError" in result.stderr or "receipt differs" in result.stderr, + result.stderr) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/research/reclamation-priority-performance/verify.py b/research/reclamation-priority-performance/verify.py new file mode 100644 index 0000000000..c10ec3616a --- /dev/null +++ b/research/reclamation-priority-performance/verify.py @@ -0,0 +1,28 @@ +"""One-command reproduction of the scoped priority-index contribution.""" + +import argparse +from pathlib import Path +import subprocess +import sys + +from adapter import HERE, require, verify_sources + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--rounds", type=int, default=1) + args = parser.parse_args() + verify_sources() + require(1 <= args.rounds <= 7, "Use one through seven rounds") + require(not args.out.exists(), "Output must be a fresh directory") + args.out.mkdir(parents=True) + commands = [[sys.executable, "-B", str(HERE / "test_priority.py")]] + for h in (23, 25): + commands.append([sys.executable, "-B", str(HERE / "audit_index.py"), + "--h", str(h), "--out", str(args.out / f"audit-{h}")]) + commands.append([sys.executable, "-B", str(HERE / "benchmark.py"), + "--rounds", str(args.rounds), "--out", str(args.out / "benchmark")]) + for command in commands: + subprocess.run(command, check=True) + print("PASS_RECLAMATION_PRIORITY", flush=True)