From d20c1b062da1b4eae37db73098eab97f9a3e38c0 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Fri, 13 Nov 2026 22:45:06 +0000 Subject: [PATCH 1/2] feat(research): restore a dirty spare for principal fanout --- .../principal-demand-dirty-spare/PROOF.md | 195 +++++++++++++ .../principal-demand-dirty-spare/README.md | 164 +++++++++++ .../principal-demand-dirty-spare/SOURCES.json | 36 +++ .../principal-demand-dirty-spare/TASK.json | 84 ++++++ .../principal-demand-dirty-spare/VERIFY.json | 34 +++ .../principal-demand-dirty-spare/verify.py | 262 ++++++++++++++++++ 6 files changed, 775 insertions(+) create mode 100644 research/principal-demand-dirty-spare/PROOF.md create mode 100644 research/principal-demand-dirty-spare/README.md create mode 100644 research/principal-demand-dirty-spare/SOURCES.json create mode 100644 research/principal-demand-dirty-spare/TASK.json create mode 100644 research/principal-demand-dirty-spare/VERIFY.json create mode 100644 research/principal-demand-dirty-spare/verify.py diff --git a/research/principal-demand-dirty-spare/PROOF.md b/research/principal-demand-dirty-spare/PROOF.md new file mode 100644 index 0000000000..5b79143499 --- /dev/null +++ b/research/principal-demand-dirty-spare/PROOF.md @@ -0,0 +1,195 @@ +# A restored spare removes the principal-demand orbit obstruction + +This contribution was produced by Nick Petalas. Apache-2.0. + +## Contract + +Let R be any associative ring with identity, 1 != 0. It need not be finite, +commutative, a domain or a field. Three rows A0,A1,H and a disjoint source p +start with independent arbitrary values a0,a1,h,p in R^w, w >= 1. Every +coefficient acts by left multiplication. The required endpoint is + +```text +(A0,A1,H,p) = (a0+x p, a1+y p, h, p). +``` + +A fixed, input-independent finite word may use only source insertions +P_i(beta): row i += beta p and row additions E_ij(c): row i += c row j, +i != j, with rows numbered 0,1,2 and H numbered 2. Every original dirt +column must return exactly. There is no clearing, observation, free basis +map, extra row, or input-dependent control. We count nonzero source +insertions. Row additions, coefficient preparation and physical use are +separate costs. The optional tariff below charges every gate in the word. + +## Theorem + +Put L=Rx+Ry, a left ideal. The minimum number of nonzero source insertions is + +```text +0 if x=y=0; +1 if L is nonzero and principal; +2 if L is not principal. +``` + +The new assertion is sufficiency of principality over arbitrary rings after +adding one restored dirty spare. A one-insertion word uses at most eight +row additions, with its insertion at the spare. This bound need not be a +shortest word. Necessity and the two-insertion echo are credited to Ali +Romman #5310 and the retained ring-valued fanout lineage. Their finite-ring +sufficiency theorem does not assert this arbitrary-ring stabilization. + +### Necessity + +No insertion leaves the source column zero. If a word has exactly one +nonzero insertion beta at row i, let C be the invertible matrix product of +all later row additions. The final source column is + +```text +lambda=(x,y,0)^T = C e_i beta. +``` + +Every coordinate is a left multiple of beta, so L is contained in R beta. +Applying C^-1 expresses beta as a left linear combination of x,y,0 and +gives the opposite containment. Thus L=R beta is principal. This proof +works with any finite number of restored dirty spectators, and it does +not use commutativity, finiteness, or a division operation. Invertibility +also shows that nonzero beta cannot produce zero demand. + +### The eight-ADD construction + +Suppose L=R beta is nonzero. Since x,y belong to R beta and beta belongs +to Rx+Ry, choose a,b,s,t in R satisfying + +```text +x=a beta, y=b beta, beta=s x+t y. +``` + +These are witnesses, not free divisions. The theorem is existential when +only the ideal's principality is known. An implementation must supply the +witnesses and pay for their preparation. Define the four-ADD word R in +chronological order by + +```text +E_20(s), E_21(t), E_02(-a), E_12(-b). +``` + +On the desired source column it performs + +```text +(x,y,0) -> (x,y,sx) -> (x,y,beta) + -> (0,y,beta) -> (0,0,beta). +``` + +Execute R, then P_2(beta), then the literal inverse of R: + +| Step | Gate | +|---:|---| +| 1 | H += s A0 | +| 2 | H += t A1 | +| 3 | A0 -= a H | +| 4 | A1 -= b H | +| 5 | H += beta p | +| 6 | A1 += b H | +| 7 | A0 += a H | +| 8 | H -= t A1 | +| 9 | H -= s A0 | + +On every original dirt column, steps 1-4 and 6-9 cancel exactly. The source +column after step 5 evolves under steps 6-9 as + +```text +(0,0,beta) -> (0,b beta,beta) + -> (a beta,b beta,beta) + -> (a beta,b beta,beta-t b beta) + -> (a beta,b beta,beta-t b beta-s a beta) + = (x,y,0). +``` + +The additive group of a ring is commutative; no multiplicative coefficients +were commuted. In particular the order is s a and t b, not a s or b t. +This proves the endpoint for arbitrary dirt and every data width. Zero +coefficient gates may be deleted. The inverse reverses all nine gates and +negates their coefficients, and must be charged if used. + +A useful stronger identity holds without any witness relation: the same +word has identity dirt block and source column + +```text +(a beta, b beta, (1-s a-t b) beta)^T. +``` + +The verifier checks this full identity over the free associative integer +polynomial ring. It is a finite coefficient certificate, independently of +all finite-ring substitutions. + +### At most two insertions + +For any x,y, even without a spare, the chronological word + +```text +A1 -= y A0; A0 += p; A1 += y A0; A0 += (x-1) p +``` + +restores all dirt and produces increments (x p,y p). Delete zero calls. +If L is nonprincipal, x cannot equal 1, so both source coefficients are +nonzero. The necessity argument makes two insertions minimal. Zero demand +has the empty word. These observations complete the classification. + +## Polynomial first example and complete declared gate price + +For R=K[u,v] over any field K, take + +```text +x=1+uv, y=u^2, beta=1, +a=1+uv, b=u^2, s=1-uv, t=v^2. +``` + +The witness identity is (1-uv)(1+uv)+v^2 u^2=1. Every coefficient of the +eight row additions is a nonzero polynomial over every field, including +characteristic two. The word therefore uses exactly eight nonzero row +additions and one nonzero source insertion, restores the arbitrary third +row, and realizes precisely the demand in Nick Petalas #5211. + +That predecessor proves that the same demand with exactly two mutable +rows has no one-insertion word, using Cohn's cited classical theorem. +We use that obstruction as a cited premise and do not replay or reprove it. +The new constructive upper bound is independent of Cohn's theorem. + +Let each row addition into row i cost c_i>0, independently of coefficient +and source row, and let insertion at the spare cost mu_2>0. The exact price +of the displayed polynomial word is + +```text +mu_2 + 2 c_0 + 2 c_1 + 4 c_2. +``` + +This charges all preparation, dirty restoration and the insertion in this +abstract alphabet. At mu_0=100, mu_1=1000, mu_2=100 and c_0=c_1=c_2=1, +the displayed word costs 108. The predecessor's exact two-row tariff at +the matching two-row prices is 202. This is a comparison of two explicitly +different workspace contracts, not a new three-row optimum or a physical +cost claim. Inverse execution would cost another 108 under these stationary +prices. Coefficient preparation, storage, movement and actual native gates +are outside the declared abstract tariff and are not assigned zero cost. + +## Relation to stabilized dual exchange + +Nick Petalas #6280 gives a dyadic exchange for a genuine dual pair ab=1, +with three block shears and one sign SCALE. Its classical stabilized +completion mechanism is related precedent. The present word uses only +elementary row additions and requires merely (1-sa-tb) beta=0. The element +beta may be a zero divisor and sa+tb need not equal 1. Thus no dual pair or +unit beta is assumed. For example, in Z/4, beta=2, a=b=s=1, t=2 satisfies +the witness while sa+tb=3. The claim here is the exact ring-valued fanout +criterion, explicit eight-ADD word and Cohn application, not historical +priority for stabilization or elementary matrix algebra. + +## Limits + +The finite certificate establishes the stated polynomial identity. The +all-ring classification rests on the written algebraic proof. No shortest +ADD count, all-positive-price three-row tariff, native coefficient +implementation, physical spare lifetime, precision/tape cost, recursive +supplier admission, new kappa, or complete multiplication theorem follows. +All five selected framework assumptions remain. Independent human and +formal proof-kernel review are unclaimed. diff --git a/research/principal-demand-dirty-spare/README.md b/research/principal-demand-dirty-spare/README.md new file mode 100644 index 0000000000..4b4282c0d1 --- /dev/null +++ b/research/principal-demand-dirty-spare/README.md @@ -0,0 +1,164 @@ +# A restored dirty spare reaches every principal two-row demand + +This contribution was produced by Nick Petalas. Apache-2.0. + +Claim type: scoped algebraic proof with an exact free-associative polynomial +certificate and finite corroboration. Over every associative unital ring R, +for two demanded rows and one arbitrary dirty spare restored to its original +value, the minimum source-insertion count is + +```text +0 for zero demand; +1 for a nonzero principal left demand ideal; +2 for a nonprincipal left demand ideal. +``` + +The new step is arbitrary-ring sufficiency with the restored spare, using +one source insertion and at most eight elementary row additions. Finiteness, +commutativity, invertible demand coefficients and a clean spare are unnecessary. +[PROOF.md](PROOF.md) gives the ordered-ring construction and all-input proof. +The bound of eight ADDs is constructive, not an ADD optimum or exact tariff. + +This answers the feasibility part of Open next question in Nick Petalas's +[PR #5211](https://github.com/CrocSwap/integer-mult-bounds/pull/5211). For its +polynomial demand `(1+uv,u²)` over every field K, one restored dirty spare +removes the two-row one-insertion obstruction. The literal new word has +exactly eight nonzero ADDs and one insertion. Its complete declared abstract +gate price is `mu_2+2c_0+2c_1+4c_2`, with c_i charging each ADD into row i +and mu_2 charging the insertion at the spare. At prices mu_0=100, mu_1=1000, +mu_2=100 and all c_i=1, the word costs 108. The cited two-row optimum is +202 at the matching original prices. The workspace contracts differ; no +three-row optimum or physical saving is inferred. + +## Construction and evidence + +Given witnesses `x=a beta`, `y=b beta`, `beta=s x+t y`, execute the following +nine gates on arbitrary incoming A0,A1,H,p: + +```text +H += s A0; H += t A1; A0 -= a H; A1 -= b H; +H += beta p; +A1 += b H; A0 += a H; H -= t A1; H -= s A0. +``` + +The endpoint is `(A0+x p,A1+y p,H,p)`. The first and last four gates cancel +on every original dirt column. Without any witness relation, the residual +increment at H is exactly `(1-sa-tb) beta p`. Thus witnesses need only satisfy +an annihilator relation, not `sa+tb=1`. Coefficient preparation and physical +access remain separately paid obligations. + +The standard-library verifier imports no predecessor scientific code. It +checks the full four-by-four affine map over the free associative integer +polynomial ring, including the precise product orders, and the literal +inverse. A separate commutative integer polynomial specialization checks +the Cohn word, its inverse, all nine individual gate deletions, every +nonzero coefficient and destination counts `(2,2,4)`. + +Exact finite substitutions cover every five-tuple `(beta,a,b,s,t)` over Z/4 +and UT2(F2): 1,024 and 32,768 tuples, respectively. Every full affine map and +inverse agrees with the unconstrained residual identity. Among these are +192 and 6,720 nonzero valid witnesses; 48 and 4,704 of those have the chosen +`sa+tb != 1`. A further 3,420 selected witnesses in M2(F2), including 2,160 +with the chosen `sa+tb != 1`, check genuinely noncommutative substitutions. +These finite tests check the new word, not predecessor source-count theorems. +Eight invalid-domain controls and explicit wrong-order/nonzero-residual +discriminators also pass. Three disposable optimized-script mutations are +rejected at the free-associative endpoint check: lost restoration, wrong +preparation sign and reversed multiplication. The universal criterion is +the written proof. + +## Reproduce + +From the repository root, with standard-library CPython 3.12: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/principal-demand-dirty-spare/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/principal-demand-dirty-spare/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/principal-demand-dirty-spare +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/principal-demand-dirty-spare --check-source-history +``` + +Substitute another CPython 3.12 path on other hosts. Both registered commands +emit `PASS_PRINCIPAL_DEMAND_DIRTY_SPARE` in a generated JSON receipt binding +all six package files by SHA256. Replay writes nothing. The receipt is +generated by execution, not handwritten. SOURCES.json pins predecessor text +as historical provenance; no external live scientific inputs are required. + +## Scope, credit and overlap + +Base is canonical main `e54523517d0f03e58352e647c403a5af3e525a57`, priority +revision 8, selected #7000 with conditional kappa 0.00363005817 unchanged. +The selected source-binding positive control passed. The priority catalogue +still describes #5599; its numerical headline is historical. TASK.json +explicitly changes the bit-helper-contract card to this algebraic interface +question. No G20 supplier or selected framework assumption is discharged. +The [advance CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19601509) +records the question and proposed ten-ADD bound before the new checks. The +first verified word uses eight ADDs and is packaged without seeking an optimum. + +Credit Nick Petalas #5211 for the explicit restored-spare question and the +cited two-row polynomial obstruction; lee-phys #5139/#5089 for the principal +ideal interface; Ali Romman #5310 for the finite associative-ring criterion, +all-ring necessity and two-insertion echo; Krzysztof Wójt #5045 for the +source-count/return classification; and Nick Petalas #4916 for the ring-valued +contract. Ross Richardson, Cinna Davis, Anthony, Oscar Fennell, Tekalign and +the retained fanout lineage keep their credit. Nick Petalas #6280 is related +dyadic dual-exchange precedent. The new annihilator-witness word uses no +SCALE and need not have a genuine dual pair. Elementary stabilization and +row algebra are classical; no literature-wide priority is claimed. + +Live open/account PR lists, recent handoffs, active Discussions, local +reservations, all-main README searches for the object and its general-ring +form, and merged/all-state PR searches were checked before the claim. +The batch reservation records the source and main predecessor author. +The cached card search covers 846 open PRs and 7,480 Discussion records, +with complete reported remote pagination at 22:38 and 22:39 UTC on November +13, 2026. Its later local scan covers 222 of 10,178 tracked notes. Sparse local +notes, unpublished work and arbitrary historical diffs are not exhaustively +covered. These searches are overlap checks, not a novelty certificate. + +## Limits and verifier constraints + +Only the abstract ring gate contract and source-insertion count are settled. +A shortest ADD word and exact three-row directional tariff remain open. +Native coefficient realization, a physical restored spare, source access, +precision/tapes, movement, stock, compiler closure and a complete supplier +invoice are not supplied. Unknown physical costs are not zero. No new kappa, +selected-frontier update or complete multiplication theorem is claimed. +Independent human and formal proof-kernel review are unclaimed. No predecessor +scientific replay, selected cold replay, Lean or Docker build was run. + +Build the Lever led to the retained deterministic full-state checker. Prove +It Works led to every independent dirty column, exact noncommutative product +orders, literal inverses and gate-deletion controls. Power of Ten inspection +covers this verifier. Its functions remain below 60 physical lines, matrices +are four by four, words have at most eighteen gates, ring tables have at most +sixteen elements, and the exhaustive tuple domain has at most 32,768 members. +Polynomial capacity is 128 terms and degree twelve, with at most 16,384 term +pairs per product. Six source reads are capped at 256 KiB plus one guard byte. +There is no recursion, subprocess, network, dynamic code generation or write +path. Explicit exception checks remain active under -O. Warning-strict normal +and optimized replay supply interpreter diagnostics; no shared build settings +change. + +Power of Ten rule 3 deviation: Python and its standard library allocate managed +objects during this fixed offline run. The capacities above bound live data; +allocator internals are not instrumented. A larger domain or embedded service +must add a separately verified allocation policy. Rule 9 deviation: word +inversion receives only the locally defined polynomial negation function or +a fixed finite-table lookup. These two targets are immediate and retain no +mutable state; both are exercised by the normal and optimized replay. No +open-ended dispatch is accepted. + +## Open next questions + +- Find the exact directional tariff for the polynomial demand with one + restored dirty spare. Start from the displayed `(2,2,4)` ADD vector and + retain all three dirt columns while classifying arbitrary words. The + missing step is a three-row lower bound, not another check of this word. +- Bind one actual helper boundary to the ring action and a physically + available restored spare. First price coefficient preparation, source + access, lifetimes, routing and the complete consumer. No such physical + binding or favorable recursive invoice is supplied. + +Structured relevance, first steps and blockers are in TASK.json. diff --git a/research/principal-demand-dirty-spare/SOURCES.json b/research/principal-demand-dirty-spare/SOURCES.json new file mode 100644 index 0000000000..6ff426199c --- /dev/null +++ b/research/principal-demand-dirty-spare/SOURCES.json @@ -0,0 +1,36 @@ +{ + "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/cohn-fanout-obstruction/README.md", + "usage": "provenance", + "git_blob": "831e465aa74eb0b8265fdc9f7ee6b692a895e9b3", + "sha256": "a3ffdc41437ba17031276b215fd4a55173817af41b1ddfd426c3ce0127076f07" + }, + { + "path": "research/division-free-dual-exchange/README.md", + "usage": "provenance", + "git_blob": "5cf1073edeca87d6a28f0e1b29101d3a3aeafbbd", + "sha256": "c7f6c03990f858c85fd199babdc927f79af25de4421681d9a488c9f8d231ce09" + }, + { + "path": "research/finite-ring-source-insertions/README.md", + "usage": "provenance", + "git_blob": "74b9c1a2c17c1330ade8b6f24af225d8aa74f17e", + "sha256": "4e44aabcfb788f16732ecadfe3b85dfa516fdc12909712fd5edb60ea8c6c89b6" + } + ] +} diff --git a/research/principal-demand-dirty-spare/TASK.json b/research/principal-demand-dirty-spare/TASK.json new file mode 100644 index 0000000000..df00c9944b --- /dev/null +++ b/research/principal-demand-dirty-spare/TASK.json @@ -0,0 +1,84 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-helper-contract", + "question": "Can a changed G20 helper path or independent-target split improve the complete BIT moment without losing its physical endpoint?", + "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", + "research/g20-helper-split/README.md", + "research/g20-conjugation-admission/README.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": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. 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": "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": "First read #5679/#5708 and their audits as pending component proposals. Choose one uncovered helper group/cut on an exact word; compare arbitrary-input native action, targets, owned storage, both orientations and full signed bill. Stop if the gain is only a scalar count or repaid by lost targets. Do not rerun the frozen #5609 common-frame domain without changing its hypothesis.", + "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": [ + "G20", + "helper split", + "5679", + "5708", + "independent target" + ], + "existing_checks": [ + { + "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": "Classify single-source-insertion feasibility for two demanded rows with one restored arbitrary dirty spare over every associative unital ring. Construct an eight-ADD word from a principal-left-ideal witness; specialize it to the polynomial Cohn demand.", + "scope_change_reason": "Follow Open next question of PR5211. This is an algebraic stabilization result, not a changed G20 supplier, physical caller or improvement in kappa.", + "bottleneck_link": "An explicitly paid restored spare removes an elementary-orbit obstruction to single source insertion. Native coefficient production, spare availability, precision, routing, compiler closure and the complete recursive invoice remain separate.", + "budget_minutes": 60, + "stop_rule": "Stop at the first verified restoring construction and insertion-count criterion. Do not seek a shortest ADD word or expand into a supplier.", + "outcome": "completed", + "evidence": "PROOF.md gives the all-ring criterion and full eight-ADD construction. verify.py checks the free associative polynomial identity, the literal Cohn word and exact finite ring substitutions.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "What is the least complete directional tariff for the Cohn demand with this restored dirty spare?", + "why_it_matters": "The eight-ADD word is an upper bound; additional legal interleavings may lower the bill.", + "first_step": "Keep all three dirt columns and compare count vectors under positive destination prices, starting with the eight-ADD word.", + "blocked_by": "No arbitrary-word three-row tariff lower bound is supplied." + }, + { + "question": "Can a current physical helper boundary supply this ring action and restored spare at a favorable complete price?", + "why_it_matters": "The algebraic source-count improvement alone does not improve a recursive supplier.", + "first_step": "Name one coefficient representation, source access contract and spare lifetime, then charge the full consumer.", + "blocked_by": "Native coefficient operations, routing, precision and complete caller costs are unspecified." + } + ], + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19601509" +} diff --git a/research/principal-demand-dirty-spare/VERIFY.json b/research/principal-demand-dirty-spare/VERIFY.json new file mode 100644 index 0000000000..2655ee83c1 --- /dev/null +++ b/research/principal-demand-dirty-spare/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": "Free associative full-state identity, polynomial Cohn specialization, finite noncommutative substitutions, witness and restoration controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Repeat every scientific and failure control with Python assertions disabled." + } + ] +} diff --git a/research/principal-demand-dirty-spare/verify.py b/research/principal-demand-dirty-spare/verify.py new file mode 100644 index 0000000000..35e8b196c9 --- /dev/null +++ b/research/principal-demand-dirty-spare/verify.py @@ -0,0 +1,262 @@ +#!/usr/bin/env python3 +"""Exact full-state certificates for the restored-spare fanout word.""" +import hashlib +import itertools +import json +from pathlib import Path +import sys + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def poly(terms): + require(len(terms) <= 128, 'polynomial term capacity') + require(all(len(w) <= 12 for w in terms), 'polynomial degree capacity') + return tuple(sorted((w, c) for w, c in terms.items() if c)) + + +def add(p, q): + out = dict(p) + for w, c in q: + out[w] = out.get(w, 0) + c + return poly(out) + + +def neg(p): + return tuple((w, -c) for w, c in p) + + +def mul(p, q, commutative): + require(len(p) * len(q) <= 16384, 'polynomial product capacity') + out = {} + for u, c in p: + for v, d in q: + w = ''.join(sorted(u + v)) if commutative else u + v + out[w] = out.get(w, 0) + c * d + return poly(out) + + +def word(a, b, s, t, beta, negative): + prefix = ((2, 0, s), (2, 1, t), (0, 2, negative(a)), + (1, 2, negative(b))) + suffix = tuple((i, j, negative(c)) for i, j, c in reversed(prefix)) + return prefix + ((2, 3, beta),) + suffix + + +def inverse(gates, negative): + return tuple((i, j, negative(c)) for i, j, c in reversed(gates)) + + +def execute_poly(gates, commutative): + require(len(gates) <= 18, 'word capacity') + one = poly({'': 1}) + rows = [[one if i == j else () for j in range(4)] for i in range(4)] + for i, j, c in gates: + require(0 <= i < 3 and 0 <= j < 4 and i != j, 'gate indices') + rows[i] = [add(x, mul(c, y, commutative)) + for x, y in zip(rows[i], rows[j], strict=True)] + return rows + + +def expected_poly(x, y, residual): + one = poly({'': 1}) + out = [[one if i == j else () for j in range(4)] for i in range(4)] + out[0][3], out[1][3], out[2][3] = x, y, residual + return out + + +def symbolic_checks(): + a, b, s, t, z = (poly({c: 1}) for c in 'abstz') + gates = word(a, b, s, t, z, neg) + x, y = poly({'az': 1}), poly({'bz': 1}) + residual = poly({'z': 1, 'saz': -1, 'tbz': -1}) + require(execute_poly(gates, False) == expected_poly(x, y, residual), + 'free associative full-state identity') + require(execute_poly(gates + inverse(gates, neg), False) + == expected_poly((), (), ()), 'formal inverse endpoint') + wrong = add(z, neg(add(mul(x, s, False), mul(y, t, False)))) + require(wrong != residual, 'ordered products discriminator') + return {'free_associative_identities': 2, 'order_discriminators': 1} + + +def cohn_checks(): + one, u, v = (poly({w: 1}) for w in ('', 'u', 'v')) + uv = mul(u, v, True) + a, b = add(one, uv), mul(u, u, True) + s, t = add(one, neg(uv)), mul(v, v, True) + gates = word(a, b, s, t, one, neg) + endpoint = expected_poly(a, b, ()) + require(add(mul(s, a, True), mul(t, b, True)) == one, + 'Cohn witness identity') + require(execute_poly(gates, True) == endpoint, 'Cohn full dirty endpoint') + require(execute_poly(inverse(gates, neg), True) + == expected_poly(neg(a), neg(b), ()), 'Cohn literal inverse') + require(all(c for _, _, c in gates), 'nonzero polynomial gate census') + counts = tuple(sum(i == k and j != 3 for i, j, _ in gates) + for k in range(3)) + require(counts == (2, 2, 4), 'complete destination counts') + for cut in range(9): + shortened = gates[:cut] + gates[cut + 1:] + require(execute_poly(shortened, True) != endpoint, 'omitted gate') + require(100 + sum(counts) == 108, 'declared complete word price') + return {'cohn_words': 2, 'cohn_gate_deletions': 9, + 'cohn_row_adds': sum(counts), 'cohn_source_insertions': 1, + 'cohn_destination_counts': counts, 'cohn_declared_word_price': 108} + + +def table_product(kind, x, y): + if kind == 'Z4': + return x * y % 4 + if kind == 'UT2F2': + a, b, c = ((x >> i) & 1 for i in range(3)) + d, e, f = ((y >> i) & 1 for i in range(3)) + return (a * d) | ((a * e ^ b * f) << 1) | ((c * f) << 2) + require(kind == 'M2F2', 'unknown finite ring') + a, b, c, d = ((x >> i) & 1 for i in range(4)) + e, f, g, h = ((y >> i) & 1 for i in range(4)) + return ((a * e ^ b * g) | ((a * f ^ b * h) << 1) + | ((c * e ^ d * g) << 2) | ((c * f ^ d * h) << 3)) + + +def tables(kind): + require(kind in ('Z4', 'UT2F2', 'M2F2'), 'unknown finite ring') + size, one = {'Z4': (4, 1), 'UT2F2': (8, 5), 'M2F2': (16, 9)}[kind] + plus = tuple(tuple((x + y) % 4 if kind == 'Z4' else x ^ y + for y in range(size)) for x in range(size)) + times = tuple(tuple(table_product(kind, x, y) for y in range(size)) + for x in range(size)) + minus = tuple(next(y for y in range(size) if plus[x][y] == 0) + for x in range(size)) + for a, b, c in itertools.product(range(size), repeat=3): + require(times[times[a][b]][c] == times[a][times[b][c]], 'associativity') + require(times[a][plus[b][c]] == plus[times[a][b]][times[a][c]], + 'left distributivity') + require(times[plus[a][b]][c] == plus[times[a][c]][times[b][c]], + 'right distributivity') + for a in range(size): + require(times[one][a] == a == times[a][one], 'ring identity') + return plus, times, minus, one + + +def execute_finite(gates, ring): + plus, times, _, one = ring + size = len(plus) + require(len(gates) <= 18, 'word capacity') + rows = [[one if i == j else 0 for j in range(4)] for i in range(4)] + for i, j, c in gates: + require(0 <= i < 3 and 0 <= j < 4 and i != j, 'gate indices') + require(0 <= c < size, 'finite coefficient domain') + rows[i] = [plus[x][times[c][y]] + for x, y in zip(rows[i], rows[j], strict=True)] + return rows + + +def check_tuple(values, ring): + beta, a, b, s, t = values + plus, times, minus, one = ring + x, y = times[a][beta], times[b][beta] + residual = plus[beta][minus[plus[times[s][x]][times[t][y]]]] + gates = word(a, b, s, t, beta, minus.__getitem__) + expected = [[one if i == j else 0 for j in range(4)] for i in range(4)] + expected[0][3], expected[1][3], expected[2][3] = x, y, residual + require(execute_finite(gates, ring) == expected, 'finite full-state identity') + backwards = inverse(gates, minus.__getitem__) + for i in range(3): + expected[i][3] = minus[expected[i][3]] + require(execute_finite(backwards, ring) == expected, 'finite inverse identity') + witness = residual == 0 and beta != 0 + nondual = witness and plus[times[s][a]][times[t][b]] != one + return witness, nondual + + +def exhaustive_substitutions(kind): + ring = tables(kind) + size = len(ring[0]) + count = witnesses = nondual = 0 + for values in itertools.product(range(size), repeat=5): + good, weak = check_tuple(values, ring) + count += 1 + witnesses += good + nondual += weak + require(count == size**5 and witnesses > 0, 'complete tuple domain') + require(nondual > 0, 'annihilator-only witness domain') + return {'ring': kind, 'tuples': count, 'nonzero_witnesses': witnesses, + 'witnesses_with_sa_plus_tb_not_one': nondual} + + +def matrix_witnesses(): + ring = tables('M2F2') + plus, times, _, _ = ring + count = nondual = 0 + for beta, a, b in itertools.product(range(16), repeat=3): + if beta == 0: + continue + x, y = times[a][beta], times[b][beta] + candidates = ((s, t) for s, t in itertools.product(range(16), repeat=2) + if plus[times[s][x]][times[t][y]] == beta) + found = next(candidates, None) + if found is not None: + good, weak = check_tuple((beta, a, b, *found), ring) + require(good, 'selected noncommutative witness') + count += 1 + nondual += weak + require(count > 0 and nondual > 0, 'matrix witness coverage') + return {'ring': 'M2F2', 'selected_witnesses': count, + 'selected_witnesses_with_sa_plus_tb_not_one': nondual} + + +def controls(): + ring = tables('UT2F2') + _, times, minus, one = ring + require(times[1][2] == 2 and times[2][1] == 0, + 'literal E00 E01 differs from E01 E00') + # This tuple does not satisfy the witness relation: spare must retain p. + gates = word(one, one, 0, 0, one, minus.__getitem__) + require(execute_finite(gates, ring)[2][3] == one, 'invalid witness residual') + rejected = 0 + for gates in (((3, 0, one),), ((0, 0, one),), ((0, 4, one),), + ((0, 1, 8),), ((0, 1, -1),), ((0, 1, one),) * 19): + try: + execute_finite(gates, ring) + except ValueError: + rejected += 1 + require(rejected == 6, 'invalid gate controls') + for terms in ({'x' * 13: 1}, {str(i): 1 for i in range(129)}): + try: + poly(terms) + except ValueError: + rejected += 1 + require(rejected == 8, 'polynomial capacity controls') + return {'invalid_domain_controls': rejected, 'semantic_controls': 2} + + +def receipt(results): + root = Path(__file__).resolve().parent + names = ('README.md', 'PROOF.md', 'TASK.json', 'SOURCES.json', + 'VERIFY.json', 'verify.py') + hashes = {} + for name in names: + with (root / name).open('rb') as stream: + data = stream.read(262145) + require(len(data) <= 262144, 'source file capacity') + hashes[name] = hashlib.sha256(data).hexdigest() + return {'status': 'PASS_PRINCIPAL_DEMAND_DIRTY_SPARE', + 'claim_type': 'scoped written proof and exact polynomial certificate', + 'python': sys.version.split()[0], 'results': results, + 'sha256': hashes, 'no_new_kappa': True} + + +def main(): + require(len(sys.argv) == 1, 'no command-line inputs supported') + results = {'symbolic': symbolic_checks(), 'polynomial': cohn_checks(), + 'complete_substitutions': [exhaustive_substitutions('Z4'), + exhaustive_substitutions('UT2F2')], + 'matrix_substitutions': matrix_witnesses(), 'controls': controls()} + print(json.dumps(receipt(results), indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main() From 4ea3aff1b5201d5c0cbef931d18aa0ffb8fa4db6 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Tue, 17 Nov 2026 22:45:54 +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")