From f594a080b02ed44b66ea588d5cc2b14762b76b47 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Wed, 18 Nov 2026 20:41:20 +0000 Subject: [PATCH 1/2] feat(research): prove the symbolic two-target switch core Derive the invariant agreement set across binary radices and window widths by tracking the temporary and source carries. Extend the five-translation minimum to the stated packing range. --- .../compact-two-target-symbolic-core/PROOF.md | 151 ++++++++++++++++++ .../README.md | 99 ++++++++++++ .../SOURCES.json | 24 +++ .../TASK.json | 89 +++++++++++ .../VERIFY.json | 34 ++++ .../verify.py | 130 +++++++++++++++ 6 files changed, 527 insertions(+) create mode 100644 research/compact-two-target-symbolic-core/PROOF.md create mode 100644 research/compact-two-target-symbolic-core/README.md create mode 100644 research/compact-two-target-symbolic-core/SOURCES.json create mode 100644 research/compact-two-target-symbolic-core/TASK.json create mode 100644 research/compact-two-target-symbolic-core/VERIFY.json create mode 100644 research/compact-two-target-symbolic-core/verify.py diff --git a/research/compact-two-target-symbolic-core/PROOF.md b/research/compact-two-target-symbolic-core/PROOF.md new file mode 100644 index 0000000000..ab90c79f24 --- /dev/null +++ b/research/compact-two-target-symbolic-core/PROOF.md @@ -0,0 +1,151 @@ +# The invariant core of the two-target compact switch + +## Word and agreement contract + +Let the control radix $B=2^g$ and window modulus $N=2^m$ satisfy +$g\ge 1$ and $N>B$. Put $L=2N$. Write the two control fields as +$u=u_0+Bu_1$ and $t=t_0+Bt_1$, taken modulo $B^2$. The data field is + +$$ +y=b_0+2W_0+L(b_1+2W_1)\pmod{L^2}, +$$ + +with $0\le W_iB$ and +the inactive subcall cannot cancel it. Thus every invariant +agreement requires $t_0B$. + +Conversely, under (1), neither subcall has a temporary carry or a +lower-window spill. Each flips its active target bits and leaves +both windows and the entire temporary field fixed. The source load +complements both active parities, and the final source unload +restores the entire source field. Therefore $S=T$ on (1). All four +conditions are independent of the target bits, so their intersection +is $T$-invariant. + +The condition $N>B$ is used to see the saturation error in the +restored window. For example, at $N=B=4$ the state $(u,t,y)=(0,12,0)$ +and its ideal mate both agree even though $t_1$ is saturated. The +upper-window increment wraps at the full data modulus. + +## Translation consequence + +An entry translates each digit and each window independently by a +fixed constant modulo its own period. It preserves both target bits +and therefore commutes with $T$. A selector with +$\sigma(T(x))=\sigma(x)$ can use an entry on the ideal orbit of $x$ +exactly when the translated state belongs to (1). The selector is +logical. Its preparation, execution and cleanup have separate costs. + +For $B\ge4$, four entries cannot cover (1). Extend the finite +adversary of PR #7197 as follows. Label four entries $C,D,E,F$. +Order the first two so that their lower-temporary shifts differ +by something other than $1$ from $C$ to $D$ modulo $B$. Such an +order exists because reversing a difference of $1$ gives $-1$. +Choose $u_0$ to saturate in $E$, $t_1$ to saturate in $F$, and +$t_0$ to saturate in $C$. The translated $t_0$ in $D$ is then +some $v>0$. Choose $W_0$ to become $N-v$ in $D$. The first three +entries each fail a saturation condition, while $D$ fails the +window inequality. Any smaller nonempty menu pads to four by +repetition. + +For $B\ge8$ and $N\ge5(B-2)$, PR #6812's five-entry menu applies. +In phase $k\in\{0,1,2,3,4\}$, shift $u_0,t_0,t_1$ by $k$ and +$W_0$ by $k(B-2)$. Each guarded control rejects at most one phase. +The five preimages of $W_0>N-B+1$ are disjoint intervals of length +$B-2$, so the window rejects at most one phase. At least one phase +has all three nonsaturated controls and $W_0\le N-B+1$, which +implies $W_0+t_0B`, the +two-target compact switch with constant source bits `(1,1)` agrees +with the ideal XOR on both members of an ideal orbit exactly when + +```text +u0 < B-1, t0 < B-1, t1 < B-1, W0 + t0 < N. +``` + +[The proof](PROOF.md) establishes this formula for every binary +radix and width in the stated range. PR #7197 obtained the formula +at `B=8, N=32` by finite enumeration and left the symbolic +classification open. The new proof accounts for lower-window +spills across the two subcalls, source-load carries, and saturation +in both temporary digits. The word and five-phase upper construction +come from PR #6812. [PR #7197](https://github.com/CrocSwap/integer-mult-bounds/pull/7197) · [PR #6812](https://github.com/CrocSwap/integer-mult-bounds/pull/6812) + +The formula implies that four independent coordinate translations +cannot cover the invariant core when `B>=4`. The minimum is exactly +five when `B>=8` and `5(B-2)<=N`, with a selector that takes the same +value at both ends of the ideal XOR. This is a scoped algebraic proof +with finite corroboration. + +## Reproduce + +Run from the repository root with CPython 3.12. The local runs use +CPython 3.12.15 on macOS 27.0.1 arm64 and the standard library. + +```sh +python3.12 -I -W error -B research/compact-two-target-symbolic-core/verify.py +python3.12 -I -O -W error -B research/compact-two-target-symbolic-core/verify.py +python3.12 -B scripts/research_package.py --package research/compact-two-target-symbolic-core +python3.12 -B scripts/check_research_commit.py --package research/compact-two-target-symbolic-core --check-source-history +``` + +The direct check writes a report with marker +`PASS_COMPACT_TWO_TARGET_SYMBOLIC_CORE` and SHA256 hashes of the six +package files. It compares the formula with literal packed execution +of both orbit members when needed. Across 984,064 input states it finds +534,112 invariant agreement states. It exhausts the complete dirty +fields at `(B,N)=(2,4),(4,8),(4,16)`. At `(8,16),(8,64)` it sweeps +every lower coordinate and temporary field with both upper source +parities and the four upper block endpoints. The prior +`(B,N)=(8,32)` census is not replayed. + +The check also covers all 557,056 relevant coordinate tuples for +the five-entry menus at `(8,64),(16,128)`. Deleting the last entry +misses 72 and 168 tuples, respectively. Seven controls cover all +four clauses, the safe side of the window boundary, an individual raw +agreement whose ideal mate fails, and a valid full-width wrap at +`N=B`. + +The largest state grid has 524,288 inputs and the largest cover check +has 524,288 tuples times five phases. The verifier streams the input +grids and keeps no state-indexed table. CPython allocates finite +integer and tuple values during execution. Every failure check +remains active under optimization. + +## Scope + +The proof concerns the two fixed target positions, exactly two +digits per control, constant sources and the declared live-digit +word. Its cover corollary assumes independent coordinate +translations and an invariant selector. The physical translation, +selection, data movement, cleanup and recursive costs remain open. +No selected assumption, full caller or κ is established. The selected +metadata baseline passed. The selected scientific cold replay, Lean, +Docker, independent human review and formal proof-kernel review are +unclaimed. + +The `uniform-transfer-audit` card changes scope to this logical CRT +switch question. The core determines which addresses each translation +can serve without exceptional repair. [Advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19717713) + +## Open next questions + +- **Other source pairs.** Derive the invariant core when exactly one + source is constant one. The two lower parities then need not be + complementary. Begin with the resulting spill and restoration + equations before classifying any cover. +- **Small-radix menus.** Find the exact minimum when + `B>=4` and the five-phase packing conditions fail. Begin by deriving + a cover on the four relevant coordinates. The four-entry adversary + already applies there, while five-phase attainment is open. + +## Credit + +This contribution was produced by Nick Petalas. Apache-2.0. Credit the +finite predecessor and its first open question to PR #7197 at +`47419abcd185a088a6b5d2ef9e721ef2651d9729`, and the raw word and +sufficient cover to Benny Zhao in PR #6812 at +`297ad233e8d00d7a7af4a09dc13fed90ede63dc4`. The translation and +conjugation method comes from PR #6231. Credit Cinna Davis's PR #4100 +and unpaidmoon's PR #4321 for the compact-switch and live-digit +contracts, John-Michael Smith and Hanson Sun for the terminal carry +and window arguments, and Arham Tahir, Aaron Wang, woklerx and +Douglas Colkitt for the retained agreement and repair work. +[Finite predecessor proof](https://github.com/petalas/integer-mult-bounds/blob/47419abcd185a088a6b5d2ef9e721ef2651d9729/research/compact-two-target-translation-minimum/PROOF.md) diff --git a/research/compact-two-target-symbolic-core/SOURCES.json b/research/compact-two-target-symbolic-core/SOURCES.json new file mode 100644 index 0000000000..a6ea730697 --- /dev/null +++ b/research/compact-two-target-symbolic-core/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/terminal-carry-guard-cover/PROOF.md", + "usage": "provenance", + "git_blob": "3dc4c0be7f6d0166407ba1bf27e5bf176f784a6f", + "sha256": "80833edf2a4796c07eb7b1be993e7dfe87123f13f6f8bc0d25c73a800cbc96f3" + } + ] +} diff --git a/research/compact-two-target-symbolic-core/TASK.json b/research/compact-two-target-symbolic-core/TASK.json new file mode 100644 index 0000000000..e5b04c09c8 --- /dev/null +++ b/research/compact-two-target-symbolic-core/TASK.json @@ -0,0 +1,89 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Derive the exact maximal invariant agreement core of the all-one two-target compact switch for every binary radix B and window modulus N>B. Apply the core to the independent translation minimum under an invariant selector.", + "scope_change_reason": "PR #7197 leaves the symbolic invariant core open after its finite B=8, N=32 classification. This logical CRT switch question uses the PR #6812 word and changes the selected-assumption audit premise.", + "bottleneck_link": "The core gives the exact eligible address set for each translated switch in this logical CRT interface. It can bound the number of phases required before selection, movement and repair are priced.", + "budget_minutes": 60, + "stop_rule": "Stop after a written core proof and a bounded literal packed replay on new geometries, including the natural translation corollary.", + "outcome": "completed", + "evidence": "Symbolic proof for N>B, plus 984064 new packed input states, 557056 cover tuples and seven boundary controls. The written proof supplies the all-width and arbitrary-menu quantifiers.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "What is the invariant core when one of the two constant source bits is zero?", + "why_it_matters": "A changed source pair may admit more addresses for each translation.", + "first_step": "Write the two lower parity trajectories and derive their net temporary and window defects.", + "blocked_by": "The lower parities need not be complementary. The present single-active-subcall argument does not apply." + }, + { + "question": "What is the exact menu minimum for B>=4 outside the five-phase packing range?", + "why_it_matters": "The four-entry obstruction applies there but does not provide an attaining menu.", + "first_step": "Construct and price a cover of the four relevant restored coordinates at B=4 and N=8.", + "blocked_by": "Five disjoint bad-preimage intervals and five distinct control shifts are not both guaranteed." + } + ] +} diff --git a/research/compact-two-target-symbolic-core/VERIFY.json b/research/compact-two-target-symbolic-core/VERIFY.json new file mode 100644 index 0000000000..f8d50a26e8 --- /dev/null +++ b/research/compact-two-target-symbolic-core/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Literal packed invariant-core membership, five-phase covers and boundary controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Literal packed invariant-core membership, five-phase covers and boundary controls." + } + ] +} diff --git a/research/compact-two-target-symbolic-core/verify.py b/research/compact-two-target-symbolic-core/verify.py new file mode 100644 index 0000000000..54f51a59d2 --- /dev/null +++ b/research/compact-two-target-symbolic-core/verify.py @@ -0,0 +1,130 @@ +"""Check the symbolic two-target core against the literal packed word.""" + +from hashlib import sha256 +from itertools import product +import json +from pathlib import Path + +State = tuple[int, int, int] + + +def packed_step(u: int, t: int, y: int, base: int, block: int) -> tuple[int, int]: + z0, z1 = u & 1, (u // base) & 1 + data_modulus = block**2 + control_modulus = base**2 + y = (y + 2 * z0 * (t % base) + 2 * z1 * (t // base) * block) % data_modulus + load = (y & 1) + base * ((y // block) & 1) + t = (t + load) % control_modulus + y = (y + z0 * (1 - 2 * (t % base)) + z1 * (1 - 2 * (t // base)) * block) % data_modulus + unload = ((y & 1) ^ z0) + base * (((y // block) & 1) ^ z1) + return (t - unload) % control_modulus, y + + +def raw(state: State, base: int, window: int) -> State: + u, t, y = state + block = 2 * window + t, y = packed_step(u, t, y, base, block) + loaded = (u + 1 + base) % base**2 + t, y = packed_step(loaded, t, y, base, block) + return (loaded - 1 - base) % base**2, t, y + + +def ideal(state: State, window: int) -> State: + u, t, y = state + return u, t, y ^ (1 + 2 * window) + + +def in_core(state: State, base: int, window: int) -> bool: + u, t, y = state + upper_temp, lower_temp = divmod(t, base) + lower_window = (y // 2) % window + return (u % base < base - 1 and lower_temp < base - 1 + and upper_temp < base - 1 and lower_window + lower_temp < window) + + +def literal_core(state: State, base: int, window: int) -> bool: + mate = ideal(state, window) + return raw(state, base, window) == mate and raw(mate, base, window) == state + + +def check_domain(base: int, window: int, complete: bool) -> dict: + # Largest grid is 8 * 2 * 64 * 128 * 4. The upper representatives on + # partial grids include both parities at both ends of the window. + block = 2 * window + upper_controls = range(base) if complete else (0, base - 1) + upper_blocks = range(block) if complete else (0, 1, block - 2, block - 1) + states = agreements = 0 + for u0, u1, t, lo, hi in product( + range(base), upper_controls, range(base**2), range(block), upper_blocks + ): + state = u0 + base * u1, t, lo + block * hi + actual = literal_core(state, base, window) + if actual != in_core(state, base, window): + raise ValueError(f"core mismatch at B={base}, N={window}, state={state}") + agreements += actual + states += 1 + return dict(base=base, window=window, complete=complete, states=states, core=agreements) + + +def check_cover(base: int, window: int) -> dict: + # At most 16**3 * 128 tuples; each checks the five stated translations. + bad_without_last = 0 + for u0, t0, t1, lower_window in product(range(base), range(base), range(base), range(window)): + good_phases = [] + for phase in range(5): + u = (u0 + phase) % base + t = (t0 + phase) % base + base * ((t1 + phase) % base) + y = 2 * ((lower_window + phase * (base - 2)) % window) + if in_core((u, t, y), base, window): + good_phases.append(phase) + if not good_phases: + raise ValueError(f"uncovered coordinate tuple at B={base}, N={window}") + bad_without_last += good_phases == [4] + if bad_without_last == 0: + raise ValueError("shortened menu unexpectedly covers the grid") + return dict(base=base, window=window, tuples=base**3 * window, + missed_without_last=bad_without_last) + + +def check_controls() -> list[str]: + controls = { + "lower temporary saturation": (0, 3, 0), + "upper temporary saturation": (0, 12, 0), + "source carry": (3, 0, 0), + "lower window spill": (0, 1, 14), + } + for name, state in controls.items(): + if literal_core(state, 4, 8): + raise ValueError(f"failed to expose {name}") + if not literal_core((0, 1, 12), 4, 8): + raise ValueError("safe side of the lower-window boundary failed") + saturated_upper = controls["upper temporary saturation"] + if raw(saturated_upper, 4, 8) != ideal(saturated_upper, 8): + raise ValueError("expected a raw agreement whose ideal mate fails") + if not literal_core(saturated_upper, 4, 4): + raise ValueError("expected the upper-window error to wrap at N=B") + return [*controls, "safe window boundary", "raw agreement only", "wrap at N=B"] + + +def main() -> None: + checks = [ + check_domain(2, 4, complete=True), + check_domain(4, 8, complete=True), + check_domain(4, 16, complete=True), + check_domain(8, 16, complete=False), + check_domain(8, 64, complete=False), + ] + covers = [check_cover(8, 64), check_cover(16, 128)] + controls = check_controls() + directory = Path(__file__).resolve().parent + package_hashes = { + name: sha256((directory / name).read_bytes()).hexdigest() + for name in ("README.md", "PROOF.md", "TASK.json", "SOURCES.json", "VERIFY.json", "verify.py") + } + print(json.dumps(dict(status="PASS_COMPACT_TWO_TARGET_SYMBOLIC_CORE", domains=checks, + covers=covers, controls=controls, package_sha256=package_hashes), + indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() From 3d6b5586a43240d5d166912b4873a2009b281de7 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Wed, 18 Nov 2026 20:43:51 +0000 Subject: [PATCH 2/2] fix(ci): sync CI verification doc and historical replay-gap verifier --- docs/ci-verification.md | 19 +++++- .../historical-selected-replay-gap/README.md | 6 +- .../SOURCES.json | 60 +++++++++--------- .../VERIFY.json | 31 +-------- .../historical-selected-replay-gap/verify.py | 63 ++++++++++++++----- 5 files changed, 100 insertions(+), 79 deletions(-) diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 63ba3e9aa8..52b62d0481 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -1,8 +1,25 @@ # CI verification -## Current selected-family replay: #6030 +## Current selected-family replay: #7000 with #7001 The [selected record](../certificates/selected-result.json) binds conditional +κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md), +[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json), +and [explicit source closure](../certificates/frontier7000-source.json). +`make frontier7000-verify` follows that exact-source selected replay. The review +reuses eleven authenticated preceding executions and records seven fresh serial +application, scalar and complete native-catalogue executions. The earlier +monolithic timeout is retained separately and is not completed coverage. +Consult the receipts for exact commands, source heads and limits. + +The five inherited framework assumptions remain. No complete uniform word, +literal multiplier execution, independent human proof or formal-kernel proof +is asserted. Routine research submissions do not need to rerun this +selected-family replay. The sections below preserve historical checkpoints. + +## Historical selected-family replay: #6030 + +The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md), [validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json), and [explicit source closure](../certificates/frontier6030-source.json). diff --git a/research/historical-selected-replay-gap/README.md b/research/historical-selected-replay-gap/README.md index 55d8cc3b49..36d9a873ca 100644 --- a/research/historical-selected-replay-gap/README.md +++ b/research/historical-selected-replay-gap/README.md @@ -69,7 +69,11 @@ python3 -B scripts/research_package.py --package research/historical-selected-re The direct command prints `PASS_HISTORICAL_SELECTED_REPLAY_GAP`. A registered replay prints `PASS_REGISTERED_RESEARCH_PACKAGE`. Both require Git history -containing the two inspected commits. +containing the two inspected commits and the source and manifest objects at +`2485805a6d47f36ea83ddde6327d453ac82d44dc`. The verifier uses a temporary +sparse checkout of that commit, checks the declared source digests there, and +uses its planner and manifest inventory. The recorded rejections and selection +therefore remain reproducible after later changes to the live Makefile or CI guide. ## Open next questions diff --git a/research/historical-selected-replay-gap/SOURCES.json b/research/historical-selected-replay-gap/SOURCES.json index c1010eec95..62bb8b3950 100644 --- a/research/historical-selected-replay-gap/SOURCES.json +++ b/research/historical-selected-replay-gap/SOURCES.json @@ -4,13 +4,13 @@ "files": [ { "path": "Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "0d683a06b9e7ee162496108ce9a7c5d2ee94fccf", "sha256": "4f2d4f2dcd15139ec82658a975f85ed300897385f85799218539f4c8d60567da" }, { "path": "certificates/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "eccafa830c16170c36faf93045ddf1f638f7bcd4", "sha256": "4c0b9d37e1034b2076e30a70f8e514416298c462d9ee98bc87fe6556b14df786" }, @@ -22,7 +22,7 @@ }, { "path": "docs/ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "63ba3e9aa8bdc5e942b56e34244b92b16f854085", "sha256": "c7d3027e9ad8bcbff68f07aa9576b30fb2f3c76c44d876d40c7fdbf4a3e2228a" }, @@ -34,163 +34,163 @@ }, { "path": "research/clifford-state-performance/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "6f98a0061a5104dfab82c9e806f819b41811f684", "sha256": "396d0f08df24952248140d5c65c51b8c902ef1c580892ff7ea182890530f67ee" }, { "path": "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "5e0f92af463ec12c5e1dcc3effd44081a88af647", "sha256": "07a9daeaf2bda308a92e9a4684f13d5fc766c7772d74801fceb7f4599fdab226" }, { "path": "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "9e13266bf85e627f1b7dc225e9530ea69fd2c7f0", "sha256": "421e1211fb1897c45621dc6801c276e53f2e6f335583c9c9049e535f87c0a3b1" }, { "path": "research/community-batch932-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "cc4d03eb59b9ab3f952735f7e88ff18c2d15d7af", "sha256": "184629cac91a5cfaca50330a88596008b824221433867dcf8117539c913c284a" }, { "path": "research/community-batch970-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8b9f4111badf7de5d97684799560b55110e9da79", "sha256": "23188ed920e38a54006cb883e181585620821c63bf7e8b5e05d32719417cc37e" }, { "path": "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "a5300d4e7a5381a3f443fc54c768ca6f0f236d68", "sha256": "3c820fb30e1b4d9bcfc6a7ab524375e5b2abd66b940af2c509146104f0bcd79c" }, { "path": "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "d7ff6d777b01d69b6ce84caf25d3b7e4a4d2f211", "sha256": "6b185a9902652f893f3ebd8ada92d2f11b6de6533a9a4d11718a8a4496101128" }, { "path": "research/community-hyperplane599-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "546f37d326d10a99910ae8f908e71ef768524d98", "sha256": "65099d764bfcc39bda5e4d9966783611b094c3522dbdd1435cd498d657a8ef8e" }, { "path": "research/community-k492-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "e538481e4cb16ed936d3195f2dfb5b5a9ca0a76b", "sha256": "2c0f4fa5bc150d05658af2e7c54c4d2c337dd52b7efd3d69530ae73bcbdf452a" }, { "path": "research/community-reconciliation92-audit/MANIFEST.json", - "usage": "input", + "usage": "provenance", "git_blob": "2a2e93685173d5f13cbb5abe740f5d90352e0228", "sha256": "5f501f3c118131e7d069f30ad77186eb2ad6961f9680a0ef105f4514ed41808a" }, { "path": "research/partial-swap-digest/baseline.py", - "usage": "input", + "usage": "provenance", "git_blob": "a2f0190704db83bd8ef48e46e723c49b925804fe", "sha256": "81e9af92cdf38243a540cdcff2062778e449467848d444da37a9553c12ca4c34" }, { "path": "research/r420-two-sided-basis/SOURCES.json", - "usage": "input", + "usage": "provenance", "git_blob": "5d718e11e62f4bcadecf1e02d6b61f87dbe190b0", "sha256": "d9810b0d139c5a1211fd2c1f0d142187cc1fca30026e1e7bc4f9ecfacf1596d1" }, { "path": "research/skip-clones/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8d1bb3b9c8189e35e5d8bfdfa632d7473e8be0d5", "sha256": "0b68e63e35a97ce6b0cdb6e291b88ebaa8f2dd4afb70b2498f10ee89428258dc" }, { "path": "research/split-skip/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "2ab610b6ea2edd2865fda793ef2168b0c76afb4f", "sha256": "7c2b4646a3ecfef6f881da5c43e4bd0fa9a4d1b00548b8ab458d897e16735134" }, { "path": "scripts/historical-ci-inputs/Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "aff68409021c9d401a6f8013b9dfd7dbcc30f2a8", "sha256": "ea8830dd79da493e2d75baf753d733ff7efbcf2b4794afe41fae0ac8f3055646" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "65db599ab0b1dea0312c4ca048e0bd0f44c3736f", "sha256": "96ea543e6c707424afe247e77bd86c82152f90fc76a0773c4232145da5cdf8d1" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "34820a8f24678f918f4d0e7a35380d8013fc3495", "sha256": "628391b6abfbc8674ceec1751867a4392f2cc0b5b66886243e139af86cf355ac" }, { "path": "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "c755b76e0d44ba4917aa94440ebe54daefce5b2a", "sha256": "d7fd929726b326aeeaf0a3996475adec88eee9aac09ae0bebeeaa0bc1fc8f199" }, { "path": "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "7f3c012504187917a728b9fe87043f0fc8cd006a", "sha256": "a854022e0e1d5d4db4d60e586be3ea56005013ef14a1fc06d02bc06e8529c4b0" }, { "path": "scripts/historical-ci-inputs/partial-swap-context.json", - "usage": "input", + "usage": "provenance", "git_blob": "ad65114886bf34a4fd27e79f3be502389e689faa", "sha256": "833a9642f33aeab2ffea17ec9c6b82e0a953f90192b2c82e10bef21538dccba9" }, { "path": "scripts/historical-ci-inputs/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "52075f2463f60af5e16571347f24274fce73a1ea", "sha256": "f3c4be597b2f2136da4ae2cc80c7454f63c90aa01f84e5b8131cee4dd55de815" }, { "path": "scripts/partial_swap/shared.py", - "usage": "input", + "usage": "provenance", "git_blob": "44a0e454c70f9c4b98e258b8443612e6a119904b", "sha256": "5a0646a50b9f3e8ea55168620a78e8853b0ab810517cefc8cfb8696aedee278a" }, { "path": "scripts/replay_historical_check.py", - "usage": "input", + "usage": "provenance", "git_blob": "1e92fff2782970ef71378f594f2350d245a4db26", "sha256": "5467619c78183d3adc82b0cb55af28e5c1a01fca2b0588677816244b53e2bafd" }, { "path": "scripts/research_package.py", - "usage": "input", + "usage": "provenance", "git_blob": "091b4c8f58bac9a9580d76025b887dc5c873d05f", "sha256": "e1256016e7f51827d04fa2179255989f639ae1d97afaa9c16265f85a0c6abd70" }, { "path": "scripts/run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "a96ab35b315ce492e7fbbfd6c5ae211aa066b541", "sha256": "49eb56dd0fc0d8d8ffdb209970a7adf2176223580646f575d5c22e59543b381c" }, { "path": "scripts/verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "6882a4700e410dec569b51ae2eaf1a19cc019195", "sha256": "d6b305eac5b9bdb8172c469ad30a1655a60fa0aceac8b1bf610e1b73f51babd8" }, { "path": "tests/test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "343b24abf6719b81805eba5a84c74e57634c8288", "sha256": "3a5470d0b139828b90e19bf9583ddeafcd69f8e34f2824664eb3a2958a52e34d" } diff --git a/research/historical-selected-replay-gap/VERIFY.json b/research/historical-selected-replay-gap/VERIFY.json index 98553e72ed..ab7efa3471 100644 --- a/research/historical-selected-replay-gap/VERIFY.json +++ b/research/historical-selected-replay-gap/VERIFY.json @@ -4,36 +4,7 @@ "python": "3.12", "requirements": [], "inputs": [ - "Makefile", - "certificates/partial-swap-network.json", - "docs/ci-verification.md", - "research/clifford-state-performance/SOURCE.json", - "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "research/community-batch932-audit/CONTENT-COVERAGE.json", - "research/community-batch970-audit/CONTENT-COVERAGE.json", - "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "research/community-hyperplane599-audit/SOURCE.json", - "research/community-k492-audit/SOURCE.json", - "research/community-reconciliation92-audit/MANIFEST.json", - "research/partial-swap-digest/baseline.py", - "research/r420-two-sided-basis/SOURCES.json", - "research/skip-clones/SOURCE.json", - "research/split-skip/SOURCE.json", - "scripts/historical-ci-inputs/Makefile", - "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "scripts/historical-ci-inputs/partial-swap-context.json", - "scripts/historical-ci-inputs/partial-swap-network.json", - "scripts/partial_swap/shared.py", - "scripts/replay_historical_check.py", - "scripts/research_package.py", - "scripts/run_isolated_tests.py", - "scripts/verify_selected_result.py", - "tests/test_isolated_test_runner.py" + "scripts/research_package.py" ], "commands": [ { diff --git a/research/historical-selected-replay-gap/verify.py b/research/historical-selected-replay-gap/verify.py index 83b995941a..9d266c5a4e 100644 --- a/research/historical-selected-replay-gap/verify.py +++ b/research/historical-selected-replay-gap/verify.py @@ -6,8 +6,10 @@ """ import hashlib import importlib.util +import json import subprocess import sys +import tempfile from pathlib import Path ROOT = Path(__file__).resolve().parents[2] @@ -61,31 +63,47 @@ def require(ok, message): raise SystemExit(message) -def load_checker(): - path = ROOT / "scripts/replay_historical_check.py" - spec = importlib.util.spec_from_file_location("historical_selected_replay_gap_checker", path) +def load_module(path): + spec = importlib.util.spec_from_file_location(path.stem, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module +def checkout_snapshot(snapshot, sources, runner, env): + paths = [runner.canonical_relative_path(row["path"]) for row in sources["files"]] + git = ["git", "-c", "maintenance.auto=false", "-c", "gc.auto=0", + "-c", "core.autocrlf=false"] + subprocess.run([*git, "clone", "--quiet", "--shared", "--no-tags", "--no-checkout", + "--", str(ROOT), str(snapshot)], cwd=ROOT, env=env, check=True) + subprocess.run([*git, "update-ref", "--no-deref", "HEAD", INSPECTED], + cwd=snapshot, env=env, check=True) + # The pinned planner reads omitted manifests from the sparse HEAD/index. + patterns = "".join(f"/{path.as_posix()}\n" for path in paths) + subprocess.run([*git, "sparse-checkout", "set", "--no-cone", "--stdin"], + cwd=snapshot, env=env, input=patterns.encode("utf-8"), check=True) + subprocess.run([*git, "read-tree", "-mu", "HEAD"], cwd=snapshot, env=env, check=True) + for path, row in zip(paths, sources["files"], strict=True): + require(hashlib.sha256((snapshot / path).read_bytes()).hexdigest() == row["sha256"], + "historical checkout source digest changed: " + path.as_posix()) + + def entries(checker): for name, config in checker.CONFIG.items(): for entry in [config, *config.get("additional_inputs", [])]: yield name, entry -def reject(checker, entry): +def reject(root, checker, entry): try: - checker.authenticated_input(ROOT, entry) + checker.authenticated_input(root, entry) except ValueError as exc: return str(exc) raise SystemExit("historical input was admitted: " + entry["path"]) -def main(): - require(not sys.flags.optimize, "assertions must stay enabled") - checker = load_checker() +def check_snapshot(root, env): + checker = load_module(root / "scripts/replay_historical_check.py") selected = [entry for name, entry in entries(checker) if name == "tooling-ledger" and entry["path"] == SELECTED_PATH] require(len(selected) == 1, "selected-result checker overlay is not unique") @@ -94,7 +112,7 @@ def main(): require(entry["accepted_live_sha256"] == [SELECTED_ACCEPTED], "accepted selected-checker successors changed") frozen = (checker.INPUTS / entry["input"]).read_bytes() - live = (ROOT / SELECTED_PATH).read_bytes() + live = (root / SELECTED_PATH).read_bytes() require(hashlib.sha256(frozen).hexdigest() == SELECTED_PIN, "frozen selected checker bytes changed") require(hashlib.sha256(live).hexdigest() == SELECTED_LIVE, "live selected checker digest changed") require(SELECTED_LIVE not in (SELECTED_PIN, SELECTED_ACCEPTED), "live checker was already admitted") @@ -102,7 +120,7 @@ def main(): # live successor, not a broken comparison. require(SELECTED_PIN in (SELECTED_PIN, *entry["accepted_live_sha256"]), "pin membership control failed") - require(reject(checker, entry) == REJECTIONS[SELECTED_PATH][1], + require(reject(root, checker, entry) == REJECTIONS[SELECTED_PATH][1], "selected checker rejection text changed") counts = {path: 0 for path in REJECTIONS} @@ -110,7 +128,7 @@ def main(): for _name, item in entries(checker): if item["path"] not in REJECTIONS: continue - message = reject(checker, item) + message = reject(root, checker, item) counts[item["path"]] += 1 messages.setdefault(item["path"], message) for path, (count, message) in REJECTIONS.items(): @@ -118,20 +136,31 @@ def main(): require(messages[path] == message, "rejection text changed for " + path) require(sum(counts.values()) == 19, "rejection total changed") ci = [item for _name, item in entries(checker) if item["path"] == CI_PATH] - require(len(ci) == 1 and hashlib.sha256((ROOT / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, + require(len(ci) == 1 and hashlib.sha256((root / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, "selected CI note digest changed") diff = subprocess.check_output( - ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=ROOT, text=True) + ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=root, env=env, text=True) changed = sorted(name for name in diff.splitlines() if name) require(changed == CHANGED, "inspected commit diff changed") - sys.path.insert(0, str(ROOT / "scripts")) - from research_package import plan_details - details = plan_details(ROOT, set(changed)) + planner = load_module(root / "scripts/research_package.py") + details = planner.plan_details(root, set(changed)) require([row["package"] for row in details] == PLAN_PACKAGES, "helper plan selection changed") matched = {name for row in details for names in row["causes"].values() for name in names} require(sorted(set(changed) - matched) == UNMATCHED, "unmatched plan paths changed") - require(plan_details(ROOT, set()) == [], "empty change set selected a package") + require(planner.plan_details(root, set()) == [], "empty change set selected a package") + + +def main(): + require(not sys.flags.optimize, "assertions must stay enabled") + sources = json.loads(Path(__file__).with_name("SOURCES.json").read_bytes()) + require(sources["base_commit"] == INSPECTED, "historical checkout base changed") + runner = load_module(ROOT / "scripts/research_package.py") + env = runner.git_source_env() + with tempfile.TemporaryDirectory(prefix="historical-selected-replay-") as temporary: + snapshot = Path(temporary) / "snapshot" + checkout_snapshot(snapshot, sources, runner, env) + check_snapshot(snapshot, env) print("PASS_HISTORICAL_SELECTED_REPLAY_GAP") print("selected_checker_live=" + SELECTED_LIVE) print("rejections=19 distinct_paths=7 plan_packages=9")