From 8b8134a77db03bd5ce8fb0e7de9cb96f90fad7cc Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Fri, 13 Nov 2026 14:27:52 +0000 Subject: [PATCH 1/2] feat(research): prove minimal affine algebra carrier dimensions --- .../affine-algebra-minimal-carrier/PROOF.md | 190 ++++++++++++++++ .../affine-algebra-minimal-carrier/README.md | 138 ++++++++++++ .../SOURCES.json | 24 ++ .../affine-algebra-minimal-carrier/TASK.json | 81 +++++++ .../VERIFY.json | 34 +++ .../affine-algebra-minimal-carrier/carrier.py | 185 ++++++++++++++++ .../affine-algebra-minimal-carrier/verify.py | 206 ++++++++++++++++++ 7 files changed, 858 insertions(+) create mode 100644 research/affine-algebra-minimal-carrier/PROOF.md create mode 100644 research/affine-algebra-minimal-carrier/README.md create mode 100644 research/affine-algebra-minimal-carrier/SOURCES.json create mode 100644 research/affine-algebra-minimal-carrier/TASK.json create mode 100644 research/affine-algebra-minimal-carrier/VERIFY.json create mode 100644 research/affine-algebra-minimal-carrier/carrier.py create mode 100644 research/affine-algebra-minimal-carrier/verify.py diff --git a/research/affine-algebra-minimal-carrier/PROOF.md b/research/affine-algebra-minimal-carrier/PROOF.md new file mode 100644 index 0000000000..b6c6ce8293 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/PROOF.md @@ -0,0 +1,190 @@ +# A smallest faithful affine group-algebra carrier + +This result was produced by Nick Petalas. New material is Apache-2.0. +Claim type: scoped written proof, with finite exact corroboration. + +## 1. Statement and boundary + +Let F be a finite field of order q and characteristic p, and let H be a +subgroup of F* of order h. Write G = F semidirect H, with elements (a,b), +a in H and b in F, and multiplication + + (a,b)(c,d) = (ac, b+ad). + +Let K be any field of characteristic different from p. Characteristic zero +is allowed; the characteristic may divide h. A carrier means a finite +dimensional unital K-linear representation of the entire algebra K[G]. +Faithful means injective on all formal K-linear combinations, rather than +only injective on the group elements. + +**Theorem.** The smallest dimension of a faithful carrier is exactly + + d_min = q+h-1. + +An explicit attainer is W direct-sum Q. Here W is the sum-zero subspace of +the natural q-dimensional affine permutation module, and Q is the +h-dimensional left regular module of the quotient H. The kernel of the +natural permutation module has dimension exactly h-1. Every formal +coefficient can be recovered from the attainer by the formulas below. + +The regular group carrier has dimension qh, so the reduction is +(q-1)(h-1). For h=1 there is no reduction. No claim is made about the +smallest *permutation* carrier or a physically implementable native address +action. W uses differences of coordinate vectors. Arithmetic, encoding, +source acquisition, restoration, precision, routing and complete supplier +costs are outside this algebraic statement. The selected frontier is unchanged. + +## 2. Explicit coefficient inverse + +Use the natural column convention P_(a,b)e_x = e_(ax+b). For + + u = sum_(a in H,b in F) c_(a,b) [(a,b)], + M = sum c_(a,b) P_(a,b), + s_a = sum_b c_(a,b), C = sum_a s_a, + +every row and column sum of M is C. For fixed a,b define its affine line sum + + L_(a,b) = sum_(x in F) M_(ax+b,x). + +Expanding this sum yields the exact identity + + L_(a,b) = q c_(a,b) + sum_(t != a) s_t. + +Indeed, the t=a contribution repeats c_(a,b) exactly q times. For t!=a, +the index (a-t)x+b visits every element of F exactly once, so that +contribution is s_t. Consequently + + c_(a,b) = (L_(a,b) - C + s_a)/q. (1) + +Only q is inverted. This proves that the natural action together with the +quotient regular action is faithful: the first column of the latter gives +each s_a, and (1) recovers all c_(a,b). In particular the conclusion remains +valid when the characteristic of K divides h. + +## 3. Remove the redundant constant direction + +Let 1 denote the vector with all q entries equal to one. Since q is +invertible in K, + + K^F = K 1 direct-sum W, + W = {v: sum_x v_x = 0}. + +The action on K 1 is the scalar C, already obtainable from Q. Removing +this one-dimensional summand preserves faithfulness and gives dimension +(q-1)+h. Here is a literal inverse in the basis + + w_x = e_x-e_0, x in F minus {0}. + +Let B be the W block of the supplied carrier matrix. Define columns d_x +of length q by d_0=0 and, for x!=0, + + (d_x)_y = B_(y,x) for y!=0, + (d_x)_0 = -sum_(y!=0) B_(y,x). + +Then d_x=M e_x-M e_0. The row sums of M give + + M e_0 = (C 1 - sum_(x!=0) d_x)/q, + M e_x = M e_0+d_x. (2) + +Recover s_a from Q, recover M using (2), then use (1). These formulas +give a linear left inverse of the carrier map. They do not assert that +an arbitrary block matrix belongs to its image. The executable decoder +re-encodes the recovered coefficients and rejects a matrix outside that image. + +For the natural action alone, M=0 implies C=0. Equation (1) then makes +c_(a,b)=s_a/q independent of b. Conversely put + + Z_a = sum_(b in F) [(a,b)]. + +Every Z_a acts as the same all-ones q-by-q matrix. Thus the complete kernel is + + {sum_a t_a Z_a : sum_a t_a=0}, + +with basis Z_a-Z_1 for a!=1 and dimension h-1. This is a complete kernel +classification, not an inference from finding a single alias. On W the +kernel is the full h-dimensional span of the Z_a. + +## 4. Matching lower bound for every coefficient field + +Let rho:K[G] -> End_K(V) be any faithful unital representation. Put + + e = (1/q) sum_(b in F) [(1,b)]. + +The translation subgroup is normal, so e is a central idempotent. The +elements e[(a,0)] for a in H are linearly independent and multiply as H. +Hence eK[G] is isomorphic to K[H]. Also + + V = eV direct-sum (1-e)V. + +The restriction to eV must be faithful on eK[G], because that ideal acts +as zero on (1-e)V. A finite multiplicative subgroup of a field is cyclic. +For completeness, its exponent d is attained by an element: combine +elements attaining the largest prime-power orders in this finite abelian +group. All h elements solve X^d=1, so the polynomial root bound gives h<=d; +Lagrange gives d<=h. Thus d=h. + +Choose a generator a of H. Then K[H] is K[T]/(T^h-1). Faithfulness on eV +requires the minimal polynomial of rho(e[(a,0)]) restricted to eV to be +exactly T^h-1. Otherwise a nonzero class of degree below h acts as zero. +Cayley-Hamilton therefore gives + + dim_K(eV) >= h. (3) + +This reasoning permits repeated roots in T^h-1. Replacing it by its +squarefree part would lose the modular case. + +To bound the other summand, extend scalars to an algebraic closure L of K. +An injective linear map remains injective under a field extension, and +dimensions of the two summands do not change. The additive group of F is +an elementary abelian p-group of order q. Since char K != p, L contains +q distinct additive characters chi. Their Fourier idempotents are + + e_chi = (1/q) sum_(b in F) chi(-b) [(1,b)]. + +Character orthogonality gives q nonzero pairwise orthogonal idempotents +with sum one. One is e, for the trivial character. These facts follow by +summing the nontrivial pth-root geometric series in any one coordinate of +the additive F_p-vector space. In a faithful representation each e_chi +has nonzero image. The q-1 nontrivial images lie in (1-e)(L tensor_K V) +and are linearly independent summands. Therefore + + dim_K((1-e)V) >= q-1. (4) + +Adding (3) and (4) proves dim V>=q+h-1. Section 3 attains this bound. +The Fourier and minimal-polynomial arguments are classical. Their use +here, together with the explicit coefficient inverse, establishes the +stated exact carrier size. No general representation-theory priority is claimed. + +## 5. Formal-identity consequence + +For any number r of scalar roles, applying the carrier entrywise gives an +injective algebra map + + Mat_r(K[G]) -> Mat_(r(q+h-1))(K). + +Thus exact equality on every column of this smaller carrier is equivalent +to coefficientwise equality of the formal endpoint matrices. All relevant +matrices must actually be tested; a natural action, a sample of vectors, +floating-point equality or group-element faithfulness alone does not imply +this equivalence. This is a verifier interface, not a native implementation. + +## 6. Finite evidence and scope + +The executable builds F2,F3,F4,F5,F7,F8,F9, every subgroup of their +multiplicative groups, and coefficient fields F2,F3,F5,F7 of different +characteristic from the address field. It checks every group product in +the integer carrier, ranks the natural/augmentation/hybrid algebra maps, +reconstructs every formal basis vector and mixed vectors, and checks the +entire displayed natural-kernel basis. A separate rational line-sum +calculation uses literal natural matrices. These checks corroborate the +written proof rather than replace its all-parameter quantifiers. + +In the excluded characteristic, the F3 affine group with h=2 has hybrid +algebra rank three instead of six over F3. The executable checks this +boundary as a rejection control. It is not a theorem about the smallest +carrier in that characteristic. + +No predecessor scientific verifier, selected cold replay, native program, +Lean, Docker or formal proof kernel is run. Independent human and formal +proof-kernel review are unclaimed. The five selected framework assumptions +remain unresolved by this result. diff --git a/research/affine-algebra-minimal-carrier/README.md b/research/affine-algebra-minimal-carrier/README.md new file mode 100644 index 0000000000..fdb294f4e3 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/README.md @@ -0,0 +1,138 @@ +# Smallest faithful carriers for affine group algebras + +This result was produced by Nick Petalas. New material is Apache-2.0. +Claim type: scoped written proof with exact finite corroboration. No new kappa. + +For every finite field F_q of characteristic p, every subgroup H of F_q* +of order h, and every coefficient field K of characteristic different from p, +the smallest faithful linear carrier of K[F_q semidirect H] has dimension + + q+h-1. + +The sum-zero part of the natural permutation module, of dimension q-1, +together with the regular H quotient, of dimension h, attains the bound. +This replaces the regular group carrier's qh coordinates. It works even +when char K divides h. [PROOF.md](PROOF.md) gives the explicit coefficient +inverse and matching dimension lower bound. These are algebraic verifier +sizes, not native operation costs or physical memory measurements. + +| Address field | h | Regular dimension | Smallest faithful linear dimension | +| --- | ---: | ---: | ---: | +| F3 | 2 | 6 | 4 | +| F4 | 3 | 12 | 6 | +| F7 | 3 | 21 | 9 | +| F7 | 6 | 42 | 12 | +| F9 | 8 | 72 | 16 | + +The natural q-point action has an exactly (h-1)-dimensional algebra kernel, +spanned by differences of complete translation coset sums. Its faithfulness +on group elements does not make it a formal-identity checker. Ali Romman's +#5394 already supplies an explicit warning and alias; that warning is +credited background. The new result is the complete kernel, explicit +repaired carrier and exact optimal linear dimension. + +## Construction and evidence + +Write an algebra element as sum c_(a,b)[(a,b)] for a in H, b in F_q, +acting by x -> ax+b. Let M be its natural matrix, s_a=sum_b c_(a,b), and +C=sum_a s_a. Its coefficients satisfy the line-sum inverse + + c_(a,b) = (sum_x M_(ax+b,x) - C + s_a)/q. + +The quotient regular block supplies s_a. The augmentation block and C +reconstruct M after removing its redundant constant direction. Only q is +inverted. The lower bound uses a central translation-average idempotent, +the degree-h minimal polynomial needed for a faithful cyclic H algebra, +and the q-1 nontrivial translation-character idempotents. These ingredients +are classical; no literature-priority claim is made for them. + +The checker builds every multiplicative subgroup of F2,F3,F4,F5,F7,F8,F9. +It checks all integer carrier products and, over coefficient fields +F2,F3,F5,F7 of different characteristic, independently eliminates the +flattened matrix banks to measure their exact span ranks. Every formal +basis vector and twelve mixed vectors per context are recovered. A separate +rational calculation checks the line inverse directly on natural matrices. +No predecessor scientific verifier is imported or replayed. + +The result is zero errors in 54 coefficient contexts, 13,269 group-product +pairs, 1,808 field triples, 1,683 recovered coefficient vectors, 1,380 rational +coefficient recoveries, and 96 natural-kernel basis vectors. Nine controls +cover malformed images, invalid domains and the excluded characteristic. +The latter F3/S3 construction has algebra rank three over F3 instead of six; +this is only a boundary fixture. The span-rank checks also reject omitting +quotient information. The all-parameter claims rest on the written proof. + +## Reproduce + +From the repository root: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/affine-algebra-minimal-carrier +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/affine-algebra-minimal-carrier/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/affine-algebra-minimal-carrier/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/affine-algebra-minimal-carrier --check-source-history +``` + +Other machines may substitute their CPython 3.12 path. Direct runs print +`PASS_AFFINE_ALGEBRA_MINIMAL_CARRIER`; the generic runner adds +`PASS_REGISTERED_RESEARCH_PACKAGE`. JSON output includes counts, per-context +ranks and SHA256 hashes of every package file. Default replay writes nothing. +To save a generated receipt, add `--receipt /absolute/external/scratch/receipt.json`; +an existing destination or a destination inside the checkout is rejected. + +No timing speedup is claimed. Both registered runs have a 120-second bound. +The standard-library code uses fixed fields with q<=9, at most 72 group +elements, 16 carrier coordinates and 256 flattened matrix entries. It uses +no recursion, subprocesses, dynamic code generation or external scientific +input. Functions stay below 60 lines. Managed Python allocations are a +Power of Ten rule-3 deviation bounded by these domains. Warning-strict +normal and optimized replay provide interpreter diagnostics; no shared +analyzer configuration is changed. + +## Scope, provenance and overlap + +The `bit-new-register-model` card changes scope to a side result about exact +finite formal-identity checking, rather than a new paid word. A formal affine +matrix identity can be checked entrywise on this smaller carrier; the result +does not construct a bit supplier. The baseline binding command passes on +canonical main e54523517d0f03e58352e647c403a5af3e525a57. Its selected record is +#7000; the revision-8 catalogue describes the older #5599 assessment. No +selected file changes. [TASK.json](TASK.json) preserves the original card. + +The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19592134) +records the question before the proof checks. Live open/account PR lists, +handoffs, local reservations, all-main README searches for the quantity and +general group family, and merged-PR searches were checked. The overlap +helper's remote snapshot covers 810 open PRs and 7,424 Discussion records +with reported complete pagination; its local note search is sparse and +incomplete. This is bounded overlap evidence, not a novelty certificate or +an unpublished-work search. + +## Open next questions + +- Determine a smallest permutation carrier under an explicit admissible + action class. Start with the natural q-point orbit and an H quotient orbit; + the linear optimum here need not be a permutation representation. +- Determine the smallest faithful carrier in the excluded address + characteristic p. Start with the F3/S3 fixture and account for the complete + group-algebra radical; the averaging inverse and proof here do not apply. +- Bind one actual formal-word checker to this carrier, including its coefficient + field and every basis column, then measure its complete costs. Algebraic + dimension reduction alone establishes no runtime speedup. + +## Credit and limitations + +Credit Ali Romman #5394 for the formal/natural distinction and order-21 alias, +retaining Cinna Davis #2011's order-21 model, the Q8 comparison and +JoyboyBrian's formal support lineage. They are cited background rather than +replay targets. Translation averaging, finite-field character orthogonality, +cyclic group algebras and Cayley-Hamilton are classical. No predecessor +package supplies the main construction or coefficient inverse used here. + +The optimum permits arbitrary linear matrices. It does not price their +realization as permutations, recursive native operations or physical tapes. +Precision, source preparation, routing, ownership, dirty restoration, +compiler closure, complete invoices, outer use and all five selected +assumptions remain. No selected scientific replay, Lean, Docker, native +execution or complete multiplication theorem is claimed. Independent human +and formal proof-kernel review are unclaimed. diff --git a/research/affine-algebra-minimal-carrier/SOURCES.json b/research/affine-algebra-minimal-carrier/SOURCES.json new file mode 100644 index 0000000000..95aa3a7554 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/group-subproduct-cover/README.md", + "usage": "provenance", + "git_blob": "36faba920c546d36f3a51a026e8e84d925acf723", + "sha256": "b9241c29301d2d20af35fe9f09ff2b0e7e7aca0566394b8e4c7708924e59d161" + } + ] +} diff --git a/research/affine-algebra-minimal-carrier/TASK.json b/research/affine-algebra-minimal-carrier/TASK.json new file mode 100644 index 0000000000..e9cb743e14 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/TASK.json @@ -0,0 +1,81 @@ +{ + "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": "Smallest faithful linear carrier for K[F_q semidirect H], over every coefficient field of characteristic different from that of F_q.", + "scope_change_reason": "Replace paid-word synthesis with a self-contained algebraic side result: make finite formal-identity checks smaller and coefficient-faithful. No native supplier is constructed.", + "bottleneck_link": "Exact formal-versus-natural equality is an interface obligation for nonabelian word searches. This result reduces the faithful finite carrier and supplies a coefficient decoder; physical and recursive costs remain open.", + "budget_minutes": 60, + "stop_rule": "Stop at the first explicit smaller faithful carrier with a matching dimension lower bound and exact finite corroboration.", + "outcome": "completed", + "evidence": "PROOF.md; warning-strict normal/optimized verify.py; 54 coefficient contexts with zero errors. No predecessor scientific verifier replayed.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "What is the smallest faithful permutation carrier in a specified action class?", + "why_it_matters": "This distinguishes the linear optimum from a possible native address action.", + "first_step": "Compare the natural F_q orbit plus a quotient H orbit.", + "blocked_by": "No admissible physical/permutation action class or complete cost is fixed." + }, + { + "question": "What is the minimum in address characteristic p?", + "why_it_matters": "The present explicit inverse requires division by q.", + "first_step": "Classify the group-algebra radical for the F3/S3 boundary fixture.", + "blocked_by": "The translation-average argument does not apply." + }, + { + "question": "Can one complete formal-word checker use the new carrier profitably?", + "why_it_matters": "Carrier dimension alone is not a runtime comparison.", + "first_step": "Pin one checker and preserve every coefficient field and basis column.", + "blocked_by": "No source-bound implementation or measured complete invoice is supplied." + } + ], + "environment": { + "python": "3.12.15", + "dependencies": "standard library only" + }, + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19592134" +} diff --git a/research/affine-algebra-minimal-carrier/VERIFY.json b/research/affine-algebra-minimal-carrier/VERIFY.json new file mode 100644 index 0000000000..9c7e899c58 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/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": "Exact carrier group products, natural/augmentation/hybrid span ranks, complete basis recovery, rational line inverse, kernel basis and rejection controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact carrier group products, natural/augmentation/hybrid span ranks, complete basis recovery, rational line inverse, kernel basis and rejection controls." + } + ] +} diff --git a/research/affine-algebra-minimal-carrier/carrier.py b/research/affine-algebra-minimal-carrier/carrier.py new file mode 100644 index 0000000000..0e0d402871 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/carrier.py @@ -0,0 +1,185 @@ +"""Bounded exact affine carriers; no predecessor code or external dependencies.""" + +SPECS = { + "F2": (2, (0, 1)), "F3": (3, (0, 1)), + "F4": (2, (1, 1, 1)), "F5": (5, (0, 1)), + "F7": (7, (0, 1)), "F8": (2, (1, 1, 0, 1)), + "F9": (3, (1, 0, 1)), +} + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def digits(value, prime, degree): + result = [] + for _ in range(degree): + result.append(value % prime) + value //= prime + return result + + +def encode(coefficients, prime): + result = 0 + for coefficient in reversed(coefficients): + result = result * prime + coefficient % prime + return result + + +def product(left, right, prime, modulus): + degree = len(modulus) - 1 + a, b = digits(left, prime, degree), digits(right, prime, degree) + c = [0] * (2 * degree - 1) + for i in range(degree): + for j in range(degree): + c[i + j] += a[i] * b[j] + for i in range(2 * degree - 2, degree - 1, -1): + lead = c[i] % prime + for j in range(degree + 1): + c[i - degree + j] -= lead * modulus[j] + return encode(c[:degree], prime) + + +class Field: + __slots__ = ("name", "prime", "size", "add", "mul", "neg") + + def __init__(self, name, prime, size, add, mul, neg): + self.name = name + self.prime = prime + self.size = size + self.add = add + self.mul = mul + self.neg = neg + + +def field(name): + require(name in SPECS, "unsupported finite field") + prime, modulus = SPECS[name] + degree = len(modulus) - 1 + size = prime ** degree + values = [digits(x, prime, degree) for x in range(size)] + add = tuple(tuple(encode([values[x][i] + values[y][i] + for i in range(degree)], prime) + for y in range(size)) for x in range(size)) + mul = tuple(tuple(product(x, y, prime, modulus) + for y in range(size)) for x in range(size)) + neg = tuple(encode([-v for v in values[x]], prime) for x in range(size)) + require(all(any(mul[x][y] == 1 for y in range(1, size)) + for x in range(1, size)), "field contains a nonunit") + return Field(name, prime, size, add, mul, neg) + + +def subgroup(f, order): + require(type(order) is int and 1 <= order < f.size + and (f.size - 1) % order == 0, "invalid subgroup order") + for generator in range(1, f.size): + powers, value = [], 1 + for _ in range(order): + powers.append(value) + value = f.mul[value][generator] + if value == 1 and len(set(powers)) == order: + return tuple(powers) + raise ValueError("subgroup generator not found") + + +def elements(f, h): + return tuple((a, b) for a in h for b in range(f.size)) + + +def compose(f, left, right): + a, b = left + c, d = right + return f.mul[a][c], f.add[b][f.mul[a][d]] + + +def natural(f, g): + a, b = g + return tuple(f.add[f.mul[a][x]][b] for x in range(f.size)) + + +def zero_matrix(size): + return [[0] * size for _ in range(size)] + + +def matrices(f, h, g): + """Return natural, augmentation, and augmented/quotient carrier matrices.""" + permutation = natural(f, g) + q, order = f.size, len(h) + nat, aug = zero_matrix(q), zero_matrix(q - 1) + hybrid = zero_matrix(q + order - 1) + for x, y in enumerate(permutation): + nat[y][x] = 1 + for x in range(1, q): + for y in range(1, q): + entry = int(permutation[x] == y) - int(permutation[0] == y) + aug[y - 1][x - 1] = entry + hybrid[y - 1][x - 1] = entry + for i, a in enumerate(h): + j = h.index(f.mul[g[0]][a]) + hybrid[q - 1 + j][q - 1 + i] = 1 + return nat, aug, hybrid + + +def linear_combination(mats, coefficients, modulus): + require(len(mats) == len(coefficients) and len(mats) <= 72, + "coefficient length mismatch") + size = len(mats[0]) + require(1 <= size <= 16, "matrix capacity exceeded") + return [[sum(c * matrix[i][j] for c, matrix in zip(coefficients, mats)) + % modulus for j in range(size)] for i in range(size)] + + +def recover(f, h, matrix, modulus): + """Invert the hybrid algebra map using affine line sums, with no H division.""" + q, order = f.size, len(h) + require(modulus in (2, 3, 5, 7) and q % modulus != 0, + "unsupported coefficient characteristic") + size = q + order - 1 + require(len(matrix) == size and all(len(row) == size for row in matrix), + "wrong carrier matrix shape") + require(all(type(x) is int for row in matrix for x in row), + "noninteger carrier entry") + require(all(matrix[i][j] % modulus == 0 + for i in range(size) for j in range(size) + if (i < q - 1) != (j < q - 1)), "mixed carrier blocks") + sums = [matrix[q - 1 + a][q - 1] % modulus for a in range(order)] + total, invq = sum(sums) % modulus, pow(q, -1, modulus) + difference = [[0] + list(row[:q - 1]) for row in matrix[:q - 1]] + difference.insert(0, [0] + [-sum(matrix[i][j] for i in range(q - 1)) + for j in range(q - 1)]) + nat = zero_matrix(q) + for y in range(q): + first = (total - sum(difference[y])) * invq % modulus + nat[y] = [(first + difference[y][x]) % modulus for x in range(q)] + result = [] + for i, a in enumerate(h): + for b in range(q): + line = sum(nat[f.add[f.mul[a][x]][b]][x] for x in range(q)) + result.append((line - total + sums[i]) * invq % modulus) + # This is a decoder for the algebra image, not for arbitrary block matrices. + mats = [matrices(f, h, g)[2] for g in elements(f, h)] + require(linear_combination(mats, result, modulus) + == [[x % modulus for x in row] for row in matrix], + "matrix is outside the carrier algebra") + return result + + +def rank(vectors, modulus): + """Finite row elimination; at most 72 vectors of length at most 256.""" + require(len(vectors) <= 72 and all(len(v) <= 256 for v in vectors), + "rank capacity exceeded") + pivots = {} + for vector in vectors: + row = [x % modulus for x in vector] + for pivot, basis in sorted(pivots.items()): + coefficient = row[pivot] + if coefficient: + row = [(x - coefficient * y) % modulus + for x, y in zip(row, basis)] + pivot = next((i for i, x in enumerate(row) if x), None) + if pivot is not None: + inverse = pow(row[pivot], -1, modulus) + pivots[pivot] = [x * inverse % modulus for x in row] + return len(pivots) diff --git a/research/affine-algebra-minimal-carrier/verify.py b/research/affine-algebra-minimal-carrier/verify.py new file mode 100644 index 0000000000..816a20e684 --- /dev/null +++ b/research/affine-algebra-minimal-carrier/verify.py @@ -0,0 +1,206 @@ +"""Exact finite corroboration of the written all-field carrier theorem.""" + +import argparse +import hashlib +import json +import sys +from fractions import Fraction +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import carrier as c + + +PACKAGE_FILES = ("PROOF.md", "README.md", "SOURCES.json", "TASK.json", + "VERIFY.json", "carrier.py", "verify.py") + + +def flatten(matrix): + return [x for row in matrix for x in row] + + +def multiply(left, right): + size = len(left) + result = c.zero_matrix(size) + for i in range(size): + for k in range(size): + if left[i][k]: + for j in range(size): + result[i][j] += left[i][k] * right[k][j] + return result + + +def check_field(f): + q = f.size + for x in range(q): + for y in range(q): + c.require(f.add[x][y] == f.add[y][x], "addition symmetry") + c.require(f.mul[x][y] == f.mul[y][x], "multiplication symmetry") + for z in range(q): + c.require(f.add[f.add[x][y]][z] == f.add[x][f.add[y][z]], + "addition associativity") + c.require(f.mul[f.mul[x][y]][z] == f.mul[x][f.mul[y][z]], + "multiplication associativity") + c.require(f.mul[x][f.add[y][z]] + == f.add[f.mul[x][y]][f.mul[x][z]], "distributivity") + c.require(f.add[x][0] == x and f.mul[x][1] == x + and f.add[x][f.neg[x]] == 0, "field identities") + return q ** 3 + + +def check_group(f, h, group, hybrid): + lookup = {g: i for i, g in enumerate(group)} + c.require(len({c.natural(f, g) for g in group}) == len(group), + "natural group action is not faithful") + for i, left in enumerate(group): + for j, right in enumerate(group): + result = c.compose(f, left, right) + c.require(multiply(hybrid[i], hybrid[j]) == hybrid[lookup[result]], + "hybrid representation product") + a, b = c.natural(f, left), c.natural(f, right) + c.require(tuple(a[b[x]] for x in range(f.size)) + == c.natural(f, result), "literal affine action product") + return len(group) ** 2 + + +def check_context(f, h, group, natural, aug, hybrid, modulus): + count, order = len(group), len(h) + expected = (count - order + 1, count - order, count) + observed = tuple(c.rank([flatten(m) for m in bank], modulus) + for bank in (natural, aug, hybrid)) + c.require(observed == expected, "algebra span rank mismatch") + recovered = 0 + for i, matrix in enumerate(hybrid): + coefficients = [int(j == i) for j in range(count)] + c.require(c.recover(f, h, matrix, modulus) == coefficients, + "basis coefficient reconstruction") + recovered += 1 + for seed in range(12): + coefficients = [(seed * i * i + i + seed // 3) % modulus + for i in range(count)] + image = c.linear_combination(hybrid, coefficients, modulus) + c.require(c.recover(f, h, image, modulus) == coefficients, + "mixed coefficient reconstruction") + recovered += 1 + # Every stated kernel basis has all coefficients enumerated explicitly. + for a in range(1, order): + coefficients = [0] * count + for b in range(f.size): + coefficients[b] = -1 + coefficients[a * f.size + b] = 1 + c.require(not any(flatten(c.linear_combination(natural, coefficients, + modulus))), + "natural kernel basis is not null") + c.require(any(flatten(c.linear_combination(hybrid, coefficients, modulus))), + "hybrid lost a natural kernel direction") + return {"field": f.name, "subgroup_order": order, "characteristic": modulus, + "regular_dimension": count, "carrier_dimension": len(hybrid[0]), + "ranks_natural_augmentation_hybrid": list(observed), + "coefficient_vectors_recovered": recovered, + "kernel_basis_vectors": order - 1} + + +def rejects(function, expected): + try: + function() + except ValueError as error: + c.require(str(error) == expected, "unexpected rejection reason") + return 1 + raise ValueError("missing rejection: " + expected) + + +def rational_lines(f, h, group, natural): + """Separate uncompressed rational oracle for the affine line inverse.""" + for seed in range(4): + coefficients = [Fraction(i * i - seed, seed + 1) + for i in range(len(group))] + matrix = [[sum(coefficient * m[y][x] + for coefficient, m in zip(coefficients, natural)) + for x in range(f.size)] for y in range(f.size)] + sums = {a: sum(coefficients[i] for i, (t, _) in enumerate(group) if t == a) + for a in h} + total = sum(coefficients) + for i, (a, b) in enumerate(group): + line = sum(matrix[f.add[f.mul[a][x]][b]][x] for x in range(f.size)) + recovered = (line - total + sums[a]) / f.size + c.require(recovered == coefficients[i], "rational line inverse") + return 4 * len(group) + + +def controls(): + f, h = c.field("F3"), (1, 2) + group = c.elements(f, h) + bank = [c.matrices(f, h, g)[2] for g in group] + # The excluded translation characteristic actually destroys this construction. + modular_rank = c.rank([flatten(m) for m in bank], 3) + c.require(modular_rank < len(group), "excluded characteristic control") + total = 1 + total += rejects(lambda: c.field("F6"), "unsupported finite field") + total += rejects(lambda: c.subgroup(f, 3), "invalid subgroup order") + total += rejects(lambda: c.subgroup(f, True), "invalid subgroup order") + total += rejects(lambda: c.recover(f, h, bank[0], 3), + "unsupported coefficient characteristic") + total += rejects(lambda: c.recover(f, h, [[1]], 2), + "wrong carrier matrix shape") + bad = [row[:] for row in bank[0]] + bad[0][2] = 1 + total += rejects(lambda: c.recover(f, h, bad, 2), "mixed carrier blocks") + bad = [row[:] for row in bank[0]] + bad[2][3] = 1 + total += rejects(lambda: c.recover(f, h, bad, 2), + "matrix is outside the carrier algebra") + total += rejects(lambda: c.linear_combination(bank, [1], 2), + "coefficient length mismatch") + return total, modular_rank + + +def run(): + rows, group_pairs, field_triples, rational_coefficients = [], 0, 0, 0 + for name in c.SPECS: + f = c.field(name) + field_triples += check_field(f) + for order in range(1, f.size): + if (f.size - 1) % order: + continue + h = c.subgroup(f, order) + group = c.elements(f, h) + triples = [c.matrices(f, h, g) for g in group] + natural, aug, hybrid = ([t[i] for t in triples] for i in range(3)) + group_pairs += check_group(f, h, group, hybrid) + rational_coefficients += rational_lines(f, h, group, natural) + for modulus in (2, 3, 5, 7): + if modulus != f.prime: + rows.append(check_context(f, h, group, natural, aug, + hybrid, modulus)) + control_count, excluded_rank = controls() + package = Path(__file__).resolve().parent + hashes = {name: hashlib.sha256((package / name).read_bytes()).hexdigest() + for name in PACKAGE_FILES} + return {"status": "PASS_AFFINE_ALGEBRA_MINIMAL_CARRIER", "errors": 0, + "contexts": len(rows), "group_product_pairs": group_pairs, + "field_triples": field_triples, "controls": control_count, + "rational_coefficients_recovered": rational_coefficients, + "excluded_F3_S3_rank": excluded_rank, "results": rows, + "package_sha256": hashes} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--receipt", type=Path) + args = parser.parse_args() + if args.receipt is not None: + destination = args.receipt.resolve() + checkout = Path(__file__).resolve().parents[2] + c.require(not destination.is_relative_to(checkout), + "receipt must be outside the checkout") + result = run() + rendered = json.dumps(result, sort_keys=True, indent=2) + "\n" + if args.receipt is not None: + with destination.open("x", encoding="utf-8") as stream: + stream.write(rendered) + print(rendered, end="") + print("PASS_AFFINE_ALGEBRA_MINIMAL_CARRIER") + + +if __name__ == "__main__": + main() From e09f7734d6e20ffbbb402f81f33066b959b032c6 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Tue, 17 Nov 2026 22:49:08 +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")