From e7b75e61e129c5142840e7f7a072f185d26337ef Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Wed, 11 Nov 2026 10:06:10 +0000 Subject: [PATCH 1/2] docs(research): bound five-term twist residues sharply --- research/bit-five-term-residue-bound/PROOF.md | 143 ++++++++ .../bit-five-term-residue-bound/README.md | 110 ++++++ .../bit-five-term-residue-bound/SOURCES.json | 30 ++ .../bit-five-term-residue-bound/TASK.json | 79 +++++ .../bit-five-term-residue-bound/VERIFY.json | 35 ++ .../bit-five-term-residue-bound/verify.py | 326 ++++++++++++++++++ 6 files changed, 723 insertions(+) create mode 100644 research/bit-five-term-residue-bound/PROOF.md create mode 100644 research/bit-five-term-residue-bound/README.md create mode 100644 research/bit-five-term-residue-bound/SOURCES.json create mode 100644 research/bit-five-term-residue-bound/TASK.json create mode 100644 research/bit-five-term-residue-bound/VERIFY.json create mode 100644 research/bit-five-term-residue-bound/verify.py diff --git a/research/bit-five-term-residue-bound/PROOF.md b/research/bit-five-term-residue-bound/PROOF.md new file mode 100644 index 0000000000..44a989f6e0 --- /dev/null +++ b/research/bit-five-term-residue-bound/PROOF.md @@ -0,0 +1,143 @@ +# Five terms still have residue rank at most two + +This contribution was produced by Nick Petalas. Apache-2.0. + +## Statement and credited premises + +Let m >= 4, V = M_m(F2), and let U_j(z) = L_j z R_j for +L_j,R_j in GL_m(F2), j = 1,...,5. Suppose a_j in V has matrix rank +at most one and + + sum_j a_j = 0, + sum_j a_j * (U_j z) = 0 in Sym^2(V), for every z in V. (1) + +The multiplication in (1) is ordinary polynomial multiplication of linear +forms. Squares are retained. Define beta = sum_j U_j^-1(a_j). + +**Theorem.** rank(beta) <= 2. For every m >= 4 there is a solution with +five nonzero rank-one a_j and rank(beta) = 2. + +The model and necessary conditions are JoyboyBrian's #5490, Sections 1-3 +of `research/bit-three-term-twist-rigidity/PROOF.md`. We cite its +transport-distance lemma: distinct U and U' have rank(U+U') >= m as +linear maps on V. We also cite Nick Petalas's #5978, Theorem parts 2-3 +in `research/bit-four-term-twist-escape/PROOF.md`: for four contributions +at m >= 3, a nonzero residue requires all four frames equal to x and +sum U_j = 0; its rank is at most 2 rank(x), and rank two is attained by +rank-one x at every m >= 3. These are premises, not new verification +claims. SOURCES.json pins the exact proof bytes on canonical main. + +The new step is the complete reduction from five contributions to that +four-contribution theorem. It answers the m >= 4 rank-one part of +Open next question 2 in #5978. It does not answer its proposed m = 2 census +or the exceptional five-term m = 3 case. + +## Linear-syzygy fact + +Use the same linear-syzygy fact as #5978. If independent linear forms +b_1,...,b_d and linear forms f_1,...,f_d satisfy sum b_i f_i = 0, +then f_i lies in span{b_h : h != i}. To see the needed implication, +extend the b_i to a coordinate basis of the polynomial ring. The +coefficient of b_i^2 makes the b_i coefficient of f_i zero. The +coefficient of b_i c for each complementary coordinate c makes that +coefficient of f_i zero. Terms b_i b_h allow only the other b_h. +This explains why discarding squares would change the argument. + +Consequently, if sum b_i (F_i z) = 0 for all z, then the linear map +F_i has image dimension at most d-1. All ranks in this paragraph are +vector-space ranks on V, rather than the matrix rank of a frame. + +## Reduction by frame-span dimension + +If one a_j is zero, delete that term. At most four terms remain and the +credited four-term theorem applies after adding zero terms if necessary. +Its nonzero-residue case has four equal rank-one frames, so rank(beta) +is at most two. Hence assume all five a_j are nonzero. + +Put d = dim span{a_1,...,a_5}. Their zero sum gives d <= 4. +Dimension one is impossible: over F2 five equal nonzero vectors sum to +that same nonzero vector. The remaining cases are as follows. + +**d = 4.** After reordering, the frames are independent x_1,...,x_4 +and x_1+...+x_4. Substitution into (1) gives + + sum_(i=1)^4 x_i * ((U_i+U_5) z) = 0. + +Each U_i+U_5 has image dimension at most three by the syzygy fact. +Since 3 < m, the credited distance lemma forces U_i = U_5 for every +i. Thus beta = U_5^-1(sum a_j) = 0. + +**d = 3.** The frames, after reordering, are x,y,x+y,z,z with x,y,z +independent. Here is the full multiplicity argument. The set of values +occurring an odd number of times has odd size at most five and sums to +zero. Size one is impossible. Size five is impossible in F2^3: all +seven nonzero vectors sum to zero, so its two-element complement would +also sum to zero, despite having distinct elements. Thus there are +three odd-multiplicity values x,y,x+y. The other two entries are an +equal pair z,z. If z lay in span{x,y}, d would be at most two. + +Equation (1) becomes + + x*((U_1+U_3)z') + y*((U_2+U_3)z') + z*((U_4+U_5)z') = 0 + +for every argument z' in V. Each displayed difference has image +dimension at most two, less than m. Therefore U_1=U_2=U_3 and +U_4=U_5. The triple and the pair cancel separately in beta, giving zero. + +**d = 2.** The three possible nonzero frame values are x,y,x+y. Their +multiplicities all have the same parity because their sum is zero. +Their total is five, so each multiplicity is odd; the only possibility +is 3,1,1. Reorder the frames as x,x,x,y,x+y. Equation (1) reads + + x*((U_1+U_2+U_3+U_5)z) + y*((U_4+U_5)z) = 0. + +The second map has image dimension at most one. Transport distance +forces U_4=U_5. The equation then forces U_1+U_2+U_3+U_5=0, since +multiplication by the nonzero linear form x is injective. Moreover + + beta = (U_1^-1+U_2^-1+U_3^-1+U_5^-1)(x). + +These are exactly four equal-frame contributions satisfying (1). +The cited four-term theorem gives rank(beta) <= 2 rank(x) <= 2. +This proves the bound in all cases. + +## Attainment with five nonzero rank-one frames + +Take a credited four-term rank-two witness at this m, with all four +frames x = u v^T and invertible transports U_1,...,U_4 summing to zero. +Choose w independent of u and replace the first contribution by + + (w v^T, U_1), ((u+w) v^T, U_1). + +Both new frames have rank one, are nonzero, and sum to x. This +replacement preserves each equation in (1) and the residue exactly. +There are now five nonzero frames and residue rank two. No new +four-term construction is claimed. + +For direct finite corroboration, identify F2^m with F_(2^m) and write +M_c for multiplication by c. The checked new five-term witness has + + frames = (e_1 e_0^T, (e_0+e_1)e_0^T, x, x, x), x=e_0 e_0^T, + left multipliers = (1, 1, b, 1+b, 1+b), + right multipliers = (1+b, 1+b, 1+b, 1, b), + U_j(z) = M_left[j] z M_right[j], b = t. + +The finite verifier checks all input basis matrices in (1), inverse +transport, all five frame ranks and the actual rank of beta at +m=4,5,6,7,8. The moduli are t^4+t+1, t^5+t^2+1, t^6+t+1, +t^7+t+1 and t^8+t^4+t^3+t+1. It checks a multiplicative inverse for +every nonzero element of each finite field. These new five-frame checks +do not replay the predecessor's census or its four-frame verifier. + +## Scope and next step + +This is a necessary-condition obstruction in one off-diagonal block. +A five-contribution block with rank-one frames cannot alone supply a +full-rank residue when m >= 4. Other blocks, direct diagonal contributions, +the second-order constant-input cross terms and complete words may alter +a caller's total target. No arbitrary-word lower bound follows. + +The threshold m >= 4 is used at d=4, where the rank-three image bound +need not identify the transports if m=3. This case is left open. Native +twist costs, physical realization, recursive invoices, the five selected +framework assumptions and a complete multiplication theorem are unrun. diff --git a/research/bit-five-term-residue-bound/README.md b/research/bit-five-term-residue-bound/README.md new file mode 100644 index 0000000000..945fe3ee3a --- /dev/null +++ b/research/bit-five-term-residue-bound/README.md @@ -0,0 +1,110 @@ +# Five address-twist contributions still have residue rank at most two + +This contribution was produced by Nick Petalas. Apache-2.0. + +**Claim type: scoped written proof with exact finite corroboration.** For +every m >= 4, five rank-at-most-one frames satisfying the dirty degree-one +conditions of JoyboyBrian's [#5490](https://github.com/CrocSwap/integer-mult-bounds/pull/5490) +have role-s residue of matrix rank at most two. The bound is attained with +five nonzero frames at every such m. + +Let V=M_m(F2), U_j(z)=L_j z R_j with invertible L_j,R_j, and require + +```text +sum a_j = 0, +sum a_j * (U_j z) = 0 in Sym^2(V), for every z, +beta = sum U_j^-1(a_j). +``` + +Polynomial squares are retained. [PROOF.md](PROOF.md) classifies the +five-frame span and multiplicities. At span dimension four or three, +transport rank distance forces residue zero. At dimension two, the frame +multiplicities are 3,1,1 and the problem reduces to the credited four-term +theorem of [#5978](https://github.com/CrocSwap/integer-mult-bounds/pull/5978). +Its rank-two witness becomes a five-frame witness by splitting one frame. + +This answers the m >= 4 rank-one part of that older package's Open next +question 2. It does not settle five contributions at m=2 or m=3, arbitrary +frame ranks, complete words, supplier admission or a new kappa. In this +necessary-condition model, adding a fifth contribution does not raise the +maximum residue rank above two at m >= 4. + +## Evidence and reproduction + +From the repository root, standard-library CPython 3.12: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/bit-five-term-residue-bound/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -O -B research/bit-five-term-residue-bound/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/bit-five-term-residue-bound +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/bit-five-term-residue-bound --check-source-history +``` + +The scientific marker is `PASS_FIVE_TERM_RESIDUE_BOUND`. The verifier +enumerates all five-nonzero-vector multisets spanning F2^d and summing to +zero for d=1,2,3,4. Their counts are 0,3,28,168. It checks the claimed +types and every kernel-basis syzygy for each of the 199 multisets in a +six-dimensional ambient space. This finite calculation corroborates the +written dimension-independent argument; it does not replace that proof. + +It then checks new five-frame rank-two witnesses at m=4,...,8 by direct +polynomial arithmetic on every input basis matrix. Omitted-term, +changed-frame and changed-transport controls must fail at the named +conditions; a square-retention control is also required. No predecessor +executable is imported or replayed. The two cited proof files are +authenticated by their pinned hashes. + +Default replay writes nothing. Its JSON output includes the complete +finite result and SHA256 of all six package files and the two proof inputs. +`--receipt /absolute/path/outside/repository.json` writes the same generated +receipt and refuses to overwrite an existing file. No receipt is hand-written. + +## Limits and credit + +The universal result is a written proof using cited premises. Independent +human and formal proof-kernel review are unclaimed. No rounded native +implementation, complete caller, other off-diagonal blocks, constant-input +second-order cross terms, physical twist costs, recursive moment or selected +supplier replay is supplied. The selected frontier is unchanged. + +JoyboyBrian's #5490 supplies the model, the necessary conditions, transport +rank distance and three-term rigidity. Nick Petalas's older #5978 supplies +the four-term theorem, its field witnesses and the explicit five-term +question. Krzysztof Wójt's #5003 supplies the inherited second-order +quotient and source compatibility, with the Cinna Davis/#2110, Ali Romman, +eumemic and huxint lineage retained by citation. Linear syzygies and finite +fields are standard ingredients. The new contribution is the five-term +reduction, its sharpness by splitting, and the new finite corroboration. + +The scoped side result changes card `bit-new-register-model` from a native +alphabet search to this local obstruction. The card's working source-binding +baseline passed against selected #7000. This is not a new register census +or a completed native alphabet. The CLAIM describes the local refinement; +TASK.json marks the change from the broader catalogue premise explicitly. + +## Open next questions + +1. Can five rank-one frames at m=3 have residue rank three? The span-four + branch is the sole new branch left by this proof. Start with a five-circuit + of rank-one matrices and impose the full quadratic equations on two-sided + transports. A transport pair can differ by rank three there, so the present + distance argument does not settle it. +2. What is the first contribution count admitting full-rank residue for a + named m>=4? Start with six contributions and classify frame multiplicities + before any word synthesis. A local residue still needs every remaining + block, constant-input cross term and physical cost in a complete caller. + +Structured relevance, first steps and blockers are in [TASK.json](TASK.json). + +## Implementation bounds + +The verifier has no recursion, network, subprocesses, dynamic code generation +or predecessor imports. Census loops cover at most C(19,5)=11,628 multisets +per dimension; syzygy systems have 30 variables and 21 equations. Witnesses +have m<=8, at most 64 input basis matrices, five terms and 4,096 polynomial +bit positions. Functions are shorter than 60 physical lines. Explicit +exceptions remain active under optimization. Each registered command has a +120-second timeout. Python exact arithmetic allocates during this bounded +offline computation, a Power of Ten rule 3 deviation. Package and proof +files are individually capped at 256 KiB. Warning-strict normal and +optimized execution provide the interpreted-code diagnostics. diff --git a/research/bit-five-term-residue-bound/SOURCES.json b/research/bit-five-term-residue-bound/SOURCES.json new file mode 100644 index 0000000000..52e970822a --- /dev/null +++ b/research/bit-five-term-residue-bound/SOURCES.json @@ -0,0 +1,30 @@ +{ + "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/bit-four-term-twist-escape/PROOF.md", + "usage": "input", + "git_blob": "7893702732f4903adb21e5ec8696cede0aefb5f5", + "sha256": "93ed15ab008347e9a410d6fc306ba75897cab4b4b4d0b0ba5d3fa1a3d78d122f" + }, + { + "path": "research/bit-three-term-twist-rigidity/PROOF.md", + "usage": "input", + "git_blob": "65120d64fb7e25765734584a7e389e53e83fa142", + "sha256": "6ca59361eefe1fa546d348aefce127b325149323a83d4ab10445ac6f28c6a854" + } + ] +} diff --git a/research/bit-five-term-residue-bound/TASK.json b/research/bit-five-term-residue-bound/TASK.json new file mode 100644 index 0000000000..3c89255be6 --- /dev/null +++ b/research/bit-five-term-residue-bound/TASK.json @@ -0,0 +1,79 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "Sharp rank-two residue bound for five rank-at-most-one contributions satisfying the two-sided address-twist dirty degree-one conditions at every m>=4.", + "scope_change_reason": "Takes the older explicit five-contribution question in PR5978 instead of searching a larger register alphabet. This is a necessary-condition side result, not a completed native construction.", + "bottleneck_link": "A five-contribution off-diagonal block still cannot supply a full-rank residue at m>=4. The obstruction tells a new BIT controller which local extension remains insufficient; it does not bound arbitrary callers.", + "budget_minutes": 60, + "stop_rule": "Ship the first proved five-term extension; do not search the exceptional m=3 case or six-term extensions.", + "outcome": "completed", + "evidence": "PROOF.md reduces every five-term solution to the cited four-term theorem. verify.py enumerates 199 full-span zero-sum nonzero-frame multisets, checks all pointwise kernel-basis syzygies in ambient dimension six, and checks five new five-frame rank-two witnesses at m=4,...,8 with four named controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Can five rank-one contributions at m=3 have residue rank three?", + "why_it_matters": "This is the exceptional span-four branch where rank distance does not force equal transports.", + "first_step": "Choose five rank-one frames forming a four-dimensional circuit and impose the complete quadratic equations on two-sided invertible transports.", + "blocked_by": "The rank-three image bound equals m, so the present distance argument does not settle the transport equations." + }, + { + "question": "What is the first contribution count permitting a full-rank residue for a named m>=4?", + "why_it_matters": "Five contributions cannot improve this local rank-two capacity.", + "first_step": "Classify six-frame multiplicities and their syzygies before attempting a complete word.", + "blocked_by": "Other blocks, constant-input cross terms and physical costs must still be imposed for a useful controller." + } + ], + "coordination": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19539340", + "question_source": "PR #5978, Open next question 2", + "cited_model": "JoyboyBrian PR #5490", + "upstream_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "overlap_checked_utc": "2026-11-11T09:58:56Z", + "coverage": "488 open PRs, 6175 closed PRs in source-reference check, 7148 Discussion records, complete local inventory of 10178 notes at base. Search is provisional and does not cover arbitrary diffs or unpublished work.", + "recent_self_source_matches": 0 + } +} diff --git a/research/bit-five-term-residue-bound/VERIFY.json b/research/bit-five-term-residue-bound/VERIFY.json new file mode 100644 index 0000000000..05cac08305 --- /dev/null +++ b/research/bit-five-term-residue-bound/VERIFY.json @@ -0,0 +1,35 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-four-term-twist-escape/PROOF.md", + "research/bit-three-term-twist-rigidity/PROOF.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "New five-frame multiplicity types and kernel-basis syzygies, direct five-frame witnesses at m=4..8, named rejection controls and source hashes." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "New five-frame multiplicity types and kernel-basis syzygies, direct five-frame witnesses at m=4..8, named rejection controls and source hashes." + } + ] +} diff --git a/research/bit-five-term-residue-bound/verify.py b/research/bit-five-term-residue-bound/verify.py new file mode 100644 index 0000000000..f4e6b3df5a --- /dev/null +++ b/research/bit-five-term-residue-bound/verify.py @@ -0,0 +1,326 @@ +#!/usr/bin/env python3 +"""New five-term reduction checks. Nick Petalas, Apache-2.0.""" + +import argparse +from collections import Counter +import hashlib +from itertools import combinations, combinations_with_replacement +import json +from pathlib import Path + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def xor_all(values): + result = 0 + for value in values: + result ^= value + return result + + +def rank(vectors, dimension): + pivots = [0] * dimension + for original in vectors: + value = original + for bit in range(dimension - 1, -1, -1): + if not (value >> bit) & 1: + continue + if pivots[bit]: + value ^= pivots[bit] + else: + pivots[bit] = value + break + return sum(bool(value) for value in pivots) + + +def kernel(equations, variables): + pivots = [0] * variables + for original in equations: + row = original + for bit in range(variables - 1, -1, -1): + if not (row >> bit) & 1: + continue + if pivots[bit]: + row ^= pivots[bit] + else: + pivots[bit] = row + break + basis = [] + for free in range(variables): + if pivots[free]: + continue + value = 1 << free + for bit in range(variables): + if pivots[bit] and (pivots[bit] & value).bit_count() % 2: + value ^= 1 << bit + need(all((row & value).bit_count() % 2 == 0 for row in equations), + "kernel vector violates its equation") + basis.append(value) + need(len(basis) + rank(equations, variables) == variables, + "kernel dimension violates rank-nullity") + need(rank(basis, variables) == len(basis), "kernel basis is dependent") + return basis + + +def linear_combinations(basis): + return [xor_all(value for bit, value in enumerate(basis) if mask >> bit & 1) + for mask in range(1 << len(basis))] + + +def pattern_basis(frames, dimension): + counts = Counter(frames) + if dimension == 2: + need(sorted(counts.values()) == [1, 1, 3], "wrong dimension-two type") + repeated = next(value for value in counts if counts[value] == 3) + single = next(value for value in counts if counts[value] == 1) + return [repeated, single] + if dimension == 3: + need(sorted(counts.values()) == [1, 1, 1, 2], "wrong dimension-three type") + triple = [value for value in counts if counts[value] == 1] + pair = next(value for value in counts if counts[value] == 2) + need(xor_all(triple) == 0, "dimension-three triple does not sum to zero") + need(rank([*triple, pair], dimension) == 3, "pair is not independent") + return [triple[0], triple[1], pair] + need(dimension == 4 and len(counts) == 5, "wrong dimension-four type") + need(all(rank(subset, 4) == 4 for subset in combinations(frames, 4)), + "dimension-four type is not a five-circuit") + return list(frames[:4]) + + +def syzygy_check(frames, basis): + """Check every pointwise kernel-basis syzygy in ambient dimension six.""" + ambient = 6 + equations = [] + for row in range(ambient): + for column in range(row, ambient): + equation = 0 + for index, frame in enumerate(frames): + if frame >> row & 1: + equation ^= 1 << (index * ambient + column) + if row != column and frame >> column & 1: + equation ^= 1 << (index * ambient + row) + equations.append(equation) + solutions = kernel(equations, 5 * ambient) + combinations_of_basis = linear_combinations(basis) + coordinates = [combinations_of_basis.index(frame) for frame in frames] + allowed = [set(linear_combinations(basis[:i] + basis[i + 1:])) + for i in range(len(basis))] + for solution in solutions: + images = [(solution >> (ambient * j)) & 63 for j in range(5)] + for index in range(len(basis)): + coefficient = xor_all(images[j] for j in range(5) + if coordinates[j] >> index & 1) + need(coefficient in allowed[index], "syzygy image escaped the other forms") + return len(solutions) + + +def multiplicity_census(): + counts = {} + syzygy_dimensions = Counter() + for dimension in range(1, 5): + count = 0 + for frames in combinations_with_replacement(range(1, 1 << dimension), 5): + if xor_all(frames) or rank(frames, dimension) != dimension: + continue + basis = pattern_basis(frames, dimension) + need(rank(basis, dimension) == dimension, "pattern basis lost rank") + syzygy_dimensions[syzygy_check(frames, basis)] += 1 + count += 1 + counts[str(dimension)] = count + need(counts == {"1": 0, "2": 3, "3": 28, "4": 168}, "multiplicity census changed") + return {"full_span_multisets": counts, + "pointwise_syzygy_kernel_dimensions": dict(sorted(syzygy_dimensions.items()))} + + +def field_mul(left, right, modulus, dimension): + result = 0 + for bit in range(dimension): + if right >> bit & 1: + result ^= left + left <<= 1 + if left >> dimension & 1: + left ^= modulus + return result + + +def field_inverse(value, modulus, dimension): + need(0 < value < 1 << dimension, "invalid nonzero field element") + result = 1 + power = value + exponent = (1 << dimension) - 2 + for bit in range(dimension): + if exponent >> bit & 1: + result = field_mul(result, power, modulus, dimension) + power = field_mul(power, power, modulus, dimension) + need(field_mul(value, result, modulus, dimension) == 1, "field inverse failed") + return result + + +def multiplication_matrix(value, modulus, dimension): + result = 0 + for column in range(dimension): + image = field_mul(value, 1 << column, modulus, dimension) + for row in range(dimension): + result |= ((image >> row) & 1) << (row * dimension + column) + return result + + +def matrix_mul(left, right, dimension): + result = 0 + mask = (1 << dimension) - 1 + for row in range(dimension): + value = 0 + for middle in range(dimension): + if left >> (row * dimension + middle) & 1: + value ^= (right >> (middle * dimension)) & mask + result |= value << (row * dimension) + return result + + +def matrix_rank(value, dimension): + mask = (1 << dimension) - 1 + return rank([(value >> (row * dimension)) & mask for row in range(dimension)], + dimension) + + +def symmetric_product(left, right, dimension): + result = 0 + for row in range(dimension): + if not left >> row & 1: + continue + for column in range(dimension): + if right >> column & 1: + low, high = min(row, column), max(row, column) + result ^= 1 << (low * dimension + high) + return result + + +def make_witness(dimension, modulus): + x, y = 1, 1 << dimension + # Split the first x of the credited four-term witness into y and x+y. + return {"dimension": dimension, "modulus": modulus, + "frames": [y, x ^ y, x, x, x], + "left": [1, 1, 2, 3, 3], "right": [3, 3, 3, 1, 2]} + + +def witness_check(data): + m, modulus = data["dimension"], data["modulus"] + need(4 <= m <= 8 and modulus.bit_length() == m + 1, "invalid fixture size") + frames, left, right = data["frames"], data["left"], data["right"] + need(len(frames) == len(left) == len(right) == 5, "wrong contribution arity") + need(all(0 < frame < 1 << (m * m) and matrix_rank(frame, m) == 1 + for frame in frames), "frame is not rank one") + need(xor_all(frames) == 0, "constant condition failed") + matrices = [multiplication_matrix(value, modulus, m) for value in left] + rights = [multiplication_matrix(value, modulus, m) for value in right] + inverses = [multiplication_matrix(field_inverse(value, modulus, m), modulus, m) + for value in left] + inverse_rights = [multiplication_matrix(field_inverse(value, modulus, m), modulus, m) + for value in right] + for column in range(m * m): + total = 0 + for index in range(5): + image = matrix_mul(matrix_mul(matrices[index], 1 << column, m), rights[index], m) + restored = matrix_mul(matrix_mul(inverses[index], image, m), inverse_rights[index], m) + need(restored == 1 << column, "transport inverse failed") + total ^= symmetric_product(frames[index], image, m * m) + need(total == 0, "quadratic condition failed") + beta = xor_all(matrix_mul(matrix_mul(inverses[j], frames[j], m), inverse_rights[j], m) + for j in range(5)) + need(matrix_rank(beta, m) == 2, "residue rank is not two") + need(rank(frames, m * m) == 2, "witness frame span changed") + need(len(set(zip(left, right))) == 4, "witness transport multiplicity changed") + return {"dimension": m, "modulus": modulus, "frames": frames, + "left": left, "right": right, "beta": beta, "beta_rank": 2} + + +def rejection_controls(data): + mutations = [] + missing = {key: list(value) if isinstance(value, list) else value + for key, value in data.items()} + for key in ("frames", "left", "right"): + missing[key].pop() + mutations.append((missing, "arity")) + frame = {**data, "frames": list(data["frames"])} + frame["frames"][0] ^= 1 + mutations.append((frame, "constant")) + transport = {**data, "left": list(data["left"])} + transport["left"][0] = 2 + mutations.append((transport, "quadratic")) + rejected = [] + for mutation, expected in mutations: + try: + witness_check(mutation) + except ValueError as error: + need(expected in str(error), "mutation failed at the wrong condition") + rejected.append(expected) + else: + raise ValueError("mutation was accepted: " + expected) + need(symmetric_product(1, 1, 6) != 0, "polynomial square was discarded") + return rejected + ["retained polynomial square"] + + +def authenticated_sources(package): + root = package.parents[1] + sources = json.loads((package / "SOURCES.json").read_text()) + need(len(sources["files"]) == 4, "source manifest row count changed") + expected = {"research/bit-four-term-twist-escape/PROOF.md", + "research/bit-three-term-twist-rigidity/PROOF.md"} + authenticated = {} + for row in sources["files"]: + if row["usage"] != "input": + continue + need(row["path"] in expected, "unexpected proof path") + source = root / row["path"] + need(source.is_file() and not source.is_symlink(), "source is not regular") + need(source.stat().st_size <= 262144, "source exceeds capacity") + digest = hashlib.sha256(source.read_bytes()).hexdigest() + need(digest == row["sha256"], "source digest differs: " + row["path"]) + authenticated[row["path"]] = digest + need(set(authenticated) == expected, "wrong cited proof inputs") + return authenticated + + +def run(package): + expected = {"README.md", "PROOF.md", "TASK.json", "SOURCES.json", "VERIFY.json", "verify.py"} + files = sorted(path for path in package.iterdir() if path.is_file()) + need({path.name for path in files} == expected, "unexpected package file inventory") + need(all(not path.is_symlink() and path.stat().st_size <= 262144 for path in files), + "package capacity or regular-file condition failed") + sources = authenticated_sources(package) + census = multiplicity_census() + fixtures = [(4, 0x13), (5, 0x25), (6, 0x43), (7, 0x83), (8, 0x11B)] + witnesses = [] + for dimension, modulus in fixtures: + for value in range(1, 1 << dimension): + field_inverse(value, modulus, dimension) + witnesses.append(witness_check(make_witness(dimension, modulus))) + controls = rejection_controls(make_witness(4, 0x13)) + return {"status": "PASS_FIVE_TERM_RESIDUE_BOUND", "claim_type": "scoped written proof", + "census": census, "new_five_frame_witnesses": witnesses, + "controls": controls, "cited_proof_sha256": sources, + "package_sha256": {path.name: hashlib.sha256(path.read_bytes()).hexdigest() + for path in files}} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--receipt", type=Path, help="write a fresh receipt outside the repository") + arguments = parser.parse_args() + package = Path(__file__).resolve().parent + if arguments.receipt is not None: + need(not arguments.receipt.resolve().is_relative_to(package.parents[1]), + "receipt must be outside the repository") + result = run(package) + payload = json.dumps(result, indent=2, sort_keys=True) + "\n" + if arguments.receipt is not None: + with arguments.receipt.open("x") as output: + output.write(payload) + print(payload, end="") + + +if __name__ == "__main__": + main() From 4f7df01fced21e39352678bc4568e516dc65bc2b Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Tue, 17 Nov 2026 22:59:04 +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")