From 4d3f1c69be00a7c470064091b86f549256e7d87a Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Thu, 12 Nov 2026 18:31:52 +0000 Subject: [PATCH 1/3] feat(research): prove sharp endpoint-promised C prefix scales --- .../native-c-endpoint-prefix-scale/PROOF.md | 145 ++++++++++ .../native-c-endpoint-prefix-scale/README.md | 148 ++++++++++ .../SOURCES.json | 30 ++ .../native-c-endpoint-prefix-scale/TASK.json | 120 ++++++++ .../VERIFY.json | 34 +++ .../native-c-endpoint-prefix-scale/verify.py | 264 ++++++++++++++++++ 6 files changed, 741 insertions(+) create mode 100644 research/native-c-endpoint-prefix-scale/PROOF.md create mode 100644 research/native-c-endpoint-prefix-scale/README.md create mode 100644 research/native-c-endpoint-prefix-scale/SOURCES.json create mode 100644 research/native-c-endpoint-prefix-scale/TASK.json create mode 100644 research/native-c-endpoint-prefix-scale/VERIFY.json create mode 100644 research/native-c-endpoint-prefix-scale/verify.py diff --git a/research/native-c-endpoint-prefix-scale/PROOF.md b/research/native-c-endpoint-prefix-scale/PROOF.md new file mode 100644 index 0000000000..6e257715bf --- /dev/null +++ b/research/native-c-endpoint-prefix-scale/PROOF.md @@ -0,0 +1,145 @@ +# Sharp scale for endpoint-integral native C tensors + +This proof was produced by Nick Petalas. Apache-2.0. + +Put `O=Z[i]`, `pi=1+i`, and + +```text +C = [[1+i,1-i],[1-i,1+i]]/2 + = pi^-1 [[i,1],[1,i]]. +``` + +For `f>=1`, let `C_a` apply C on binary address bit a, and set +`F=C_0 ... C_(f-1)`. Let `C_S=product_(a in S) C_a`. Distinct axes +commute. The endpoint-promised input domain is + +```text +L_f = {x in O^(2^f) : F x in O^(2^f)}. +``` + +Both the input and final output are exact Gaussian integers. No assumption +about intermediate integrality is made. Arbitrary signs, imaginary parts +and independent spectator fibres are allowed. + +## Theorem + +For every `S subset {0,...,f-1}`, put `j=|S|` and `d=min(j,f-j)`. +The least nonnegative integer e such that + +```text +pi^e C_S L_f is contained in O^(2^f) +``` + +is exactly `d`. The least nonnegative integer s such that +`2^s C_S L_f` is integral is exactly `ceil(d/2)`. + +Consequently the least common Gaussian scale for every partial axis product +is `pi^floor(f/2)`, and the least common binary scale is + +```text +2^ceil(floor(f/2)/2). +``` + +The same common scales are minimal for the prefixes of any single fixed +axis ordering. They suffice for every ordering simultaneously. Minimality +is over all inputs in `L_f`, rather than for each individual input. + +## Upper bound from the two endpoints + +Direct multiplication gives + +```text +pi C = [[i,1],[1,i]], +pi C^-1 = [[1,i],[i,1]], +C^2 = [[0,1],[1,0]], +C (1,1)^T = (1,1)^T. +``` + +In particular, `pi C` and `pi C^-1` are Gaussian integral. If `x in L_f` +and `y=F x`, then + +```text +C_S x is in pi^-j O^(2^f), +C_S x = C_(S complement)^-1 y is in pi^-(f-j) O^(2^f). +``` + +For nonnegative a,b, the two fractional modules are nested and their +intersection is `pi^-min(a,b) O^(2^f)`. This proves the bound d, using +only the two endpoint promises. Since `pi^2=2i`, multiplying by +`2^ceil(d/2)` clears those denominators. + +## Matching input at every cut + +Pair d distinct axes in S with d distinct axes outside S. On each pair +use the integer array + +```text +v = e_00 + e_11. +``` + +On every unpaired axis use `u=e_0+e_1`. Let x be their tensor product, +with factors placed on the specified axes. This has only zero/one real +entries and zero imaginary parts. + +The complete transform fixes u and sends each v to `e_01+e_10`. +Indeed C is symmetric and `C^2` is the bit swap, so this identity follows +by multiplying the displayed two-by-two matrices. Thus both x and F x +are Gaussian integral, and x belongs to `L_f`. + +At the chosen cut, exactly one axis in each pair has been transformed. +Its four entries, in address order, are + +```text +(C tensor I) v = pi^-1 (i,1,1,i). +``` + +The same identity holds with the pair's axes exchanged. The unpaired u +factors remain fixed. Every coordinate of `C_S x` is therefore a Gaussian +unit times `pi^-d`. A Gaussian unit is not divisible by pi. Hence no +smaller exponent e can clear the Gaussian denominator. + +Multiplication by `2^s` increases pi divisibility by exactly `2s`, because +`2=-i pi^2`. The same example is integral after that multiplication if +and only if `2s>=d`. This proves the binary lower bound. At a middle cut +of any fixed ordering, `d=floor(f/2)`, proving both common-scale minima. + +## Arithmetic interface consequence + +Suppose a supplied array x and its intended `F x` are Gaussian integral. +Scale the input by the theorem's common binary factor, apply the ordinary +axis sequence, then divide the completed output by the same factor. +Every axis output is integral, and the final division is exact. The +returned mathematical output is exactly `F x`. + +This statement is an arithmetic composition. It supplies neither a +literal scaling program nor a signed-range bound. An implementation must +still pay both conversions, preserve ownership, allocate sufficient +intermediate signed width and scratch, and admit its actual producer's +endpoint promise. The argument applies independently to every spectator +fibre of the positive rank-one native leaf, so it covers arbitrary f in +the stated tensor model without asserting physical implementation. + +## Relation to earlier work and scope + +Jerry Chen / CubeJerry's PR7429 defines this positive C tensor at selected +MOVE24472 and requires every axis output to be integral and fit the signed +width. Its f=2 example already distinguishes final and intermediate +integrality. That distinction and the machine implementation are credited +premises, not new findings or replay targets here. + +Jose Manuel / jmbarrancoml's PR3091 supplies the physical axis method and +retains Alejandro Zarzuelo Urdiales's sharp `ceil(f/2)` binary reserve for +arbitrary inputs. The new bound uses the additional *integral final +output* premise, so it does not replace that unrestricted-input reserve. + +Clear1nsight's PR3382 characterizes the integral entrance on which every +partial coordinate product is already integral. That maximal exactness +lattice is an established result. The proof here does not reconstruct +or use its characterization. The new result is the exact scalar needed +to move the larger endpoint-promised domain into every partial-product +integrality domain, with a matching input at every cut. + +No denominator theorem for arbitrary Clifford words, intervening +noncommuting maps, nonintegral final outputs or rounded trajectories is +asserted. The statement concerns exactly the commuting coordinate C +tensors defined above. All five selected framework assumptions remain. diff --git a/research/native-c-endpoint-prefix-scale/README.md b/research/native-c-endpoint-prefix-scale/README.md new file mode 100644 index 0000000000..05de5603ca --- /dev/null +++ b/research/native-c-endpoint-prefix-scale/README.md @@ -0,0 +1,148 @@ +# Sharp integral-prefix scale for the positive native C tensor + +This scoped written proof with exact finite corroboration was produced by +Nick Petalas. Apache-2.0. No new kappa or selected-frontier change is claimed. + +For `C=[[1+i,1-i],[1-i,1+i]]/2`, suppose both x and `C^(tensor f) x` +are Gaussian-integer arrays. The least common binary input scale making +every axis prefix integral is exactly + +```text +2^ceil(floor(f/2)/2). +``` + +More precisely, at any cut with j processed axes, the sharp Gaussian +denominator exponent is `min(j,f-j)`, in units of `pi=1+i`. The sharp +binary scale at that cut is `2^ceil(min(j,f-j)/2)`. This covers every +subset of axes and therefore every fixed axis order. It allows arbitrary +Gaussian-integer inputs satisfying the final-output promise, with arbitrary +spectator fibres. + +[PROOF.md](PROOF.md) proves the all-f statement. From the input, the cut +has at most j Gaussian denominator factors. From the integral output, its +inverse suffix has at most f-j. Paired-coordinate integer inputs attain +the smaller exponent at every cut. + +## What changes + +Jerry Chen / CubeJerry's [PR7429](https://github.com/CrocSwap/integer-mult-bounds/pull/7429) +implements this tensor as the positive rank-one central leaf of selected +MOVE24472. It requires integral, width-fitting outputs at every axis and +already gives an f=2 example with integral endpoints but a nonintegral +intermediate. That example and the implementation are credited prior work. + +The new arithmetic bridge is to multiply an endpoint-promised input by the +sharp scale, run the ordinary axes with exact divisions, and divide the +completed output by the same scale. Every intermediate axis output is +integral and the original mathematical output is returned exactly. + +The unrestricted-input reserve `ceil(f/2)` is established prior work, +retained in Jose Manuel / jmbarrancoml's [PR3091](https://github.com/CrocSwap/integer-mult-bounds/pull/3091) +and credited there to Alejandro Zarzuelo Urdiales. The smaller exponent +here uses an additional endpoint promise. Clear1nsight's +[PR3382](https://github.com/CrocSwap/integer-mult-bounds/pull/3382) characterizes +the different entrance where all partial products are already integral. +Neither predecessor theorem nor executable is audited or replayed here. + +## Exact finite evidence + +The standard-library checker imports no predecessor code. It checks: + +- 164 sharp cut witnesses, covering every axis subset through f=6 and + every prefix cut for f=7 through 10. Each also executes the complete + scaled arithmetic program and exact final division. +- All 65,808 Gaussian arrays with real and imaginary components in `{0,1}` + for f=1,2,3. Exactly 968 have integral final outputs; all their 3,792 + checked prefixes satisfy both denominator bounds. The other 64,840 + inputs are outside the promised endpoint domain. +- 180 signed complex prefixes checked against a separately coded rational + butterfly, with direct tensor-entry comparisons through f=4. +- All 153 axis permutations at f=1 through 5 on the paired witnesses. +- Eight named semantic controls, including a scale one bit too small at + f=6, a missing endpoint promise, inexact divisions, inverse-phase + confusion and a signed complex dirty offset. + +Finite checks corroborate the written proof. They do not enumerate the +unbounded input lattice. Every acceptance check remains active under `-O`. +The verifier writes nothing and prints a generated receipt containing the +results, Python version and SHA256 of every package file. No receipt is +hand-written or checked in. + +## Reproduce + +From the repository root: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/native-c-endpoint-prefix-scale/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/native-c-endpoint-prefix-scale/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/native-c-endpoint-prefix-scale +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/native-c-endpoint-prefix-scale --check-source-history +``` + +Substitute any installed CPython 3.12 path on another host. Expected markers +are `PASS_NATIVE_C_ENDPOINT_PREFIX_SCALE`, `PASS_REGISTERED_RESEARCH_PACKAGE` +and, after committing, `PASS_RESEARCH_COMMIT_BYTES`. The standalone verifier +also works in a Git-free package copy. Each registered command has a +120-second cap. Normal and optimized direct runs take less than a second +locally; these are check durations, not physical performance measurements. + +## Scope and source boundary + +The claim is a new numerical interface theorem for a stated tensor, with +no changed supplier word. It does not establish that a production caller +supplies the endpoint promise. Signed range, scratch width, physical +scaling/unscaling, ownership, tape movement, compiler closure, stock and +the complete paid/productive invoice remain separate obligations. All five +selected framework assumptions remain. No native machine, selected cold +replay, Lean, Docker or complete multiplication theorem is run or claimed. +Independent human and formal proof-kernel review are unclaimed. + +The base is canonical main `e54523517d0f03e58352e647c403a5af3e525a57`, +priority revision 8, selected #7000. [TASK.json](TASK.json) records the +explicit change from the formal-interface card to this written arithmetic +proof. [SOURCES.json](SOURCES.json) pins canonical provenance only. The +definition and proof are self-contained, with no external executable or +data inputs. TASK also records #7429's exact head, README path and the SHA256 +of the source text inspected. That external document is provenance, not a +registered replay dependency or an asserted independently certified input. + +[Advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19571939). +Live claims, the account's recent contributions, the main-tree READMEs and +merged PRs were checked for the formula, tensor, endpoint promise and more +general partial-product forms. The overlap snapshot reported complete +pagination of 760 open PRs and 7,346 Discussion records, without warnings. +No same-scope result was found in that coverage. Arbitrary unpublished work +and unsearched diffs remain outside it. + +Power of Ten inspection found no recursion, dynamic evaluation, subprocesses +or writes in the verifier. All arithmetic domains are fixed: f is at most +10, arrays have at most 1,024 entries, and the exhaustive loop has at most +65,536 cases at one f. Every function is under 60 physical lines. All gates +use exact integers or Fractions and explicit failure checks. Receipt hashing +caps the inventory at twelve files and each file at 1 MiB. Managed Python +allocation is a deviation from fixed steady-state allocation; the fixed +domains bound live collections, but runtime allocation internals are not +measured. Warning-strict normal and optimized execution supplies the available +diagnostics; no separate static analyzer or native fixed-allocation version +is supplied. + +## Open next questions + +Can the sharp scale be installed around one literal positive C leaf with +a favorable complete physical bill? First supply an actual producer with +the required endpoint promise, bound every scaled intermediate magnitude, +and price both exact conversions together with movement, owners and retained +history. Those missing contracts prevent a supplier or kappa claim. This +package stops at the first sharp arithmetic result and reserves no follow-up. + +## Credit + +The new proof, matching all-cut witnesses and checker were produced by +Nick Petalas. Jerry Chen / CubeJerry supplies PR7429's literal leaf and its +explicit integrality boundary. Jose Manuel / jmbarrancoml supplies PR3091's +physical axis method, retaining Alejandro Zarzuelo Urdiales's C/parity and +tensor-reserve credit. Clear1nsight supplies PR3382's maximal simultaneous +exactness lattice. The selected native, Gaussian, controller and physical +lineage retains its predecessor credit. Fractional-ideal arithmetic and +tensor-product identities are classical; no literature-wide priority is +claimed for those methods. diff --git a/research/native-c-endpoint-prefix-scale/SOURCES.json b/research/native-c-endpoint-prefix-scale/SOURCES.json new file mode 100644 index 0000000000..4fcd4143c4 --- /dev/null +++ b/research/native-c-endpoint-prefix-scale/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/physical-gaussian-leaf/README.md", + "usage": "provenance", + "git_blob": "573a0c3c9df984a397c112026dfc2d8e2cc94c66", + "sha256": "60f82399ac13f3c0f1f10de6488021b64240711190a09962568f2d72ea302eb0" + }, + { + "path": "research/p104-clifford-exactness/README.md", + "usage": "provenance", + "git_blob": "581edcfcbcc31cf78c02f9873c14094f9b37e1bf", + "sha256": "7374b6b360fa6755f68ee513467de1c0436a48a22a9584a3c27687e73a16a7db" + } + ] +} diff --git a/research/native-c-endpoint-prefix-scale/TASK.json b/research/native-c-endpoint-prefix-scale/TASK.json new file mode 100644 index 0000000000..ba49b422d4 --- /dev/null +++ b/research/native-c-endpoint-prefix-scale/TASK.json @@ -0,0 +1,120 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "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": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Exact all-f Gaussian and binary scales clearing every partial-axis C tensor on Gaussian-integral inputs whose complete C tensor output is Gaussian integral.", + "scope_change_reason": "The formal-interface card is narrowed to a written numerical implication exposed by PR7429, without a proof-assistant build or selected-assumption discharge.", + "bottleneck_link": "Provides the sharp arithmetic scale converting an endpoint-integrality promise into the intermediate-integrality precondition of the positive C native leaf. Physical width, conversion tariffs and the full caller remain separate.", + "budget_minutes": 60, + "stop_rule": "Stop at the first proved sharp scale with exact attaining inputs and bounded finite corroboration; leave physical implementation and range pricing to an explicit next question.", + "outcome": "completed", + "evidence": "PROOF.md gives the two-boundary fractional-ideal argument and matching paired-coordinate input for every cut. verify.py checks exact finite witnesses, exhaustive small inputs, independent arithmetic oracles and semantic controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Can the sharp scale be installed around the literal positive C leaf with a favorable complete physical bill?", + "why_it_matters": "The theorem closes intermediate integrality under an endpoint promise, but extra scaling and wider signed fields may consume its benefit.", + "first_step": "Supply one actual endpoint-integral producer, bound every scaled intermediate magnitude, and price both exact conversions, tape movement, owners and retained history.", + "blocked_by": "No literal scaling wrapper, signed-range theorem, producer admission or complete recursive comparison is supplied." + } + ], + "playbook": "Autonomous local run", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19571939", + "predecessors": [ + { + "pr": 7429, + "author": "CubeJerry", + "head": "1a555e469b89af70d309bc966f8f813ac11dc887", + "path": "research/literal-positive-c-leaf/README.md", + "sha256": "d806cf3772570ecccb9b45de1570bdeba723765fe494192f074aee8f041ccdf5", + "usage": "Question and numerical-boundary provenance only; no executable or scientific receipt is imported.", + "url": "https://github.com/CubeJerry/integer-mult-bounds/blob/1a555e469b89af70d309bc966f8f813ac11dc887/research/literal-positive-c-leaf/README.md" + }, + { + "pr": 3091, + "author": "jmbarrancoml", + "path": "research/physical-gaussian-leaf/README.md", + "usage": "Credited physical axis method and retained unrestricted ceil(f/2) reserve; not replayed." + }, + { + "pr": 3382, + "author": "Clear1nsight", + "path": "research/p104-clifford-exactness/README.md", + "usage": "Related all-partial-product exactness lattice; its theorem is neither used nor replayed." + } + ] +} diff --git a/research/native-c-endpoint-prefix-scale/VERIFY.json b/research/native-c-endpoint-prefix-scale/VERIFY.json new file mode 100644 index 0000000000..45c095717e --- /dev/null +++ b/research/native-c-endpoint-prefix-scale/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 sharp cut witnesses, endpoint-promised exhaustive small-box inputs, independent rational and dense-tensor oracles, axis-order permutations, scaling composition and named semantic controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact sharp cut witnesses, endpoint-promised exhaustive small-box inputs, independent rational and dense-tensor oracles, axis-order permutations, scaling composition and named semantic controls." + } + ] +} diff --git a/research/native-c-endpoint-prefix-scale/verify.py b/research/native-c-endpoint-prefix-scale/verify.py new file mode 100644 index 0000000000..a504d886ef --- /dev/null +++ b/research/native-c-endpoint-prefix-scale/verify.py @@ -0,0 +1,264 @@ +#!/usr/bin/env python3 +"""Exact finite corroboration of the native C prefix-scale theorem. + +Produced by Nick Petalas. Apache-2.0. Standard library only. +No predecessor executable is imported or run. All checks survive -O. +""" + +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from itertools import permutations, product +from pathlib import Path +import json +import random +import sys + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def multiply(z, w): + return z[0] * w[0] - z[1] * w[1], z[0] * w[1] + z[1] * w[0] + + +def axis_numerator(values, axis): + """Apply 2C using real integer rows, without any division.""" + out = list(values) + for a in range(len(values)): + if a & (1 << axis): + continue + b = a | (1 << axis) + ar, ai = values[a] + br, bi = values[b] + out[a] = ar - ai + br + bi, ar + ai - br + bi + out[b] = ar + ai + br - bi, ai - ar + br + bi + return out + + +def prefixes(values, order): + result = [list(values)] + for axis in order: + result.append(axis_numerator(result[-1], axis)) + return result + + +def is_integral(numerators, denominator): + return all(a % denominator == b % denominator == 0 for a, b in numerators) + + +def divide(numerators, denominator): + need(is_integral(numerators, denominator), "nonintegral Gaussian value") + return [(a // denominator, b // denominator) for a, b in numerators] + + +def scaled_program(values, order, scale): + current = [(scale * a, scale * b) for a, b in values] + for axis in order: + current = divide(axis_numerator(current, axis), 2) + return divide(current, scale) + + +def rational_axis(values, axis): + """Independent complex multiplication with rational coefficients.""" + diagonal = Fraction(1, 2), Fraction(1, 2) + off = Fraction(1, 2), Fraction(-1, 2) + out = list(values) + for a in range(len(values)): + if a & (1 << axis): + continue + b = a | (1 << axis) + u, v = multiply(diagonal, values[a]), multiply(off, values[b]) + out[a] = u[0] + v[0], u[1] + v[1] + u, v = multiply(off, values[a]), multiply(diagonal, values[b]) + out[b] = u[0] + v[0], u[1] + v[1] + return out + + +def dense_tensor(values, f, selected): + """Direct tensor entries i^(d-HammingDistance)/pi^d on selected bits.""" + mask = sum(1 << a for a in selected) + d = len(selected) + denominator = (1, 0) + for _ in range(d): + denominator = multiply(denominator, (1, 1)) + norm = denominator[0] ** 2 + denominator[1] ** 2 + inverse = Fraction(denominator[0], norm), Fraction(-denominator[1], norm) + units = ((1, 0), (0, 1), (-1, 0), (0, -1)) + result = [] + for a in range(1 << f): + total = (0, 0) + for b in range(1 << f): + if (a ^ b) & ~mask: + continue + exponent = d - ((a ^ b) & mask).bit_count() + term = multiply(units[exponent % 4], values[b]) + total = total[0] + term[0], total[1] + term[1] + result.append(multiply(total, inverse)) + return result + + +def witness(f, selected): + selected = tuple(sorted(selected)) + other = tuple(a for a in range(f) if a not in selected) + pairs = tuple(zip(selected, other)) + values, endpoint = [], [] + for address in range(1 << f): + equal = all(((address >> a) ^ (address >> b)) & 1 == 0 for a, b in pairs) + opposite = all(((address >> a) ^ (address >> b)) & 1 == 1 for a, b in pairs) + values.append((int(equal), 0)) + endpoint.append((int(opposite), 0)) + return values, endpoint + + +def check_cut(f, selected): + x, expected = witness(f, selected) + order = tuple(selected) + tuple(a for a in range(f) if a not in selected) + history = prefixes(x, order) + need(divide(history[-1], 1 << f) == expected, "witness endpoint") + common = 1 << (((f // 2) + 1) // 2) + need(scaled_program(x, order, common) == expected, "scaled arithmetic program") + j = len(selected) + d = min(j, f - j) + pi_power = (1, 0) + for _ in range(d): + pi_power = multiply(pi_power, (1, 1)) + cut = [multiply(v, pi_power) for v in history[j]] + integral = divide(cut, 1 << j) + need(all(abs(a) + abs(b) == 1 for a, b in integral), "sharp Gaussian denominator") + binary = 1 << ((d + 1) // 2) + divide([(binary * a, binary * b) for a, b in history[j]], 1 << j) + if binary > 1: + need(not is_integral([(binary // 2 * a, binary // 2 * b) + for a, b in history[j]], 1 << j), "binary lower bound") + if f <= 4: + need(dense_tensor(x, f, selected) == + [(Fraction(a, 1 << j), Fraction(b, 1 << j)) for a, b in history[j]], + "direct tensor oracle") + return {"f": f, "cut": j, "gaussian_exponent": d, "binary_scale": binary} + + +def exhaustive_box(): + """Every Gaussian 0/1-component array through three axes.""" + counts = Counter() + for f in range(1, 4): + n = 1 << f + scale = 1 << (((f // 2) + 1) // 2) + for flat in product((0, 1), repeat=2 * n): + x = list(zip(flat[::2], flat[1::2])) + history = prefixes(x, range(f)) + counts["inputs"] += 1 + if not is_integral(history[-1], 1 << f): + counts["outside_endpoint_domain"] += 1 + continue + counts["endpoint_integral"] += 1 + for j, row in enumerate(history): + d = min(j, f - j) + pi = (1, 0) + for _ in range(d): + pi = multiply(pi, (1, 1)) + divide([multiply(z, pi) for z in row], 1 << j) + divide([(scale * a, scale * b) for a, b in row], 1 << j) + counts["prefixes"] += 1 + return dict(counts) + + +def independent_oracles(): + rng = random.Random(8527429) + count = 0 + for f in range(1, 6): + for _ in range(12): + x = [(rng.randrange(-7, 8), rng.randrange(-7, 8)) for _ in range(1 << f)] + order = tuple(rng.sample(range(f), f)) + integer = prefixes(x, order) + rational = [(Fraction(a), Fraction(b)) for a, b in x] + for j, axis in enumerate(order, 1): + rational = rational_axis(rational, axis) + need(rational == [(Fraction(a, 1 << j), Fraction(b, 1 << j)) + for a, b in integer[j]], "independent rational prefix") + if f <= 4: + need(rational == dense_tensor(x, f, order[:j]), "dense tensor prefix") + count += 1 + return count + + +def permutation_checks(): + count = 0 + for f in range(1, 6): + x, endpoint = witness(f, range(f // 2)) + scale = 1 << (((f // 2) + 1) // 2) + for order in permutations(range(f)): + history = prefixes(x, order) + need(divide(history[-1], 1 << f) == endpoint, "axis order endpoint") + for j, row in enumerate(history): + divide([(scale * a, scale * b) for a, b in row], 1 << j) + count += 1 + return count + + +def controls(): + checked = [] + x, endpoint = witness(6, range(3)) + h = prefixes(x, range(6)) + need(divide(h[-1], 64) == endpoint, "six-axis promise") + checked.append("six_axis_integral_endpoint") + need(not is_integral([(2*a, 2*b) for a, b in h[3]], 8), "one bit too little") + checked.append("one_bit_below_sharp_scale") + impulse = [(1, 0)] + [(0, 0)] * 7 + bad = prefixes(impulse, range(3)) + need(not is_integral(bad[-1], 8), "missing endpoint hypothesis") + checked.append("unpromised_endpoint") + need(not is_integral([(2*a, 2*b) for a, b in bad[-1]], 8), "unpromised scale") + checked.append("scale_without_endpoint_promise_fails") + for bad_denominator in (2, 4): + rejected = False + try: + divide([(1, 0)], bad_denominator) + except ValueError as error: + rejected = str(error) == "nonintegral Gaussian value" + need(rejected, "inexact division must reject") + checked.append("inexact_division_" + str(bad_denominator)) + minus = rational_axis([(Fraction(1), Fraction(0)), (Fraction(0), Fraction(0))], 0) + need(minus != [(Fraction(1,2), Fraction(-1,2)), + (Fraction(1,2), Fraction(1,2))], "inverse/phase confusion") + checked.append("forward_not_inverse_phase") + shifted = [(a - 8, b + 8) for a, b in x] + need(divide(prefixes(shifted, range(6))[-1], 64) == + [(a - 8, b + 8) for a, b in endpoint], "arbitrary signed dirty offset") + checked.append("signed_complex_dirty_offset") + return checked + + +def run(): + cuts = [] + for f in range(1, 7): + for mask in range(1 << f): + cuts.append(check_cut(f, tuple(a for a in range(f) if mask & (1 << a)))) + for f in range(7, 11): + for j in range(f + 1): + cuts.append(check_cut(f, tuple(range(j)))) + summary = { + "claim_type": "scoped written proof with exact finite corroboration", + "cut_witnesses": len(cuts), + "cut_profile_sha256": sha256(json.dumps(cuts, sort_keys=True).encode()).hexdigest(), + "exhaustive_box": exhaustive_box(), + "independent_prefixes": independent_oracles(), + "axis_permutations": permutation_checks(), + "controls": controls(), + "binary_scales_f1_to_f10": [1 << (((f // 2) + 1) // 2) for f in range(1, 11)], + } + here = Path(__file__).resolve().parent + files = sorted(p for p in here.iterdir() if p.is_file()) + need(len(files) <= 12, "package inventory cap") + need(all(p.stat().st_size <= 2**20 for p in files), "package byte cap") + receipt = {"result": summary, + "files": {p.name: sha256(p.read_bytes()).hexdigest() for p in files}, + "python": sys.version.split()[0]} + print(json.dumps(receipt, sort_keys=True, indent=2)) + print("PASS_NATIVE_C_ENDPOINT_PREFIX_SCALE") + + +if __name__ == "__main__": + run() From 8b0dd714d30e9c1574387587eb6418ae99ac34e1 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Thu, 12 Nov 2026 18:32:37 +0000 Subject: [PATCH 2/3] docs(research): state the production credit explicitly --- research/native-c-endpoint-prefix-scale/README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/research/native-c-endpoint-prefix-scale/README.md b/research/native-c-endpoint-prefix-scale/README.md index 05de5603ca..d1a72ee127 100644 --- a/research/native-c-endpoint-prefix-scale/README.md +++ b/research/native-c-endpoint-prefix-scale/README.md @@ -1,7 +1,8 @@ # Sharp integral-prefix scale for the positive native C tensor -This scoped written proof with exact finite corroboration was produced by -Nick Petalas. Apache-2.0. No new kappa or selected-frontier change is claimed. +This contribution was produced by Nick Petalas. Apache-2.0. +Claim type: scoped written proof with exact finite corroboration. +No new kappa or selected-frontier change is claimed. For `C=[[1+i,1-i],[1-i,1+i]]/2`, suppose both x and `C^(tensor f) x` are Gaussian-integer arrays. The least common binary input scale making From 48b7734703b6c94d897a378c4a9f01cb099c7f22 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Tue, 17 Nov 2026 22:47:59 +0000 Subject: [PATCH 3/3] 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")