From 75aa393e808d030930879b87815e0abb7bb5742d Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Thu, 12 Nov 2026 18:23:47 +0000 Subject: [PATCH 1/2] feat(research): sharpen chronological plateau width divisors --- research/additive-plateau-width/PROOF.md | 169 +++++++++++++++++++ research/additive-plateau-width/README.md | 131 ++++++++++++++ research/additive-plateau-width/SOURCES.json | 34 ++++ research/additive-plateau-width/TASK.json | 111 ++++++++++++ research/additive-plateau-width/VERIFY.json | 32 ++++ research/additive-plateau-width/verify.py | 144 ++++++++++++++++ research/additive-plateau-width/width.py | 133 +++++++++++++++ 7 files changed, 754 insertions(+) create mode 100644 research/additive-plateau-width/PROOF.md create mode 100644 research/additive-plateau-width/README.md create mode 100644 research/additive-plateau-width/SOURCES.json create mode 100644 research/additive-plateau-width/TASK.json create mode 100644 research/additive-plateau-width/VERIFY.json create mode 100644 research/additive-plateau-width/verify.py create mode 100644 research/additive-plateau-width/width.py diff --git a/research/additive-plateau-width/PROOF.md b/research/additive-plateau-width/PROOF.md new file mode 100644 index 0000000000..86afb471de --- /dev/null +++ b/research/additive-plateau-width/PROOF.md @@ -0,0 +1,169 @@ +# A minimum-decrement divisor for chronological widths + +This contribution was produced by Nick Petalas. All integers below are exact. +The recurrence and its separated-flow properties are credited premises from +Jerry Chen / CubeJerry [#7424](https://github.com/CrocSwap/integer-mult-bounds/pull/7424), +head `d622d8c62defa9defeb95741e88b33a120044866`, PROOF.md sections 1–4. +That work extends #7345, codyw912 #4638 and Mihir Srivastava #4507/#5071. +The new step is the additive plateau visit bound and its width divisor. +No predecessor theorem is audited here. + +## 1. Boundary and inherited recurrence + +Fix positive integer target multiplicities W_k and paid-site multiplicities P_r, +with finite nonempty supports satisfying + +``` +2 <= k_min <= k <= m <= A, 1 <= r <= r_max < k_min. +``` + +Each occurrence of a paid site and each chronological path remains distinct. +Let Gamma be the multiplicative semigroup generated by target and paid ranks, +including 1. Write gamma_next for the successor of gamma in Gamma. It exists +because k_min*gamma is in Gamma. For n < A let B_n=1. At n >= A the credited +flow supplies fresh-source multiplicities t_s > 0, their total S=sum_s t_s, +and a nonempty list of individual exit ranks e. Its least replication is + +``` +a_n = lcm( {B_(n-s)/gcd(B_(n-s),t_s): sgamma and s<=A*gamma, +and hence s>=gamma_next. These properties follow from the credited fresh-source +floor s>n/A and the product form of source ranks, evaluated at the plateau's +first rank. Every exit has + +``` +e <= r_max*k_min^G <= r_max*gamma < A*gamma, +``` + +where G=floor(log_(k_min) gamma). Thus every paid exit leaves this plateau. +These statements specify the exact application boundary of the theorem. + +## 2. New visit bound + +Fix a maximum N>=A and an observed plateau gamma<=floor(N/A). Put + +``` +L_gamma = A*gamma, +U_gamma = min(N, A*gamma_next - 1), +delta_gamma = min{s: t_s>0}, +nu_gamma = 1 + floor((U_gamma-L_gamma)/delta_gamma). +``` + +Consider any directed recursive rank chain starting at a rank <=N. Every edge +strictly decreases its rank, so its visits to one plateau are contiguous. An +edge that remains on that plateau cannot be an exit. It must be a complement +n -> n-s, which decreases rank by at least delta_gamma. If the chain visits +this plateau v times, its first and last such ranks differ by at least +(v-1)*delta_gamma, and by at most U_gamma-L_gamma. Therefore + +``` +v <= nu_gamma. +``` + +There is no logarithmic estimate or real-power rounding in this argument. +This visit bound is attained in the numerical recurrence: start at U_gamma +and repeatedly take the positive-count complement with s=delta_gamma until +it leaves the plateau. All intermediate ranks lie in [L_gamma,U_gamma], where +the source census is unchanged. If this process takes another edge while +remaining in the plateau then its child is positive, so that complement exists. +Thus the actual maximum number of visits is exactly nu_gamma. + +A useful uniform consequence is + +``` +nu_gamma <= ceil(A*(gamma_next-gamma)/delta_gamma) + <= ceil(A - A*gamma/gamma_next) + <= A-1. +``` + +The last inequality uses gamma_next<=k_min*gamma<=A*gamma. This also shows +nu_gamma is always smaller than the previous common visit exponent +`tau=A*ceil(log2 k_min)`, which is at least A. Truncating the last plateau +can improve it further. In particular the minimum with the inherited tau, +proposed in the advance claim, equals nu_gamma on this application boundary. + +## 3. New all-prime divisor + +For any prime p, including a prime absent from the rank alphabet, the LCM +recurrence gives + +``` +v_p(B_n) <= v_p(S_n) + max_child v_p(B_child). +``` + +The gcd can only lower a complement child's valuation. Follow a maximizing +child until a base rank is reached. Strict descent makes this finite. The +resulting sum has at most nu_gamma copies of v_p(S(gamma)) on each observed +plateau. The maximizing chain can depend on p; the visit bound holds for all +chains, so no common maximizing chain is needed. Therefore, simultaneously +for every 1<=n<=N, + +``` +B_n divides Q_new(N) = product_(gamma<=floor(N/A)) S(gamma)^nu_gamma. +``` + +Moreover + +``` +Q_new(N) divides Q_old(N) = product_(gamma<=floor(N/A)) S(gamma)^tau. +``` + +Every exponent is lower. Divisibility is strict whenever at least one observed +plateau has S(gamma)>1. Replacing tau by nu_gamma also tightens the explicit +bit envelope to `log2 B_n <= sum_gamma nu_gamma*log2 S(gamma)`; this does not +assert a lower asymptotic degree or change the width sequence. + +The argument is also a self-contained lemma for any integer width recurrence +with the same constant-plateau census, complement steps, below-plateau exits +and unit base widths. Physical native semantics are not needed for that lemma. + +## 4. A sharp first-plateau instance + +Take targets (2,3), one paid rank-1 site, A>=3 and A<=N<2A. Then gamma=1, +gamma_next=2, t_2=t_3=1, S=2, delta=2 and the individual exit is e=1. +The new divisor is + +``` +Q_new(N) = 2^(1+floor((N-A)/2)), +Q_old(N) = 2^A. +``` + +Jerry Chen's #7424 already gives the width formula +`B_n=2^(1+floor((n-A)/2))` on this plateau. We cite that formula as a premise; +it is not the new result. Our divisor attains it exactly at N, so its exponent +cannot be decreased even by one. At A=64, N=127 the upper divisor changes +from 2^64 to the attained 2^32. The source's quadratic explicit-output +obstruction still applies; the smaller divisor does not remove it. + +The uniform A-1 visit constant is sharp as well: two target roles of rank A +and one paid rank-1 site have their first plateau [A,A^2-1], with delta=A, +S=2 and exactly A-1 visits. This follows directly by taking successive +rank-A complements. No physical supplier for either toy rule is asserted. + +## 5. Evidence and limits + +The standard-library checker expands small productive words and paid paths, +then constructs only the exact width recurrence and directed child graph. It +checks the new divisor, its divisibility into the old divisor, actual longest +plateau visits by a separate graph dynamic program, and attaining truncated +plateaus. It imports no predecessor program and runs no predecessor suite. +Finite enumeration corroborates the new theorem; it is not an all-rank proof. + +The result assumes the stated separated numerical compiler and its credited +flow. It supplies no actual selected manifest, complete instruction stream, +new batching policy, native realization, owner erasure, precision/tape bound, +analytic recovery or multiplication theorem. All five selected assumptions +remain. Independent human and formal proof-kernel review are unclaimed. diff --git a/research/additive-plateau-width/README.md b/research/additive-plateau-width/README.md new file mode 100644 index 0000000000..6ca6f01bf8 --- /dev/null +++ b/research/additive-plateau-width/README.md @@ -0,0 +1,131 @@ +# A sharper plateau divisor for chronological widths + +**Scoped written proof with exact finite corroboration. No new κ.** +This contribution was produced by Nick Petalas. + +For the separated fixed-rule numerical compiler of Jerry Chen / CubeJerry's +[#7424](https://github.com/CrocSwap/integer-mult-bounds/pull/7424), replace its +common plateau exponent `tau=A*ceil(log2 k_min)` by + +``` +nu_gamma = 1 + floor((min(N,A*gamma_next-1)-A*gamma)/delta_gamma), +delta_gamma = smallest positive fresh-source rank on the plateau. + +B_n divides product_gamma S(gamma)^nu_gamma, for every 1 <= n <= N. +``` + +Every new exponent is at most `A-1`, strictly below the previous `tau`. +The new divisor divides the old one, strictly whenever an observed plateau +has source count greater than one. It also gives a smaller explicit bit +upper bound. It changes neither the width sequence nor its proved +asymptotic degree. [PROOF.md](PROOF.md) states all hypotheses and proves +that the visit exponent is the exact maximum on the numerical child graph. + +The reason is specific: every paid exit leaves its parent's plateau, while +every complement step inside it subtracts at least `delta_gamma`. Applying +that count to every prime-valuation chain proves the divisor, including +primes absent from the rank alphabet. + +For targets `(2,3)`, one paid rank-1 site, `A=64` and `N=127`, the upper +divisor decreases from `2^64` to `2^32`. The new divisor attains the width +already established by #7424. That width formula is credited prior work; +the new result is the general divisor refinement. No physical supplier for +this toy rule is asserted. + +## Exact evidence + +The independently written standard-library checker imports no predecessor +program. It constructs 670 distinct bounded rule/maximum fixtures, totaling +11,926 width rows and 851 plateau rows. All 851 literal graph maxima equal +the new visit bound. The divisor decreases strictly on 448 fixtures; 222 +have only base ranks. A further 294 first-plateau/truncation fixtures attain +the divisor exactly. Sixteen domain and semantic controls pass, including +lowering the exponent, dropping its final `+1`, allowing a same-plateau exit, +and pooling repeated chronological cuts. + +Normal and optimized runs print identical computed results and fixture digest: + +``` +PASS_ADDITIVE_PLATEAU_WIDTH +computed_library_sha256=39175e152722a32239563041f1ee5c4669c8aca9b5212d3bc96a0ccb98dd8365 +``` + +Counts refer to the stated finite fixtures. The universal statement rests +on the written proof and the cited numerical-flow premises. No predecessor +scientific suite or selected cold replay was run. + +## Reproduce + +From the repository root, with CPython 3.12 and its standard library: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/additive-plateau-width/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -W error -B research/additive-plateau-width/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/additive-plateau-width +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/additive-plateau-width --check-source-history --check-modes +``` + +Substitute another CPython 3.12 path on another machine. The two registered +commands have 120-second timeouts. Direct verification writes nothing. +Adding `--record /absolute/external/new.json` generates a receipt with the +computed results, interpreter version and SHA256 hashes of all seven package +files. It refuses existing paths. A receipt is never hand-written. + +[SOURCES.json](SOURCES.json) pins main's historical task/selected/width documents +as provenance. It separately identifies the exact public #7424 proof and its +SHA256 as cited mathematical provenance. No external executable/data inputs, +network access or unmerged Git objects are needed by the direct verifier. +The citation hash is not a claim of runtime authentication or theorem review. + +## Limits and implementation bounds + +The theorem concerns the exact least-replication recurrence for finite fixed +separated histograms with `r_max low // ambient, "fresh-source floor fails") + encoded = [ambient, targets, paid, maximum, widths, refined, old] + digest.update(json.dumps(encoded, separators=(',', ':')).encode()) + counts['computed_library_sha256'] = digest.hexdigest() + return counts + + +def check_sharpness(): + """For cap one the refinement is exact, including truncated last plateaus.""" + cases = 0 + for ambient in range(3, 101): + for maximum in (ambient, ambient + (ambient - 1) // 2, 2 * ambient - 1): + rows, widths, children, refined, old = library(ambient, (2, 3), (1,), maximum) + low, high, sources, exits, bound, tau = rows[0] + require(bound == (maximum - ambient) // 2 + 1, "wrong endpoint rounding") + require(refined == 2 ** bound, "unexpected cap-one divisor") + require(max(widths) == refined, "cap-one divisor is not attained") + require(maximum_visits(children, low, high) == bound, "visit bound not attained") + require(old == 2 ** ambient and sources == {2: 1, 3: 1} and exits == (1,), + "sharpness fixture changed") + cases += 1 + return {'attaining_truncated_plateaus': cases, + 'A64_N127_old_divisor': str(2 ** 64), + 'A64_N127_new_divisor': str(2 ** 32)} + + +def reject(call, message): + try: + call() + except ValueError: + return + raise ValueError('accepted invalid case: ' + message) + + +def check_controls(): + invalid = ( + ('boolean ambient', lambda: validate_rule(True, (2,), (1,), 4)), + ('unbounded library', lambda: validate_rule(2, (2,), (1,), MAX_N + 1)), + ('no productive role', lambda: validate_rule(4, (), (1,), 8)), + ('no paid site', lambda: validate_rule(4, (2,), (), 8)), + ('unseparated ranks', lambda: validate_rule(4, (2,), (2,), 8)), + ('target beyond ambient', lambda: validate_rule(4, (5,), (1,), 8)), + ('rank-one target', lambda: validate_rule(4, (1,), (1,), 8)), + ('noninteger rank', lambda: validate_rule(4, (2.0,), (1,), 8)), + ('unit generator', lambda: semigroup((1, 2), 20)), + ('zero census cap', lambda: literal_census(4, (2, 3), (1,), 0)), + ('zero maximum', lambda: plateaus(4, (2, 3), (1,), 0)), + ) + for name, call in invalid: + reject(call, name) + rows, widths, children, refined, old = library(64, (2, 3), (1,), 127) + semantic = {'lowered exponent': refined // 2 % max(widths) != 0} + wrong_visits = 1 + (127 - 64) // max(rows[0][2]) + semantic['maximum source replaces minimum'] = 2 ** wrong_visits % max(widths) != 0 + # Dropping the final +1 omits one actual visit. + rows, widths, children, refined, old = library(7, (2, 3), (1,), 13) + semantic['dropped final plus one'] = 2 ** ((13 - 7) // 2) % max(widths) != 0 + # A same-plateau exit invalidates the minimum-complement argument. + fake = [()] * 8 + fake[6], fake[7] = (5,), (6,) + semantic['same-plateau exits'] = maximum_visits(fake, 5, 7) > 1 + (7 - 5) // 3 + # Repeated exits are separate cuts, each requiring two copies. + sources, exits = literal_census(4, (3, 3), (2, 2), 3) + rows, widths, children, refined, old = library(4, (3, 3), (2, 2), 12) + semantic['pooled chronological cuts'] = ( + exits == (4, 4, 4, 4) and widths[4] == 2 and widths[12] == 8 and widths[12] != 4) + for name, detected in semantic.items(): + require(detected, 'semantic control failed: ' + name) + return {'controls': len(invalid) + len(semantic)} + + +def receipt(result): + names = ('PROOF.md', 'README.md', 'SOURCES.json', 'TASK.json', + 'VERIFY.json', 'verify.py', 'width.py') + files = [ROOT / name for name in names] + return {'result': result, 'python': platform.python_version(), + 'sources': {p.name: hashlib.sha256(p.read_bytes()).hexdigest() for p in files}} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--record', type=Path) + args = parser.parse_args() + result = {**check_libraries(), **check_sharpness(), **check_controls()} + if args.record is not None: + require(args.record.is_absolute(), 'record path must be absolute') + path = args.record.resolve() + require(not path.is_relative_to(ROOT), + 'record must be external to the package') + with path.open('x', encoding='utf-8') as stream: + stream.write(json.dumps(receipt(result), indent=2, sort_keys=True) + '\n') + print('PASS_ADDITIVE_PLATEAU_WIDTH ' + json.dumps(result, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/additive-plateau-width/width.py b/research/additive-plateau-width/width.py new file mode 100644 index 0000000000..9aff36787c --- /dev/null +++ b/research/additive-plateau-width/width.py @@ -0,0 +1,133 @@ +"""Exact small chronological libraries and the additive plateau divisor. + +New refinement produced by Nick Petalas. Apache-2.0. +The numerical recurrence is credited in README.md; no source code is imported. +""" +from collections import Counter +from itertools import product +from math import gcd, lcm, prod + +MAX_N = 256 +MAX_ROLES = 4 + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def validate_rule(ambient, targets, paid, maximum): + require(type(ambient) is int and type(maximum) is int, + "ambient and maximum must be integers") + require(2 <= ambient <= MAX_N and 1 <= maximum <= MAX_N, + "bounded checker requires 2 <= ambient <= 256 and 1 <= N <= 256") + for roles in (targets, paid): + require(isinstance(roles, tuple) and 1 <= len(roles) <= MAX_ROLES, + "supply one to four explicit roles") + require(all(type(x) is int and x > 0 for x in roles), + "role ranks must be positive integers") + require(2 <= min(targets) and max(targets) <= ambient, + "productive ranks must lie in [2, ambient]") + require(max(paid) < min(targets), "paid ranks must be separated") + + +def semigroup(generators, cap): + """Integer-by-integer membership, with an explicit cap.""" + require(type(cap) is int and 1 <= cap <= MAX_N * MAX_N, + "semigroup cap out of range") + require(isinstance(generators, tuple) and 1 <= len(generators) <= 2 * MAX_ROLES + and all(type(g) is int and g >= 2 for g in generators), + "semigroup generators must be at least two") + present = [False] * (cap + 1) + present[1] = True + for value in range(2, cap + 1): + present[value] = any(value % g == 0 and present[value // g] + for g in generators) + return tuple(i for i in range(1, cap + 1) if present[i]) + + +def literal_census(ambient, targets, paid, gamma): + """Expand role words and paid paths, without pooling chronological exits.""" + validate_rule(ambient, targets, paid, ambient) + require(type(gamma) is int and 1 <= gamma <= MAX_N // ambient, + "census cap exceeds the bounded library") + height = max(j for j in range(gamma.bit_length()) if min(targets) ** j <= gamma) + sources = Counter() + for depth in range(height + 1): + for path in product(paid, repeat=depth): + rho = prod(path) + for word in product(targets, repeat=height - depth): + column = rho * prod(word) + if column > gamma: + continue + for rank in targets: + sources[column * rank] += 1 + if depth < height: + for rank in paid: + sources[column * rank] -= 1 + require(all(t >= 0 for t in sources.values()), "negative source multiplicity") + sources = {s: t for s, t in sorted(sources.items()) if t} + exits = tuple(prod(path) for path in product(paid, repeat=height + 1)) + require(bool(sources) and min(sources) > gamma, "missing fresh-source floor") + require(max(sources) <= ambient * gamma, "source exceeds its parent") + require(all(0 < e < ambient * gamma for e in exits), "exit stays on plateau") + return sources, exits + + +def plateaus(ambient, targets, paid, maximum): + validate_rule(ambient, targets, paid, maximum) + if maximum < ambient: + return () + cap = maximum // ambient + generators = tuple(sorted(set(targets + paid) - {1})) + points = semigroup(generators, min(targets) * cap) + tau = ambient * (min(targets) - 1).bit_length() + rows = [] + for gamma, successor in zip(points, points[1:]): + if gamma > cap: + break + sources, exits = literal_census(ambient, targets, paid, gamma) + low, high = ambient * gamma, min(maximum, ambient * successor - 1) + delta = min(sources) + additive = 1 + (high - low) // delta + visits = additive + require(1 <= visits <= ambient - 1 < tau, "invalid visit budget") + rows.append((low, high, sources, exits, visits, tau)) + require(rows and rows[-1][1] == maximum, "incomplete plateau cover") + return tuple(rows) + + +def library(ambient, targets, paid, maximum): + """Evaluate only widths and their actual directed child graph.""" + rows = plateaus(ambient, targets, paid, maximum) + widths = [1] * (maximum + 1) + children = [()] * (maximum + 1) + new_divisor, old_divisor = 1, 1 + for low, high, sources, exits, visits, tau in rows: + total = sum(sources.values()) + new_divisor *= total ** visits + old_divisor *= total ** tau + for rank in range(low, high + 1): + replication = 1 + edges = [] + for source, count in sources.items(): + child = rank - source + if child: + replication = lcm(replication, widths[child] // gcd(widths[child], count)) + edges.append(child) + for child in exits: + replication = lcm(replication, widths[child]) + edges.append(child) + widths[rank] = total * replication + children[rank] = tuple(edges) + return rows, tuple(widths), tuple(children), new_divisor, old_divisor + + +def maximum_visits(children, low, high): + """Longest visits found by dynamic programming on the literal child DAG.""" + require(0 < low <= high < len(children) <= MAX_N + 1, "invalid plateau interval") + visits = [0] * (high + 1) + for rank in range(low, high + 1): + require(all(0 <= child < rank for child in children[rank]), "nondecreasing child") + visits[rank] = 1 + max((visits[c] for c in children[rank] if c >= low), default=0) + return max(visits) From 35e2715c9f668d03c494e67dc72f51bfa6cd8fe6 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Tue, 17 Nov 2026 22:47:35 +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")