From 098bdbe5e554bb94a4ffe14b4f80758c80884bc5 Mon Sep 17 00:00:00 2001 From: Charles Bethin Date: Tue, 13 Oct 2026 00:33:28 -0400 Subject: [PATCH] Add exact Gram prefix reuse with pinned verification and timing evidence --- .github/workflows/gram-prefix-performance.yml | 40 + research/gram-prefix-performance/CLAIM.md | 43 + research/gram-prefix-performance/NOTICE.md | 25 + research/gram-prefix-performance/PROOF.md | 108 +++ research/gram-prefix-performance/README.md | 139 ++++ research/gram-prefix-performance/SOURCE.json | 12 + research/gram-prefix-performance/adapter.py | 115 +++ research/gram-prefix-performance/benchmark.py | 105 +++ .../evidence/VALIDATION.json | 36 + .../evidence/kernel-optimized-python314.txt | 21 + .../evidence/macos-python313-cpu.json | 754 ++++++++++++++++++ .../evidence/macos-python313.json | 686 ++++++++++++++++ .../evidence/macos-python314-cpu.json | 754 ++++++++++++++++++ .../evidence/macos-python314.json | 686 ++++++++++++++++ .../evidence/minimal-offline-replay.txt | 29 + .../evidence/mutations-python313.jsonl | 5 + .../evidence/verify-python313.txt | 29 + .../evidence/verify-python314.txt | 29 + .../evidence/wall-only-benchmark.py.txt | 96 +++ .../gram-prefix-performance/frames.json.gz | Bin 0 -> 8396 bytes research/gram-prefix-performance/kernel.py | 87 ++ .../gram-prefix-performance/test_kernel.py | 339 ++++++++ .../gram-prefix-performance/test_package.py | 119 +++ research/gram-prefix-performance/verify.py | 14 + 24 files changed, 4271 insertions(+) create mode 100644 .github/workflows/gram-prefix-performance.yml create mode 100644 research/gram-prefix-performance/CLAIM.md create mode 100644 research/gram-prefix-performance/NOTICE.md create mode 100644 research/gram-prefix-performance/PROOF.md create mode 100644 research/gram-prefix-performance/README.md create mode 100644 research/gram-prefix-performance/SOURCE.json create mode 100644 research/gram-prefix-performance/adapter.py create mode 100644 research/gram-prefix-performance/benchmark.py create mode 100644 research/gram-prefix-performance/evidence/VALIDATION.json create mode 100644 research/gram-prefix-performance/evidence/kernel-optimized-python314.txt create mode 100644 research/gram-prefix-performance/evidence/macos-python313-cpu.json create mode 100644 research/gram-prefix-performance/evidence/macos-python313.json create mode 100644 research/gram-prefix-performance/evidence/macos-python314-cpu.json create mode 100644 research/gram-prefix-performance/evidence/macos-python314.json create mode 100644 research/gram-prefix-performance/evidence/minimal-offline-replay.txt create mode 100644 research/gram-prefix-performance/evidence/mutations-python313.jsonl create mode 100644 research/gram-prefix-performance/evidence/verify-python313.txt create mode 100644 research/gram-prefix-performance/evidence/verify-python314.txt create mode 100644 research/gram-prefix-performance/evidence/wall-only-benchmark.py.txt create mode 100644 research/gram-prefix-performance/frames.json.gz create mode 100644 research/gram-prefix-performance/kernel.py create mode 100644 research/gram-prefix-performance/test_kernel.py create mode 100644 research/gram-prefix-performance/test_package.py create mode 100644 research/gram-prefix-performance/verify.py diff --git a/.github/workflows/gram-prefix-performance.yml b/.github/workflows/gram-prefix-performance.yml new file mode 100644 index 0000000000..4a27321afb --- /dev/null +++ b/.github/workflows/gram-prefix-performance.yml @@ -0,0 +1,40 @@ +name: Exact Gram prefix performance + +on: + workflow_dispatch: + pull_request: + paths: + - 'research/gram-prefix-performance/**' + - '.github/workflows/gram-prefix-performance.yml' + +permissions: + contents: read + +jobs: + verify: + runs-on: ubuntu-24.04 + timeout-minutes: 10 + strategy: + matrix: + python: ['3.11', '3.14'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python }} + - name: Exact checks and full frame regeneration + run: python -B research/gram-prefix-performance/verify.py + - name: Mutated kernels and enabled arithmetic under optimized Python + run: | + python -B research/gram-prefix-performance/test_kernel.py --mutations + python -O -B research/gram-prefix-performance/test_kernel.py + - name: Complete checker comparison without a timing threshold + run: python -B research/gram-prefix-performance/benchmark.py --pairs 7 --out "$RUNNER_TEMP/gram-prefix.json" + - name: Preserve frozen inputs + run: git diff --exit-code + - uses: actions/upload-artifact@v4 + with: + name: gram-prefix-python-${{ matrix.python }} + path: ${{ runner.temp }}/gram-prefix.json diff --git a/research/gram-prefix-performance/CLAIM.md b/research/gram-prefix-performance/CLAIM.md new file mode 100644 index 0000000000..ecc33c1475 --- /dev/null +++ b/research/gram-prefix-performance/CLAIM.md @@ -0,0 +1,43 @@ +# Sprint claim + +- Track: verification engineering. +- Assignment seed: 88, drawn with `secrets.randbelow(100)` from operating-system randomness. +- Task: `01a13378-812e-75b3-9b4b-0dd927f1901a`. +- Start: `2026-10-13T04:15:36.018560+00:00`. +- Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +- Expected finish: `2026-10-13T05:00:00Z`. + +## Candidates + +1. Reuse exact leading principal minors in the selected bit Gram checker. +2. Replace the selected owner checker's repeated rational exponential operations. +3. Accelerate exact state evaluation in the selected helper-interface checker. + +PR672 covers candidate 2. PR662 covers candidate 3. +Choose candidate 1. Use seed 88 for the matrix controls and benchmark order. + +## Scope + +Optimize determinant evaluation in the pinned `gram_frames.py` checker for the selected R420 bit word. +Compute the leading principal minors in one exact Bareiss pass. +Retain the original pivoted determinant for zero-pivot cases. + +Compare every requested determinant with the original implementation. +Run the complete Gram checker on identical exported frames with both engines. +Retain rank, annihilator, prime-witness, positivity, and failure checks. +Provide exact source pins, negative controls, raw timings, and an optional adapter. + +The deliverable is a tooling improvement. It makes no new kappa claim. +Reserve the final quarter of the session for verification and the handoff. + +## Coordination and predecessors + +GitHub reports no pinned issues at the initial inspection. +The local claim follows the sprint instructions for that case. +The overlap scan covers 513 open PRs through PR693 and the review ledger. +PR239 uses dual Gram matrices for large frames. +PR367 changes rational rank and canonical basis calculations for a historical verifier. + +PR452 shares producer prefixes and changes scalar admission in another historical pipeline. +PR154 changes concurrency and binary frame operations. +Those contributions use different mechanisms. None is a code dependency. diff --git a/research/gram-prefix-performance/NOTICE.md b/research/gram-prefix-performance/NOTICE.md new file mode 100644 index 0000000000..e63319e8d3 --- /dev/null +++ b/research/gram-prefix-performance/NOTICE.md @@ -0,0 +1,25 @@ +# Attribution and license + +This contribution uses the repository's Apache-2.0 license. +Prepared for Charles Bethin with substantial OpenAI Codex assistance. +The implementation, tests, mathematical explanation, review, and packaging use that assistance. +Internal agent review is not independent human peer review. + +The reference Gram checker and record exporter come from Dylan Crow +(`utcorvusvolat-dotcom`), with Anthropic Claude assistance, through PR370 and +its later retained copies in eumemic's carrier-skeleton package. +The prime witness and determinant code comes from DreamingOfClouds through PR315. +The selected R420 bit word is eumemic's PR543 contribution, with Anthropic Claude assistance. +The new fixture contains the unchanged export of that word. +All original files and their notices remain unchanged. + +The current selected composition combines that bit supplier with the PR626 +owner allocation by Chafik Boukhalfa, on Jeremy Kothe's PR622/623 suppliers. +This package checks only the bit Gram stage and does not claim those other results. +The retained package notices give the complete earlier construction lineage. + +Related work includes Richard Hoekstra's PR239 dual-Gram acceleration, +Aman's PR367 frame-rank and canonical-basis optimization, and Aman's PR452 +shared-prefix replay work. PR154 improves concurrency and binary frame algebra. +Concurrent PR662, PR667, and PR672 optimize other exact verification workloads. +These contributions are credited context, not code dependencies. diff --git a/research/gram-prefix-performance/PROOF.md b/research/gram-prefix-performance/PROOF.md new file mode 100644 index 0000000000..6304c7e556 --- /dev/null +++ b/research/gram-prefix-performance/PROOF.md @@ -0,0 +1,108 @@ +# Exact determinant-prefix reuse + +## Claim and contract + +`PrefixDeterminant(reference_det)` returns the exact determinant of a square integer matrix. +The claim assumes that `reference_det` returns an exact determinant when the fallback calls it. +The selected reference is `det` in the pinned `prime_witnesses.py` source. +The kernel accepts built-in Python integers and rejects other scalar types. +The empty matrix has determinant 1. + +This result concerns determinant evaluation only. +It does not prove the surrounding mathematical theorem or change its parameters. +It does not independently verify the selected word, frame generation, or prime range. + +## Identity over the integers + +Let `A` be an `n` by `n` integer matrix. +Let `D_r` denote its leading principal determinant of order `r`, with `D_0 = 1`. +For indices `i,j >= k`, define the bordered minor: + +```text +P_k(i,j) = det A[(0,...,k-1,i), (0,...,k-1,j)]. +P_0(i,j) = A[i,j]. +P_k(k,k) = D_(k+1). +``` + +The determinant identity of Sylvester gives: + +```text +D_k P_(k+1)(i,j) + = D_(k+1) P_k(i,j) - P_k(i,k) P_k(k,j), + for i,j > k. +``` + +One proof first assumes that the leading block of order `k` is invertible over the rationals. +Expand the bordered minors through the Schur complement of that block. +The displayed identity becomes the formula for a determinant of order 2. +Both sides are polynomials in the entries of `A`. +The polynomial identity therefore holds for every integer matrix, including singular matrices. +For `k=0`, it is directly the same formula with the empty determinant equal to 1. + +## Elimination invariant + +Before elimination step `k`, each active entry `work[i][j]` equals `P_k(i,j)`. +The variable `previous` equals `D_k`. +The initialization satisfies these statements at `k=0`. +The pivot equals `D_(k+1)`. + +When the pivot is nonzero, the kernel applies the displayed identity to each trailing entry. +The divisor `D_k` is nonzero because each earlier pivot is nonzero. +The identity proves that each division has zero remainder and preserves the invariant. +The kernel checks divisibility with `divmod` and raises `ArithmeticError` for a nonzero remainder. +It also explicitly rejects a zero divisor. +These checks remain active under `python -O`. + +The kernel records each pivot as the corresponding leading principal determinant. +After the final elimination, `work[n-1][n-1]` equals `D_n`. +The kernel records this value as well. +For `n=1`, the only entry directly equals the determinant. +This argument does not require symmetry, positive definiteness, or positive entries. +Negative pivots and negative determinants cause no change to the identity. + +## Zero pivots and singular matrices + +A zero elimination pivot remains a valid value of its leading principal determinant. +However, subsequent elimination can require division by that zero value. +The kernel stops before this can occur. +It calls the supplied reference on a separate copy of the full requested matrix. +It retains only the leading minors already proved by the invariant and the returned full determinant. +It does not infer any later leading minor from the interrupted pass. + +The fallback covers nonsingular matrices with a singular leading block, including matrices that require row swaps. +It also covers singular matrices with an early zero pivot. +A zero final entry needs no further elimination or division and directly gives determinant zero. + +## Cache validity and bounds + +Each key is an immutable tuple of rows containing every entry of one matrix. +Python dictionary lookup checks full key equality, even when hashes collide. +Thus, a hit identifies precisely the matrix whose determinant the kernel records. +The kernel does not use mutable object identities as keys. +Later mutation of the caller's matrix cannot create a stale hit. +The kernel also leaves the caller's matrix unchanged. + +A miss discards the previous cache and creates one cache for the requested matrix. +A hit retains this cache, so requests for successive prefixes reuse the same elimination. +The cache stores at most `n` determinants after a miss of dimension `n`. +The empty matrix creates no cache entries. +An interrupted pass stores fewer prefixes plus the full determinant, still at most `n` entries. + +The bound counts entries, not bytes. +The complete prefix keys contain at most a constant times `n^3` scalar references in total. +Integer bit lengths and arithmetic costs depend on the input. +The uncached elimination uses at most a constant times `n^3` exact arithmetic operations. +This statement is not a constant-time or unit-bit-cost claim. + +## Scope of equivalence + +For each supported input, a cache hit returns a previously established exact determinant. +On a miss, the invariant proves the result unless the reference handles a zero pivot. +Under the reference contract, that fallback also returns the exact determinant. +These cases establish equivalence to the reference for square integer inputs. + +The optimization helps when the caller requests a full matrix before its leading prefixes. +The selected Gram checker uses this order with its positivity option. +The kernel does not change rank, annihilator, factor, residual, or positivity checks. +Correct determinant values alone do not establish the correctness of those surrounding checks. +The cache and counters support sequential calls; the implementation makes no thread-safety claim. diff --git a/research/gram-prefix-performance/README.md b/research/gram-prefix-performance/README.md new file mode 100644 index 0000000000..8f92b29a52 --- /dev/null +++ b/research/gram-prefix-performance/README.md @@ -0,0 +1,139 @@ +# Exact Gram prefix reuse + +This optional adapter reuses exact leading principal determinants in the selected R420 bit Gram checker. +The checker first asks for a full determinant, then for each leading principal determinant. +One Bareiss pass supplies those values. +A zero pivot invokes the original pivoted determinant on the full matrix. + +**Status: tooling improvement; no new kappa.** +The exact base is `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +The selected conditional result at that base is `0.001635527380375392`. +This contribution preserves the selected certificate, frozen sources, default commands, and `upstream/`. + +## Reproduce + +Use Python 3.11 or newer and a full repository checkout. +All dependencies belong to the Python standard library. +The benchmark uses the POSIX `resource` module on macOS or Linux. +No network connection is required. + +```sh +python3 -B research/gram-prefix-performance/verify.py +python3 -B research/gram-prefix-performance/test_kernel.py --mutations +python3 -B research/gram-prefix-performance/benchmark.py --pairs 31 --out /tmp/gram-prefix-result.json +``` + +Use a fresh benchmark output path. +Expected results: 23 passing tests, four detected kernel mutations, and `PASS_GRAM_PREFIX_BENCHMARK`. +The first command prints `PASS_GRAM_PREFIX_VERIFICATION`. +The mutation command reports the passing baseline before the four rejected mutations. + +Run either complete checker directly with the same pinned frame fixture: + +```sh +python3 -B research/gram-prefix-performance/adapter.py --engine reference +python3 -B research/gram-prefix-performance/adapter.py --engine prefix +python3 -B research/gram-prefix-performance/adapter.py --engine compare --trace --out /tmp/gram-prefix-trace.json +``` + +All three print: + +```text +PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1} +``` + +## Exact coverage + +The adapter checks source hashes before execution. +It inserts one assignment after the pinned checker imports `prime_witnesses.py`. +That assignment replaces only `pw.det`. +The checker retains every frame, rank, annihilator, prime-witness, residual, and positivity check. +The reference mode uses the original determinant. +The comparison mode compares every requested determinant with that original. + +All 3,360 determinant requests on the selected frames agree exactly. +Their ordered matrix/value transcript has SHA-256: + +```text +441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef +``` + +The fixture contains all 672 exported frames, including frame zero. +The verification command regenerates it from the pinned R420 word through the original exporter. +It compares the full uncompressed payload byte for byte. +Compressed container bytes do not determine mathematical equality. +`SOURCE.json` binds the word, exporter, checker, determinant source, and fixture payload. + +The kernel suite includes an independent permutation determinant oracle through dimension five. +It exhausts 530 binary matrices of dimensions one through three. +Seed 88 also gives 240 small signed matrices, 108 positive Gram matrices, and 144 larger matrices through dimension sixteen. +Larger cases use the original determinant and independent determinant identities. +Named cases cover negative pivots, singular leading blocks, singular matrices, large integers, and mutable inputs. + +The four kernel mutations corrupt signs, cached minor values, cache keys, or zero-pivot handling. +Each mutation causes assertion failures, without execution errors. +Package controls reject altered dimensions, dependent bases, wrong annihilators, oversized prime residuals, singular Gram matrices, and failed positivity. +The tested rejection arguments agree across all three engines. +Source tampering, disabled checker assertions, and existing output paths also fail. +The retained `--new` frame filter produces matching results in all engines. + +[PROOF.md](PROOF.md) gives the integer identity and cache argument. +The proof assumes an exact reference determinant for the fallback. +Finite tests corroborate the implementation; they are not a formal proof of the multiplication theorem. + +## Measurements + +Each evidence file records 31 alternating fresh-process pairs. +The first runs measure wall time only. +The follow-up runs also measure child user and system CPU time. +Both sets remain in `evidence/`; no samples are removed. +Both engines receive identical exported frames. +Every measured complete process must produce the same output. +Each separate determinant batch follows the actual 3,360 requests captured from the checker. +Every measured batch compares its full result list with the original afterward. +A fresh kernel starts each batch, so no previous batch supplies cached results. + +| Python | Run | Full process wall, reference → prefix | Child CPU, reference → prefix | Determinant batch, reference → prefix | +|---|---|---:|---:|---:| +| 3.13 | First | 113.79 → 115.15 ms | Not collected | 19.49 → 9.69 ms (2.01×) | +| 3.13 | CPU follow-up | 161.59 → 148.07 ms | 150.98 → 138.00 ms | 21.61 → 11.11 ms (1.94×) | +| 3.14 | First | 206.13 → 246.14 ms | Not collected | 18.83 → 10.16 ms (1.85×) | +| 3.14 | CPU follow-up | 142.55 → 147.88 ms | 135.07 → 138.29 ms | 15.31 → 8.30 ms (1.84×) | + +The determinant batches improve consistently. +Complete-process wall results vary in direction, so no reliable end-to-end wall speedup is claimed. + +Complete process timings include adapter startup and source/fixture validation. +The determinant batches exclude imports, input collection, and result comparison. +Filesystem caches are not flushed. +Other applications can affect local timings; these are paired medians, not guaranteed speedups. +The benchmark has no timing threshold and retains every sample. +`wall-only-benchmark.py.txt` preserves the first measurement script. +Its hash matches the earlier receipts; the current script matches the CPU receipts. + +These measurements do not include word construction, record export, full supplier replay, or integer multiplication. +No full-frontier speedup follows from this small stage measurement. + +## Review map and limits + +- `kernel.py`: exact determinant implementation with a bounded prefix cache. +- `adapter.py`: source-pinned execution of the retained checker. +- `test_kernel.py`: independent arithmetic tests and kernel mutations. +- `test_package.py`: full-frame reproduction, equivalence, and package controls. +- `benchmark.py`: reproducible paired measurements with source hashes. +- `evidence/`: raw local measurements and validation receipts. +- `CLAIM.md`: assignment, candidates, and overlap check. +- `NOTICE.md`: predecessor attribution, license, and AI disclosure. + +The cache stores at most one requested matrix's leading prefixes. +It uses exact immutable matrix values and does not retain successful checker results. +The public kernel accepts square matrices of built-in integers. +It does not support arbitrary scalar types or concurrent calls on one instance. +The adapter rejects optimized Python because the retained checker uses assertions. +The kernel's arithmetic guards remain active under optimized Python. + +The local checks cover only this optional adapter and the pinned Gram stage. +The full `make verify`, supplier cold replay, assembly, and Lean checks are not rerun for this addition. +Dedicated Linux CI is supplied; its remote status remains separate from local results. +All inherited compiler, hosting, precision, tape, and analytic assumptions remain. +Direct activation in a frozen production package requires separate integration and affected source-pin updates. diff --git a/research/gram-prefix-performance/SOURCE.json b/research/gram-prefix-performance/SOURCE.json new file mode 100644 index 0000000000..e9e152e11a --- /dev/null +++ b/research/gram-prefix-performance/SOURCE.json @@ -0,0 +1,12 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "assignment_seed": 88, + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-r420/data/bitE8mut-r420.json.gz": "9721a3819efd68307f66f00d84a952eb28eb7c3ad2ce79653ce295c98a764784" + }, + "frames_payload_sha256": "46f49b700fa3ecd59ba6815b58234c0b67b94360f7af52a718b275b8198c1c74", + "frames": 672 +} diff --git a/research/gram-prefix-performance/adapter.py b/research/gram-prefix-performance/adapter.py new file mode 100644 index 0000000000..55e0300b75 --- /dev/null +++ b/research/gram-prefix-performance/adapter.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Run the pinned Gram checker with an optional exact determinant adapter.""" +import argparse +import contextlib +import gzip +import hashlib +import io +import json +from pathlib import Path +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +CHECKER = 'research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py' +ANCHOR = 's.loader.exec_module(pw)' + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def source_check(root=ROOT): + pins = json.loads((HERE / 'SOURCE.json').read_text()) + for name, expected in pins['source_sha256'].items(): + require(hashlib.sha256((root / name).read_bytes()).hexdigest() == expected, + 'source pin mismatch: ' + name) + payload = gzip.decompress((HERE / 'frames.json.gz').read_bytes()) + require(hashlib.sha256(payload).hexdigest() == pins['frames_payload_sha256'], + 'frame payload mismatch') + return pins, payload + + +def execute(engine, frames, gram='e8ham', h=8, positive=True, trace=False, old=None, requests=None): + require(not sys.flags.optimize, 'enabled assertions required by the pinned checker') + require(engine in ('reference', 'prefix', 'compare'), 'unknown determinant engine') + source_check() + from kernel import PrefixDeterminant + code = (ROOT / CHECKER).read_text() + require(code.count(ANCHOR) == 1, 'unique pinned insertion point') + digester = hashlib.sha256() + calls = 0 + kernel = None + + def install(original): + nonlocal kernel + kernel = PrefixDeterminant(original) if engine != 'reference' else None + target = original if kernel is None else kernel + if not trace and engine != 'compare' and requests is None: + return target + + def checked(matrix): + nonlocal calls + value = target(matrix) + if engine == 'compare': + require(value == original(matrix), 'determinant differs from reference') + calls += 1 + if requests is not None: + requests.append([row[:] for row in matrix]) + digester.update(json.dumps([matrix, value], separators=(',', ':')).encode() + b'\n') + return value + return checked + + # The only source alteration installs the chosen determinant implementation. + # All checker loops, assertions, rank and witness code execute unchanged. + code = code.replace(ANCHOR, ANCHOR + '\npw.det = __install(pw.det)', 1) + argv = [str(ROOT / CHECKER), str(frames), '--gram', gram, '--h', str(h)] + if positive: + argv.append('--positive') + if old is not None: + argv.extend(['--new', str(old)]) + saved_argv = sys.argv + output = io.StringIO() + try: + sys.argv = argv + with contextlib.redirect_stdout(output): + exec(compile(code, str(ROOT / CHECKER), 'exec'), + {'__name__': '__main__', '__file__': str(ROOT / CHECKER), '__install': install}) + finally: + sys.argv = saved_argv + return dict(stdout=output.getvalue(), determinant_calls=calls if trace or engine == 'compare' else None, + determinant_trace_sha256=digester.hexdigest() if trace or engine == 'compare' else None, + kernel_stats=dict(kernel.stats) if kernel is not None else None) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--engine', choices=['reference', 'prefix', 'compare'], default='prefix') + ap.add_argument('--frames', type=Path, help='directory with frames.json; defaults to the pinned R420 fixture') + ap.add_argument('--gram', choices=['e8ham', 'triple9'], default='e8ham') + ap.add_argument('--h', type=int, default=8) + ap.add_argument('--no-positive', action='store_true') + ap.add_argument('--new', type=Path) + ap.add_argument('--trace', action='store_true') + ap.add_argument('--out', type=Path) + args = ap.parse_args() + require(not sys.flags.optimize, 'enabled assertions required by the pinned checker') + if args.out: + require(not args.out.exists(), 'output already exists') + _, payload = source_check() + with tempfile.TemporaryDirectory(prefix='gram-prefix-') as temp: + frames = args.frames or Path(temp) + if args.frames is None: + (frames / 'frames.json').write_bytes(payload) + result = execute(args.engine, frames, args.gram, args.h, not args.no_positive, args.trace, args.new) + if args.out: + with args.out.open('x') as stream: + json.dump(result, stream, indent=2) + stream.write('\n') + print(result['stdout'], end='') + + +if __name__ == '__main__': + main() diff --git a/research/gram-prefix-performance/benchmark.py b/research/gram-prefix-performance/benchmark.py new file mode 100644 index 0000000000..3ea8486dc4 --- /dev/null +++ b/research/gram-prefix-performance/benchmark.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 +"""Alternate fresh-process complete Gram checks on identical R420 inputs.""" +import argparse +import hashlib +import json +import importlib.util +from pathlib import Path +import platform +import resource +import statistics +import subprocess +import sys +import tempfile +import time + +import adapter + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--pairs', type=int, default=15) + ap.add_argument('--out', type=Path, required=True) + args = ap.parse_args() + adapter.require(not sys.flags.optimize, 'enabled assertions required') + adapter.require(args.pairs >= 3, 'at least three pairs required') + adapter.require(not args.out.exists(), 'output already exists') + pins, payload = adapter.source_check() + samples = [] + kernel_samples = [] + with tempfile.TemporaryDirectory(prefix='gram-prefix-benchmark-') as tmp: + frames = Path(tmp) + (frames / 'frames.json').write_bytes(payload) + # Untimed exact comparison covers every actual determinant call first. + requests = [] + reference = adapter.execute('reference', frames, trace=True, requests=requests) + compared = adapter.execute('compare', frames, trace=True) + for key in ('stdout', 'determinant_calls', 'determinant_trace_sha256'): + adapter.require(reference[key] == compared[key], 'reference mismatch: ' + key) + # Seed 88 chooses reference first; order reverses in each following pair. + for pair in range(args.pairs): + engines = ('reference', 'prefix') if (88 + pair) % 2 == 0 else ('prefix', 'reference') + row = {'pair': pair, 'order': list(engines)} + for engine in engines: + command = [sys.executable, '-B', str(adapter.HERE / 'adapter.py'), + '--frames', str(frames), '--engine', engine] + cpu_start = resource.getrusage(resource.RUSAGE_CHILDREN) + start = time.perf_counter() + process = subprocess.run(command, capture_output=True, text=True) + seconds = time.perf_counter() - start + cpu_end = resource.getrusage(resource.RUSAGE_CHILDREN) + row[engine + '_cpu_seconds'] = ((cpu_end.ru_utime - cpu_start.ru_utime) + + (cpu_end.ru_stime - cpu_start.ru_stime)) + adapter.require(process.returncode == 0, process.stderr) + adapter.require(process.stdout == reference['stdout'], 'complete checker output changed') + row[engine + '_seconds'] = seconds + row[engine + '_stdout_sha256'] = hashlib.sha256(process.stdout.encode()).hexdigest() + samples.append(row) + # A separate in-process workload uses the exact recorded request order. + # Input loading, imports, equality checks and hashing are outside timing. + from kernel import PrefixDeterminant + path = adapter.ROOT / 'research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py' + spec = importlib.util.spec_from_file_location('gram_benchmark_reference', path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + expected = [module.det(matrix) for matrix in requests] + for pair in range(args.pairs): + engines = ('reference', 'prefix') if (88 + pair) % 2 == 0 else ('prefix', 'reference') + row = {'pair': pair, 'order': list(engines)} + for engine in engines: + determinant = module.det if engine == 'reference' else PrefixDeterminant(module.det) + start = time.perf_counter() + actual = [determinant(matrix) for matrix in requests] + row[engine + '_seconds'] = time.perf_counter() - start + adapter.require(actual == expected, 'timed determinant stream changed') + kernel_samples.append(row) + medians = {engine: statistics.median(row[engine + '_seconds'] for row in samples) + for engine in ('reference', 'prefix')} + cpu_medians = {engine: statistics.median(row[engine + '_cpu_seconds'] for row in samples) + for engine in ('reference', 'prefix')} + kernel_medians = {engine: statistics.median(row[engine + '_seconds'] for row in kernel_samples) + for engine in ('reference', 'prefix')} + own_sources = {p.name: hashlib.sha256(p.read_bytes()).hexdigest() + for p in sorted(adapter.HERE.glob('*.py'))} + result = dict(status='PASS_GRAM_PREFIX_BENCHMARK', + scope='Complete 672-frame Gram checker including adapter startup and source/fixture validation, fresh processes, existing exported inputs; no exporter or full frontier replay timing.', + environment=dict(python=sys.version, executable=sys.executable, platform=platform.platform(), + machine=platform.machine(), filesystem_caches_flushed=False), + source=pins, package_python_sha256=own_sources, + reference_receipt=reference, compared_receipt=compared, + samples=samples, median_seconds=medians, + median_child_cpu_seconds=cpu_medians, cpu_speedup=cpu_medians['reference']/cpu_medians['prefix'], + median_pair_wall_speedup=statistics.median(row['reference_seconds']/row['prefix_seconds'] for row in samples), + determinant_stream=dict(requests=len(requests), samples=kernel_samples, + median_seconds=kernel_medians, speedup=kernel_medians['reference']/kernel_medians['prefix'], + result_sha256=hashlib.sha256(json.dumps(expected, separators=(',', ':')).encode()).hexdigest()), + speedup=medians['reference']/medians['prefix'], + wall_time_reduction=1-medians['prefix']/medians['reference']) + with args.out.open('x') as stream: + json.dump(result, stream, indent=2) + stream.write('\n') + print('PASS_GRAM_PREFIX_BENCHMARK', json.dumps(medians), 'speedup', result['speedup']) + + +if __name__ == '__main__': + main() diff --git a/research/gram-prefix-performance/evidence/VALIDATION.json b/research/gram-prefix-performance/evidence/VALIDATION.json new file mode 100644 index 0000000000..31c8f2e554 --- /dev/null +++ b/research/gram-prefix-performance/evidence/VALIDATION.json @@ -0,0 +1,36 @@ +{ + "status": "PASS_SCOPED_GRAM_PREFIX_VALIDATION", + "recorded_at": "2026-10-13T04:33:28.602114+00:00", + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "local_checks": { + "python313_verification": "23 tests passed", + "python314_verification": "23 tests passed", + "kernel_mutants": "four detected, zero execution errors", + "python314_optimized_kernel": "16 tests passed", + "minimal_offline_replay": "23 tests passed from a path with spaces, only four pinned source files and this package", + "selected_source_inventory": "PASS selected record, exact kappa, original source inventory and proof supplement", + "whitespace": "git diff --cached --check passed" + }, + "not_run": [ + "make verify", + "full supplier cold replay", + "full assembly replay", + "Lean" + ], + "remote_ci": "Dedicated workflow supplied; no remote pass claimed.", + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-r420/data/bitE8mut-r420.json.gz": "9721a3819efd68307f66f00d84a952eb28eb7c3ad2ce79653ce295c98a764784" + }, + "package_python_sha256": { + "adapter.py": "d666868eaa53e1f66a002ed211cbd9caadee63da229fed315534d1172e525fd6", + "benchmark.py": "58349125e19e5598c6844c69f87c34fafe44149e083f1ec5624a62dfe51fcdfd", + "kernel.py": "2e1701099bffeb84d28add001a7a46fd6457ef113aea13be8d030aa85e0e0008", + "test_kernel.py": "562ce0bed7c455d618cfdaaa501125eea59f68fe61a840cbcd006bd23e906b73", + "test_package.py": "4e5e8bdbcca458450cfe45ae8ed90b19d2bccb8967f0b53d8f0c1971da69caaa", + "verify.py": "d4564c8323129cc94ba25ab856dc7aab9bf99b8468e1d47bb17bf2b4b5ba77eb" + }, + "scope": "Exact determinant optimization and pinned finite Gram stage only. No new kappa, full-check wall speedup or complete multiplication theorem claimed." +} diff --git a/research/gram-prefix-performance/evidence/kernel-optimized-python314.txt b/research/gram-prefix-performance/evidence/kernel-optimized-python314.txt new file mode 100644 index 0000000000..b2cd7501b6 --- /dev/null +++ b/research/gram-prefix-performance/evidence/kernel-optimized-python314.txt @@ -0,0 +1,21 @@ +test_all_small_binary_matrices (__main__.PrefixDeterminantTests.test_all_small_binary_matrices) ... ok +test_cached_input_is_value_sensitive_and_copied (__main__.PrefixDeterminantTests.test_cached_input_is_value_sensitive_and_copied) ... ok +test_determinant_identities_on_larger_matrices (__main__.PrefixDeterminantTests.test_determinant_identities_on_larger_matrices) ... ok +test_empty_scalar_and_tuple_inputs (__main__.PrefixDeterminantTests.test_empty_scalar_and_tuple_inputs) ... ok +test_hand_computable_determinants (__main__.PrefixDeterminantTests.test_hand_computable_determinants) ... ok +test_integers_beyond_machine_precision (__main__.PrefixDeterminantTests.test_integers_beyond_machine_precision) ... ok +test_interleaved_matrices_and_out_of_order_prefixes (__main__.PrefixDeterminantTests.test_interleaved_matrices_and_out_of_order_prefixes) ... ok +test_negative_pivots_and_indefinite_forms (__main__.PrefixDeterminantTests.test_negative_pivots_and_indefinite_forms) ... ok +test_positive_definite_gram_prefixes (__main__.PrefixDeterminantTests.test_positive_definite_gram_prefixes) ... ok +test_previous_matrix_cache_stays_bounded (__main__.PrefixDeterminantTests.test_previous_matrix_cache_stays_bounded) ... ok +test_rejects_invalid_shapes_and_noninteger_entries (__main__.PrefixDeterminantTests.test_rejects_invalid_shapes_and_noninteger_entries) ... ok +test_seed88_larger_matrices_against_original (__main__.PrefixDeterminantTests.test_seed88_larger_matrices_against_original) ... ok +test_seed88_small_signed_matrices (__main__.PrefixDeterminantTests.test_seed88_small_signed_matrices) ... ok +test_singular_and_repeated_rows (__main__.PrefixDeterminantTests.test_singular_and_repeated_rows) ... ok +test_zero_leading_minors_with_nonsingular_full_matrix (__main__.PrefixDeterminantTests.test_zero_leading_minors_with_nonsingular_full_matrix) ... ok +test_zero_pivot_delegates_to_original (__main__.PrefixDeterminantTests.test_zero_pivot_delegates_to_original) ... ok + +---------------------------------------------------------------------- +Ran 16 tests in 0.559s + +OK diff --git a/research/gram-prefix-performance/evidence/macos-python313-cpu.json b/research/gram-prefix-performance/evidence/macos-python313-cpu.json new file mode 100644 index 0000000000..b7afc3e1d3 --- /dev/null +++ b/research/gram-prefix-performance/evidence/macos-python313-cpu.json @@ -0,0 +1,754 @@ +{ + "status": "PASS_GRAM_PREFIX_BENCHMARK", + "scope": "Complete 672-frame Gram checker including adapter startup and source/fixture validation, fresh processes, existing exported inputs; no exporter or full frontier replay timing.", + "environment": { + "python": "3.13.11 (main, Dec 5 2025, 16:06:33) [Clang 17.0.0 (clang-1700.6.3.2)]", + "executable": "/opt/homebrew/opt/python@3.13/bin/python3.13", + "platform": "macOS-27.2-arm64-arm-64bit-Mach-O", + "machine": "arm64", + "filesystem_caches_flushed": false + }, + "source": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "assignment_seed": 88, + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-r420/data/bitE8mut-r420.json.gz": "9721a3819efd68307f66f00d84a952eb28eb7c3ad2ce79653ce295c98a764784" + }, + "frames_payload_sha256": "46f49b700fa3ecd59ba6815b58234c0b67b94360f7af52a718b275b8198c1c74", + "frames": 672 + }, + "package_python_sha256": { + "adapter.py": "d666868eaa53e1f66a002ed211cbd9caadee63da229fed315534d1172e525fd6", + "benchmark.py": "58349125e19e5598c6844c69f87c34fafe44149e083f1ec5624a62dfe51fcdfd", + "kernel.py": "2e1701099bffeb84d28add001a7a46fd6457ef113aea13be8d030aa85e0e0008", + "test_kernel.py": "562ce0bed7c455d618cfdaaa501125eea59f68fe61a840cbcd006bd23e906b73", + "test_package.py": "4e5e8bdbcca458450cfe45ae8ed90b19d2bccb8967f0b53d8f0c1971da69caaa", + "verify.py": "d4564c8323129cc94ba25ab856dc7aab9bf99b8468e1d47bb17bf2b4b5ba77eb" + }, + "reference_receipt": { + "stdout": "PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1}\n", + "determinant_calls": 3360, + "determinant_trace_sha256": "441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef", + "kernel_stats": null + }, + "compared_receipt": { + "stdout": "PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1}\n", + "determinant_calls": 3360, + "determinant_trace_sha256": "441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef", + "kernel_stats": { + "calls": 3360, + "hits": 3186, + "fallbacks": 0 + } + }, + "samples": [ + { + "pair": 0, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.200035, + "reference_seconds": 0.24090179100312525, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.185853, + "prefix_seconds": 0.2336875830005738, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 1, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.17587799999999998, + "prefix_seconds": 0.20719012500194367, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.19374400000000006, + "reference_seconds": 0.22625554099795409, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 2, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.1947409999999999, + "reference_seconds": 0.22756933300115634, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.17903200000000008, + "prefix_seconds": 0.2093612500029849, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 3, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.16378299999999996, + "prefix_seconds": 0.18392750000202795, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.15246099999999996, + "reference_seconds": 0.17102633300237358, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 4, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.1552150000000001, + "reference_seconds": 0.16623299999628216, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.15554099999999998, + "prefix_seconds": 0.18406237500312272, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 5, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.16182099999999994, + "prefix_seconds": 0.18816283300111536, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.177211, + "reference_seconds": 0.21108762500080047, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 6, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.20353300000000002, + "reference_seconds": 0.390453374995559, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.1653579999999999, + "prefix_seconds": 0.22183358300389955, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 7, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.15531800000000023, + "prefix_seconds": 0.17424683299759636, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.16436700000000004, + "reference_seconds": 0.17798683300497942, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 8, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.16618999999999973, + "reference_seconds": 0.1782426249992568, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.15570700000000037, + "prefix_seconds": 0.16957874999934575, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 9, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.13118799999999953, + "prefix_seconds": 0.13913987500563962, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.15098400000000023, + "reference_seconds": 0.1593789159960579, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 10, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.15438799999999975, + "reference_seconds": 0.16257166700233938, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.14132500000000037, + "prefix_seconds": 0.15004654199583456, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 11, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.1538419999999997, + "prefix_seconds": 0.16666491700016195, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.17743500000000023, + "reference_seconds": 0.20052162500360282, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 12, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.14586199999999971, + "reference_seconds": 0.155509374999383, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.13127600000000006, + "prefix_seconds": 0.14286004200403113, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 13, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.15469100000000036, + "prefix_seconds": 0.1847027089970652, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.13181099999999957, + "reference_seconds": 0.13873254200007068, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 14, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.13277800000000006, + "reference_seconds": 0.1475231669974164, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.12967700000000026, + "prefix_seconds": 0.14394950000132667, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 15, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.12020999999999982, + "prefix_seconds": 0.12637687499955064, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.11618100000000053, + "reference_seconds": 0.12181674999737879, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 16, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.11361999999999928, + "reference_seconds": 0.11789899999712361, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.09910599999999992, + "prefix_seconds": 0.1034741249968647, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 17, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.0977980000000005, + "prefix_seconds": 0.10157908299879637, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.10464799999999963, + "reference_seconds": 0.10847487499995623, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 18, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.11711200000000033, + "reference_seconds": 0.12512629100092454, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.13346199999999975, + "prefix_seconds": 0.1449416250034119, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 19, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.1090840000000004, + "prefix_seconds": 0.11485254199942574, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.10901200000000011, + "reference_seconds": 0.11378612500266172, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 20, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.10888799999999965, + "reference_seconds": 0.11324462500488153, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.0994480000000002, + "prefix_seconds": 0.10330237499874784, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 21, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.09735799999999983, + "prefix_seconds": 0.10108054099691799, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.11078800000000033, + "reference_seconds": 0.11661474999709753, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 22, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.10879399999999939, + "reference_seconds": 0.11369116700370796, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.09296099999999985, + "prefix_seconds": 0.096982916998968, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 23, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.09318700000000057, + "prefix_seconds": 0.09826883399364306, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.09926299999999944, + "reference_seconds": 0.10352974999841535, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 24, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.11193199999999992, + "reference_seconds": 0.1207892919992446, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.1031790000000008, + "prefix_seconds": 0.10845908299961593, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 25, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.11142899999999956, + "prefix_seconds": 0.1181383340008324, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.15235500000000002, + "reference_seconds": 0.17552974999853177, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 26, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.1541110000000001, + "reference_seconds": 0.1807963750034105, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.13551199999999985, + "prefix_seconds": 0.14685587499843678, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 27, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.13800100000000048, + "prefix_seconds": 0.14807250000012573, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.12620099999999934, + "reference_seconds": 0.13203620800049976, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 28, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.16045300000000018, + "reference_seconds": 0.17334595799911767, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.1581370000000002, + "prefix_seconds": 0.1730454579956131, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 29, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.15197000000000016, + "prefix_seconds": 0.16929974999948172, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.1588619999999994, + "reference_seconds": 0.18146112499380251, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 30, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.14896500000000001, + "reference_seconds": 0.16159458400215954, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.14925400000000044, + "prefix_seconds": 0.1613149170007091, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + } + ], + "median_seconds": { + "reference": 0.16159458400215954, + "prefix": 0.14807250000012573 + }, + "median_child_cpu_seconds": { + "reference": 0.15098400000000023, + "prefix": 0.13800100000000048 + }, + "cpu_speedup": 1.0940790284128354, + "median_pair_wall_speedup": 1.0718333901518344, + "determinant_stream": { + "requests": 3360, + "samples": [ + { + "pair": 0, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.021604667002975475, + "prefix_seconds": 0.011424707998230588 + }, + { + "pair": 1, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.01134220799576724, + "reference_seconds": 0.021607458998914808 + }, + { + "pair": 2, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.023437584000930656, + "prefix_seconds": 0.01384012500056997 + }, + { + "pair": 3, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.012242083001183346, + "reference_seconds": 0.021738917006587144 + }, + { + "pair": 4, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.021852125006262213, + "prefix_seconds": 0.012511125001765322 + }, + { + "pair": 5, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.011111290994449519, + "reference_seconds": 0.021440750002511777 + }, + { + "pair": 6, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.022518584002682474, + "prefix_seconds": 0.010807334001583513 + }, + { + "pair": 7, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.011525666996021755, + "reference_seconds": 0.022032375003618654 + }, + { + "pair": 8, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.02232695800194051, + "prefix_seconds": 0.010828709004272241 + }, + { + "pair": 9, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.012145666994911153, + "reference_seconds": 0.024617124996439088 + }, + { + "pair": 10, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.024030250002397224, + "prefix_seconds": 0.012539916002424434 + }, + { + "pair": 11, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.01524687500204891, + "reference_seconds": 0.022909125000296626 + }, + { + "pair": 12, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.024191374999645632, + "prefix_seconds": 0.011518958999658935 + }, + { + "pair": 13, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.01268687500123633, + "reference_seconds": 0.02368241700605722 + }, + { + "pair": 14, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.021856667000974994, + "prefix_seconds": 0.010667833004845306 + }, + { + "pair": 15, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.010927792005531956, + "reference_seconds": 0.022068041005695704 + }, + { + "pair": 16, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.021048958995379508, + "prefix_seconds": 0.01076945800014073 + }, + { + "pair": 17, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.01055600000108825, + "reference_seconds": 0.02085333300055936 + }, + { + "pair": 18, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.02077679200010607, + "prefix_seconds": 0.01092354200227419 + }, + { + "pair": 19, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.010278292000293732, + "reference_seconds": 0.021544666000409052 + }, + { + "pair": 20, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.021981375000905246, + "prefix_seconds": 0.012936416998854838 + }, + { + "pair": 21, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.012496874995122198, + "reference_seconds": 0.02199754200410098 + }, + { + "pair": 22, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.018723916000453755, + "prefix_seconds": 0.011508290997880977 + }, + { + "pair": 23, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.01278041600016877, + "reference_seconds": 0.020120833003602456 + }, + { + "pair": 24, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01843774999724701, + "prefix_seconds": 0.009120250004343688 + }, + { + "pair": 25, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.00999466599751031, + "reference_seconds": 0.02036595899699023 + }, + { + "pair": 26, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.02043279099598294, + "prefix_seconds": 0.009525083005428314 + }, + { + "pair": 27, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009454915998503566, + "reference_seconds": 0.018198958001448773 + }, + { + "pair": 28, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.018163958004151937, + "prefix_seconds": 0.009078374998352956 + }, + { + "pair": 29, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009295625000959262, + "reference_seconds": 0.018299749994184822 + }, + { + "pair": 30, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01819137499842327, + "prefix_seconds": 0.00910245800332632 + } + ], + "median_seconds": { + "reference": 0.021607458998914808, + "prefix": 0.011111290994449519 + }, + "speedup": 1.944639827154963, + "result_sha256": "12344fac32167535a72a2b5d79b5755f925af513d16aae5e71aefdf4a43b7e1a" + }, + "speedup": 1.0913206976448857, + "wall_time_reduction": 0.08367906687920368 +} diff --git a/research/gram-prefix-performance/evidence/macos-python313.json b/research/gram-prefix-performance/evidence/macos-python313.json new file mode 100644 index 0000000000..c4921f5094 --- /dev/null +++ b/research/gram-prefix-performance/evidence/macos-python313.json @@ -0,0 +1,686 @@ +{ + "status": "PASS_GRAM_PREFIX_BENCHMARK", + "scope": "Complete 672-frame Gram checker including adapter startup and source/fixture validation, fresh processes, existing exported inputs; no exporter or full frontier replay timing.", + "environment": { + "python": "3.13.11 (main, Dec 5 2025, 16:06:33) [Clang 17.0.0 (clang-1700.6.3.2)]", + "executable": "/opt/homebrew/opt/python@3.13/bin/python3.13", + "platform": "macOS-27.2-arm64-arm-64bit-Mach-O", + "machine": "arm64", + "filesystem_caches_flushed": false + }, + "source": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "assignment_seed": 88, + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-r420/data/bitE8mut-r420.json.gz": "9721a3819efd68307f66f00d84a952eb28eb7c3ad2ce79653ce295c98a764784" + }, + "frames_payload_sha256": "46f49b700fa3ecd59ba6815b58234c0b67b94360f7af52a718b275b8198c1c74", + "frames": 672 + }, + "package_python_sha256": { + "adapter.py": "d666868eaa53e1f66a002ed211cbd9caadee63da229fed315534d1172e525fd6", + "benchmark.py": "37ebd83b85ef42767a2c6e83d1ffabc49ef0fc4066efb2e55a45475ca9bf3447", + "kernel.py": "2e1701099bffeb84d28add001a7a46fd6457ef113aea13be8d030aa85e0e0008", + "test_kernel.py": "562ce0bed7c455d618cfdaaa501125eea59f68fe61a840cbcd006bd23e906b73", + "test_package.py": "4e5e8bdbcca458450cfe45ae8ed90b19d2bccb8967f0b53d8f0c1971da69caaa", + "verify.py": "d4564c8323129cc94ba25ab856dc7aab9bf99b8468e1d47bb17bf2b4b5ba77eb" + }, + "reference_receipt": { + "stdout": "PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1}\n", + "determinant_calls": 3360, + "determinant_trace_sha256": "441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef", + "kernel_stats": null + }, + "compared_receipt": { + "stdout": "PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1}\n", + "determinant_calls": 3360, + "determinant_trace_sha256": "441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef", + "kernel_stats": { + "calls": 3360, + "hits": 3186, + "fallbacks": 0 + } + }, + "samples": [ + { + "pair": 0, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.11372145899804309, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.12957050000113668, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 1, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.1223782079978264, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.1674511250021169, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 2, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.18004320799809648, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.18566362500132527, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 3, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.16837300000042887, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.15215912499843398, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 4, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.19841483300115215, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.16610200000286568, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 5, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.14031133300159127, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.1325735420032288, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 6, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.13999554100155365, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.130011666995415, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 7, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.11514566600089893, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.10976837500493275, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 8, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.10499604099459248, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.11369425000157207, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 9, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.1354815839949879, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.15065949999552686, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 10, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.1271955829943181, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.11566083400248317, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 11, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.11151262500061421, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.12434295900311554, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 12, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.11379125000530621, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.10117187500145519, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 13, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.10046874999534339, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.10605958299856866, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 14, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.10851133299729554, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.10462099999858765, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 15, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.10385291700367816, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.10674266699788859, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 16, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.10071624999545747, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.10322908400121378, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 17, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.11489495800196892, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.13928395800030557, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 18, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.14671529099723557, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.13690620800480247, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 19, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.1287055840002722, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.161119125004916, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 20, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.16855929200391984, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.12916008300089743, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 21, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.1159368330045254, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.10899737500585616, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 22, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.10664891700434964, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.09828387499874225, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 23, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.09905820900166873, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.10614358400198398, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 24, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.09674391600128729, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.09140712500084192, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 25, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.08937883299950045, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.09467812499497086, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 26, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.0892537089966936, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.08573700000124518, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 27, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.09970437500305707, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.10557170800166205, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 28, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.11090387500007637, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.11299720799433999, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 29, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.13535487500485033, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.14595566699426854, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 30, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.1422274579963414, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.1541094170024735, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + } + ], + "median_seconds": { + "reference": 0.11379125000530621, + "prefix": 0.11514566600089893 + }, + "determinant_stream": { + "requests": 3360, + "samples": [ + { + "pair": 0, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.024160459004633594, + "prefix_seconds": 0.013309250003658235 + }, + { + "pair": 1, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.012749374996928964, + "reference_seconds": 0.023708458000328392 + }, + { + "pair": 2, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.0255070830025943, + "prefix_seconds": 0.01662216599652311 + }, + { + "pair": 3, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.013277999998535961, + "reference_seconds": 0.02337591599643929 + }, + { + "pair": 4, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.024247458000900224, + "prefix_seconds": 0.011945416998059954 + }, + { + "pair": 5, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.013274915996589698, + "reference_seconds": 0.025779790994420182 + }, + { + "pair": 6, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.02380129099765327, + "prefix_seconds": 0.013411459003691562 + }, + { + "pair": 7, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.012824915997043718, + "reference_seconds": 0.020926082994265016 + }, + { + "pair": 8, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.021025374997407198, + "prefix_seconds": 0.010823374999745283 + }, + { + "pair": 9, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.01097124999796506, + "reference_seconds": 0.02054879200295545 + }, + { + "pair": 10, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.019486666002194397, + "prefix_seconds": 0.00937487500050338 + }, + { + "pair": 11, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008988458001113031, + "reference_seconds": 0.01780187500116881 + }, + { + "pair": 12, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01823741699627135, + "prefix_seconds": 0.009775625003385358 + }, + { + "pair": 13, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009134542000538204, + "reference_seconds": 0.018089750003127847 + }, + { + "pair": 14, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.019968749998952262, + "prefix_seconds": 0.009073084002011456 + }, + { + "pair": 15, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009409292004420422, + "reference_seconds": 0.01828324999951292 + }, + { + "pair": 16, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.017976916002226062, + "prefix_seconds": 0.00926262499706354 + }, + { + "pair": 17, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.010826083002029918, + "reference_seconds": 0.018337375004193746 + }, + { + "pair": 18, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.018617624999023974, + "prefix_seconds": 0.009319417004007846 + }, + { + "pair": 19, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009685749995696824, + "reference_seconds": 0.02182720800192328 + }, + { + "pair": 20, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.019015416997717693, + "prefix_seconds": 0.010342790999857243 + }, + { + "pair": 21, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009670542000094429, + "reference_seconds": 0.018479291000403464 + }, + { + "pair": 22, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01970120800251607, + "prefix_seconds": 0.009186500006762799 + }, + { + "pair": 23, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.010858542002097238, + "reference_seconds": 0.0211266659971443 + }, + { + "pair": 24, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.02211012499901699, + "prefix_seconds": 0.009688792000815738 + }, + { + "pair": 25, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009674959001131356, + "reference_seconds": 0.018251290995976888 + }, + { + "pair": 26, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.017878625003504567, + "prefix_seconds": 0.009011207999719772 + }, + { + "pair": 27, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008996542004751973, + "reference_seconds": 0.01752962500177091 + }, + { + "pair": 28, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.017559624997375067, + "prefix_seconds": 0.009215707999828737 + }, + { + "pair": 29, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008995666001283098, + "reference_seconds": 0.01891220799734583 + }, + { + "pair": 30, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01825716700113844, + "prefix_seconds": 0.009291374997701496 + } + ], + "median_seconds": { + "reference": 0.019486666002194397, + "prefix": 0.009685749995696824 + }, + "speedup": 2.0118902522625417, + "result_sha256": "12344fac32167535a72a2b5d79b5755f925af513d16aae5e71aefdf4a43b7e1a" + }, + "speedup": 0.9882373688682113, + "wall_time_reduction": -0.01190263746579423 +} diff --git a/research/gram-prefix-performance/evidence/macos-python314-cpu.json b/research/gram-prefix-performance/evidence/macos-python314-cpu.json new file mode 100644 index 0000000000..78b0caa482 --- /dev/null +++ b/research/gram-prefix-performance/evidence/macos-python314-cpu.json @@ -0,0 +1,754 @@ +{ + "status": "PASS_GRAM_PREFIX_BENCHMARK", + "scope": "Complete 672-frame Gram checker including adapter startup and source/fixture validation, fresh processes, existing exported inputs; no exporter or full frontier replay timing.", + "environment": { + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "executable": "/opt/homebrew/opt/python@3.14/bin/python3.14", + "platform": "macOS-27.2-arm64-arm-64bit-Mach-O", + "machine": "arm64", + "filesystem_caches_flushed": false + }, + "source": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "assignment_seed": 88, + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-r420/data/bitE8mut-r420.json.gz": "9721a3819efd68307f66f00d84a952eb28eb7c3ad2ce79653ce295c98a764784" + }, + "frames_payload_sha256": "46f49b700fa3ecd59ba6815b58234c0b67b94360f7af52a718b275b8198c1c74", + "frames": 672 + }, + "package_python_sha256": { + "adapter.py": "d666868eaa53e1f66a002ed211cbd9caadee63da229fed315534d1172e525fd6", + "benchmark.py": "58349125e19e5598c6844c69f87c34fafe44149e083f1ec5624a62dfe51fcdfd", + "kernel.py": "2e1701099bffeb84d28add001a7a46fd6457ef113aea13be8d030aa85e0e0008", + "test_kernel.py": "562ce0bed7c455d618cfdaaa501125eea59f68fe61a840cbcd006bd23e906b73", + "test_package.py": "4e5e8bdbcca458450cfe45ae8ed90b19d2bccb8967f0b53d8f0c1971da69caaa", + "verify.py": "d4564c8323129cc94ba25ab856dc7aab9bf99b8468e1d47bb17bf2b4b5ba77eb" + }, + "reference_receipt": { + "stdout": "PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1}\n", + "determinant_calls": 3360, + "determinant_trace_sha256": "441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef", + "kernel_stats": null + }, + "compared_receipt": { + "stdout": "PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1}\n", + "determinant_calls": 3360, + "determinant_trace_sha256": "441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef", + "kernel_stats": { + "calls": 3360, + "hits": 3186, + "fallbacks": 0 + } + }, + "samples": [ + { + "pair": 0, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.148042, + "reference_seconds": 0.15493674999743234, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.15200899999999995, + "prefix_seconds": 0.16958545799570857, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 1, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.144063, + "prefix_seconds": 0.15162033300293842, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.19204699999999997, + "reference_seconds": 0.24769304200162878, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 2, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.190446, + "reference_seconds": 0.21184712499962188, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.14839300000000008, + "prefix_seconds": 0.169144999999844, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 3, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.13751999999999998, + "prefix_seconds": 0.14514108299772488, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.13757000000000003, + "reference_seconds": 0.1433502919971943, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 4, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.12811999999999996, + "reference_seconds": 0.13329358399641933, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.1290149999999999, + "prefix_seconds": 0.13565391700103646, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 5, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.14238400000000018, + "prefix_seconds": 0.17209687500144355, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.13969599999999988, + "reference_seconds": 0.14476641699729953, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 6, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.1276790000000001, + "reference_seconds": 0.1362081249972107, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.13829200000000003, + "prefix_seconds": 0.1478760840036557, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 7, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.14562799999999992, + "prefix_seconds": 0.16024099999776809, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.127069, + "reference_seconds": 0.13162537499738391, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 8, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.11987599999999982, + "reference_seconds": 0.12420112499967217, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.11116200000000004, + "prefix_seconds": 0.11502620800456498, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 9, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.11107500000000003, + "prefix_seconds": 0.12236695800675079, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.113616, + "reference_seconds": 0.11698374999832595, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 10, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.10686599999999996, + "reference_seconds": 0.11050008299935143, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.09944900000000001, + "prefix_seconds": 0.10305916700599482, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 11, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.09692800000000024, + "prefix_seconds": 0.10002054199867416, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.09858399999999978, + "reference_seconds": 0.1017814580045524, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 12, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.0940390000000001, + "reference_seconds": 0.09707487499690615, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.09084599999999998, + "prefix_seconds": 0.09406237499933923, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 13, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.10045700000000013, + "prefix_seconds": 0.10385479200340342, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.11510300000000007, + "reference_seconds": 0.12001158299972303, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 14, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.13906699999999983, + "reference_seconds": 0.15166587499697926, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.15196399999999988, + "prefix_seconds": 0.16534845799469622, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 15, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.17125500000000027, + "prefix_seconds": 0.18895633400097722, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.1875169999999997, + "reference_seconds": 0.21486387500044657, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 16, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.22017200000000026, + "reference_seconds": 0.25197887499962235, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.1959240000000001, + "prefix_seconds": 0.22855941699526738, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 17, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.1424169999999999, + "prefix_seconds": 0.14880029200139688, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.15252999999999994, + "reference_seconds": 0.1671421659993939, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 18, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.16055300000000006, + "reference_seconds": 0.17403750000084983, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.1484629999999998, + "prefix_seconds": 0.15504108300228836, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 19, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.1277100000000002, + "prefix_seconds": 0.13215754200064112, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.13274300000000006, + "reference_seconds": 0.13784866700007115, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 20, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.1412889999999999, + "reference_seconds": 0.14811850000114646, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.1253289999999998, + "prefix_seconds": 0.13027979099570075, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 21, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.1320940000000005, + "prefix_seconds": 0.14339462500356603, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.13100199999999962, + "reference_seconds": 0.13731941700098105, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 22, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.13506600000000024, + "reference_seconds": 0.1425461249964428, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.13962799999999964, + "prefix_seconds": 0.15830224999808706, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 23, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.1227189999999998, + "prefix_seconds": 0.12784037499659462, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.12092300000000034, + "reference_seconds": 0.1251802500046324, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 24, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.11933700000000025, + "reference_seconds": 0.12332408300426323, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.12353400000000025, + "prefix_seconds": 0.12896983300015563, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 25, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.12044499999999925, + "prefix_seconds": 0.1265525839990005, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.11948000000000025, + "reference_seconds": 0.12408287500147708, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 26, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.12924599999999997, + "reference_seconds": 0.13386199999513337, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.1313899999999999, + "prefix_seconds": 0.14189212500059512, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 27, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.15982399999999997, + "prefix_seconds": 0.17323762500018347, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.14895900000000029, + "reference_seconds": 0.1550989169991226, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 28, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.1930820000000002, + "reference_seconds": 0.20854841700202087, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.19437400000000005, + "prefix_seconds": 0.22464033299911534, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 29, + "order": [ + "prefix", + "reference" + ], + "prefix_cpu_seconds": 0.20574299999999957, + "prefix_seconds": 0.28505008300271584, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_cpu_seconds": 0.22169700000000003, + "reference_seconds": 0.28700862499681534, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 30, + "order": [ + "reference", + "prefix" + ], + "reference_cpu_seconds": 0.19602500000000034, + "reference_seconds": 0.2113397499997518, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_cpu_seconds": 0.19372899999999937, + "prefix_seconds": 0.21188987500499934, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + } + ], + "median_seconds": { + "reference": 0.1425461249964428, + "prefix": 0.1478760840036557 + }, + "median_child_cpu_seconds": { + "reference": 0.13506600000000024, + "prefix": 0.13829200000000003 + }, + "cpu_speedup": 0.9766725479420373, + "median_pair_wall_speedup": 0.9876617222116314, + "determinant_stream": { + "requests": 3360, + "samples": [ + { + "pair": 0, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.021914207994996104, + "prefix_seconds": 0.011719499998434912 + }, + { + "pair": 1, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.011478584005089942, + "reference_seconds": 0.021004959002311807 + }, + { + "pair": 2, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01935537499957718, + "prefix_seconds": 0.011193790996912867 + }, + { + "pair": 3, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.012785999999323394, + "reference_seconds": 0.026119249996554572 + }, + { + "pair": 4, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.020894666005915496, + "prefix_seconds": 0.010659624997060746 + }, + { + "pair": 5, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009572584000125062, + "reference_seconds": 0.017798249995394144 + }, + { + "pair": 6, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.019304292000015266, + "prefix_seconds": 0.008467624997138046 + }, + { + "pair": 7, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008837499997753184, + "reference_seconds": 0.015670957996917423 + }, + { + "pair": 8, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.015376041003037244, + "prefix_seconds": 0.008323457994265482 + }, + { + "pair": 9, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.011111833999166265, + "reference_seconds": 0.016708499999367632 + }, + { + "pair": 10, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.015855500001634937, + "prefix_seconds": 0.009468458003539126 + }, + { + "pair": 11, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008566042000893503, + "reference_seconds": 0.015310249997128267 + }, + { + "pair": 12, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.015312916999391746, + "prefix_seconds": 0.008363749999261927 + }, + { + "pair": 13, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009570041998813394, + "reference_seconds": 0.015279500003089197 + }, + { + "pair": 14, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.015278708000550978, + "prefix_seconds": 0.00817391700547887 + }, + { + "pair": 15, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008264957999926992, + "reference_seconds": 0.015363167003670242 + }, + { + "pair": 16, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.015231833996949717, + "prefix_seconds": 0.008097208003164269 + }, + { + "pair": 17, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008301292000396643, + "reference_seconds": 0.015300583996577188 + }, + { + "pair": 18, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.015165541997703258, + "prefix_seconds": 0.008068082999670878 + }, + { + "pair": 19, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008051791999605484, + "reference_seconds": 0.015985416997864377 + }, + { + "pair": 20, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01664037500449922, + "prefix_seconds": 0.008927249997213949 + }, + { + "pair": 21, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.007380875002127141, + "reference_seconds": 0.013841459003742784 + }, + { + "pair": 22, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.013734832995396573, + "prefix_seconds": 0.007240874998387881 + }, + { + "pair": 23, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.007242416999361012, + "reference_seconds": 0.013576500001363456 + }, + { + "pair": 24, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.013647042003867682, + "prefix_seconds": 0.0073370419995626435 + }, + { + "pair": 25, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.007175541999458801, + "reference_seconds": 0.013607042004878167 + }, + { + "pair": 26, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.013642124999023508, + "prefix_seconds": 0.007312542002182454 + }, + { + "pair": 27, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.007296084004337899, + "reference_seconds": 0.013564624998252839 + }, + { + "pair": 28, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.013592749994131736, + "prefix_seconds": 0.007412292005028576 + }, + { + "pair": 29, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.007158250002248678, + "reference_seconds": 0.013440916998661123 + }, + { + "pair": 30, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.013476624997565523, + "prefix_seconds": 0.0072175000022980385 + } + ], + "median_seconds": { + "reference": 0.015310249997128267, + "prefix": 0.008301292000396643 + }, + "speedup": 1.8443213413522535, + "result_sha256": "12344fac32167535a72a2b5d79b5755f925af513d16aae5e71aefdf4a43b7e1a" + }, + "speedup": 0.9639565853861729, + "wall_time_reduction": -0.03739111818960983 +} diff --git a/research/gram-prefix-performance/evidence/macos-python314.json b/research/gram-prefix-performance/evidence/macos-python314.json new file mode 100644 index 0000000000..42be7cdcc5 --- /dev/null +++ b/research/gram-prefix-performance/evidence/macos-python314.json @@ -0,0 +1,686 @@ +{ + "status": "PASS_GRAM_PREFIX_BENCHMARK", + "scope": "Complete 672-frame Gram checker including adapter startup and source/fixture validation, fresh processes, existing exported inputs; no exporter or full frontier replay timing.", + "environment": { + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "executable": "/opt/homebrew/opt/python@3.14/bin/python3.14", + "platform": "macOS-27.2-arm64-arm-64bit-Mach-O", + "machine": "arm64", + "filesystem_caches_flushed": false + }, + "source": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "assignment_seed": 88, + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-r420/data/bitE8mut-r420.json.gz": "9721a3819efd68307f66f00d84a952eb28eb7c3ad2ce79653ce295c98a764784" + }, + "frames_payload_sha256": "46f49b700fa3ecd59ba6815b58234c0b67b94360f7af52a718b275b8198c1c74", + "frames": 672 + }, + "package_python_sha256": { + "adapter.py": "d666868eaa53e1f66a002ed211cbd9caadee63da229fed315534d1172e525fd6", + "benchmark.py": "37ebd83b85ef42767a2c6e83d1ffabc49ef0fc4066efb2e55a45475ca9bf3447", + "kernel.py": "2e1701099bffeb84d28add001a7a46fd6457ef113aea13be8d030aa85e0e0008", + "test_kernel.py": "562ce0bed7c455d618cfdaaa501125eea59f68fe61a840cbcd006bd23e906b73", + "test_package.py": "4e5e8bdbcca458450cfe45ae8ed90b19d2bccb8967f0b53d8f0c1971da69caaa", + "verify.py": "d4564c8323129cc94ba25ab856dc7aab9bf99b8468e1d47bb17bf2b4b5ba77eb" + }, + "reference_receipt": { + "stdout": "PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1}\n", + "determinant_calls": 3360, + "determinant_trace_sha256": "441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef", + "kernel_stats": null + }, + "compared_receipt": { + "stdout": "PASS e8ham Gram: 672 frames checked, all nondegenerate and positive definite; prime witnesses valid; max determinant bits 17; primes [2]; by dim {0: 1, 1: 120, 2: 180, 4: 70, 6: 180, 7: 120, 8: 1}\n", + "determinant_calls": 3360, + "determinant_trace_sha256": "441d68e330a1b8b159fd914ceb2eab302d38eb50c87147ce62a513a02796dbef", + "kernel_stats": { + "calls": 3360, + "hits": 3186, + "fallbacks": 0 + } + }, + "samples": [ + { + "pair": 0, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.1517020000028424, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.13738666599965654, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 1, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.11654208400432253, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.13797641699784435, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 2, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.15979491700272774, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.13583391600695904, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 3, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.13900316700164694, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.1374914580010227, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 4, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.12317525000253227, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.12332095799501985, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 5, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.12994679199618986, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.12420408300386043, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 6, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.14626799999678042, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.11799445799988462, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 7, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.30140649999520974, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.15292645799490856, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 8, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.65826245900098, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.2928673339993111, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 9, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.2461352500031353, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.20613191700249445, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 10, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.2545002499973634, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.28588637500070035, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 11, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.2585830829993938, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.32651187499868684, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 12, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.7148525829979917, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.2844427910022205, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 13, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.2819522499994491, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.22321804099919973, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 14, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.2147174579949933, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.18942525000602473, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 15, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.15014541699929396, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.1618645420021494, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 16, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.1307176670015906, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.22134224999899743, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 17, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.17519362500024727, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.17874837500130525, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 18, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.16291341600299347, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.22422262500185752, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 19, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.25057099999685306, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.2619792499972391, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 20, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.2376051249957527, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.25671575000160374, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 21, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.21033858400187455, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.23593520800204715, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 22, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.17797591699491022, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.17703212500055088, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 23, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.16433579200383974, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.1754410840003402, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 24, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.19916716699663084, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.5497918339970056, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 25, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.3440623330025119, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.34111029199993936, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 26, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.4404151249982533, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.4199460000018007, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 27, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.3510235420035315, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.2731687920022523, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 28, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.2906751249975059, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.40505466700415127, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 29, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.25221050000254763, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "reference_seconds": 0.3231955410010414, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + }, + { + "pair": 30, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.27617129199643387, + "reference_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6", + "prefix_seconds": 0.2750030829993193, + "prefix_stdout_sha256": "6abafaf29f2829ad650bd36d3cac8c7c884db60c72c3a34d81e1877ea5baaba6" + } + ], + "median_seconds": { + "reference": 0.20613191700249445, + "prefix": 0.2461352500031353 + }, + "determinant_stream": { + "requests": 3360, + "samples": [ + { + "pair": 0, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.03340833300171653, + "prefix_seconds": 0.013852707998012193 + }, + { + "pair": 1, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.010482333003892563, + "reference_seconds": 0.021465124998940155 + }, + { + "pair": 2, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.030797709005128127, + "prefix_seconds": 0.014214625000022352 + }, + { + "pair": 3, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.022078875001170672, + "reference_seconds": 0.02932291699835332 + }, + { + "pair": 4, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.02270545799547108, + "prefix_seconds": 0.013039375000516884 + }, + { + "pair": 5, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.011331624999002088, + "reference_seconds": 0.026013250004325528 + }, + { + "pair": 6, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.021109499997692183, + "prefix_seconds": 0.010798875002365094 + }, + { + "pair": 7, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009938041999703273, + "reference_seconds": 0.018647707998752594 + }, + { + "pair": 8, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.057469958999718074, + "prefix_seconds": 0.024428625001746695 + }, + { + "pair": 9, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.023258708002686035, + "reference_seconds": 0.07294866700249258 + }, + { + "pair": 10, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.03604195799562149, + "prefix_seconds": 0.021646458000759594 + }, + { + "pair": 11, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.014795415998378303, + "reference_seconds": 0.04886879200057592 + }, + { + "pair": 12, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.025226290999853518, + "prefix_seconds": 0.010054582999146078 + }, + { + "pair": 13, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.00951629200426396, + "reference_seconds": 0.021180417003051843 + }, + { + "pair": 14, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.018445916000928264, + "prefix_seconds": 0.010317916996427812 + }, + { + "pair": 15, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009634791997086722, + "reference_seconds": 0.01899237500037998 + }, + { + "pair": 16, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.016788875000202097, + "prefix_seconds": 0.009456542000407353 + }, + { + "pair": 17, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.010101666004629806, + "reference_seconds": 0.018761208004434593 + }, + { + "pair": 18, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01604204100294737, + "prefix_seconds": 0.009340832999441773 + }, + { + "pair": 19, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.00958600000012666, + "reference_seconds": 0.018826667001121677 + }, + { + "pair": 20, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.019262249996245373, + "prefix_seconds": 0.01088591700681718 + }, + { + "pair": 21, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.009232542004610877, + "reference_seconds": 0.017330165996099822 + }, + { + "pair": 22, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01575237500219373, + "prefix_seconds": 0.010419416001241188 + }, + { + "pair": 23, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.00938299999688752, + "reference_seconds": 0.017923416999110486 + }, + { + "pair": 24, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.01721762499801116, + "prefix_seconds": 0.0089388750056969 + }, + { + "pair": 25, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.010291958002198953, + "reference_seconds": 0.017674540998996235 + }, + { + "pair": 26, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.0158205000043381, + "prefix_seconds": 0.008764457998040598 + }, + { + "pair": 27, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.008102250001684297, + "reference_seconds": 0.015570915995340329 + }, + { + "pair": 28, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.015561874999548309, + "prefix_seconds": 0.009473916004935745 + }, + { + "pair": 29, + "order": [ + "prefix", + "reference" + ], + "prefix_seconds": 0.00824362500134157, + "reference_seconds": 0.016433707998658065 + }, + { + "pair": 30, + "order": [ + "reference", + "prefix" + ], + "reference_seconds": 0.016107957999338396, + "prefix_seconds": 0.010162999999010935 + } + ], + "median_seconds": { + "reference": 0.018826667001121677, + "prefix": 0.010162999999010935 + }, + "speedup": 1.8524714162111475, + "result_sha256": "12344fac32167535a72a2b5d79b5755f925af513d16aae5e71aefdf4a43b7e1a" + }, + "speedup": 0.8374741813692623, + "wall_time_reduction": -0.19406666169100228 +} diff --git a/research/gram-prefix-performance/evidence/minimal-offline-replay.txt b/research/gram-prefix-performance/evidence/minimal-offline-replay.txt new file mode 100644 index 0000000000..ada4ca53f3 --- /dev/null +++ b/research/gram-prefix-performance/evidence/minimal-offline-replay.txt @@ -0,0 +1,29 @@ +PASS_GRAM_PREFIX_VERIFICATION +test_all_small_binary_matrices (test_kernel.PrefixDeterminantTests.test_all_small_binary_matrices) ... ok +test_cached_input_is_value_sensitive_and_copied (test_kernel.PrefixDeterminantTests.test_cached_input_is_value_sensitive_and_copied) ... ok +test_determinant_identities_on_larger_matrices (test_kernel.PrefixDeterminantTests.test_determinant_identities_on_larger_matrices) ... ok +test_empty_scalar_and_tuple_inputs (test_kernel.PrefixDeterminantTests.test_empty_scalar_and_tuple_inputs) ... ok +test_hand_computable_determinants (test_kernel.PrefixDeterminantTests.test_hand_computable_determinants) ... ok +test_integers_beyond_machine_precision (test_kernel.PrefixDeterminantTests.test_integers_beyond_machine_precision) ... ok +test_interleaved_matrices_and_out_of_order_prefixes (test_kernel.PrefixDeterminantTests.test_interleaved_matrices_and_out_of_order_prefixes) ... ok +test_negative_pivots_and_indefinite_forms (test_kernel.PrefixDeterminantTests.test_negative_pivots_and_indefinite_forms) ... ok +test_positive_definite_gram_prefixes (test_kernel.PrefixDeterminantTests.test_positive_definite_gram_prefixes) ... ok +test_previous_matrix_cache_stays_bounded (test_kernel.PrefixDeterminantTests.test_previous_matrix_cache_stays_bounded) ... ok +test_rejects_invalid_shapes_and_noninteger_entries (test_kernel.PrefixDeterminantTests.test_rejects_invalid_shapes_and_noninteger_entries) ... ok +test_seed88_larger_matrices_against_original (test_kernel.PrefixDeterminantTests.test_seed88_larger_matrices_against_original) ... ok +test_seed88_small_signed_matrices (test_kernel.PrefixDeterminantTests.test_seed88_small_signed_matrices) ... ok +test_singular_and_repeated_rows (test_kernel.PrefixDeterminantTests.test_singular_and_repeated_rows) ... ok +test_zero_leading_minors_with_nonsingular_full_matrix (test_kernel.PrefixDeterminantTests.test_zero_leading_minors_with_nonsingular_full_matrix) ... ok +test_zero_pivot_delegates_to_original (test_kernel.PrefixDeterminantTests.test_zero_pivot_delegates_to_original) ... ok +test_cli_assertions_and_output_preservation (test_package.PackageTests.test_cli_assertions_and_output_preservation) ... ok +test_fixture_rebuild (test_package.PackageTests.test_fixture_rebuild) ... ok +test_frame_rejections (test_package.PackageTests.test_frame_rejections) ... ok +test_new_frame_filter (test_package.PackageTests.test_new_frame_filter) ... ok +test_selected_all_determinants_and_receipt (test_package.PackageTests.test_selected_all_determinants_and_receipt) ... ok +test_source_tampering (test_package.PackageTests.test_source_tampering) ... ok +test_zero_pivot_and_negative_gram_rejections (test_package.PackageTests.test_zero_pivot_and_negative_gram_rejections) ... ok + +---------------------------------------------------------------------- +Ran 23 tests in 2.643s + +OK diff --git a/research/gram-prefix-performance/evidence/mutations-python313.jsonl b/research/gram-prefix-performance/evidence/mutations-python313.jsonl new file mode 100644 index 0000000000..099c3877a8 --- /dev/null +++ b/research/gram-prefix-performance/evidence/mutations-python313.jsonl @@ -0,0 +1,5 @@ +{"assertion_failures": 0, "errors": 0, "expected_outcome_met": true, "methods_run": 16, "name": "baseline"} +{"assertion_failures": 560, "errors": 0, "expected_outcome_met": true, "methods_run": 16, "name": "wrong_full_determinant_sign"} +{"assertion_failures": 982, "errors": 0, "expected_outcome_met": true, "methods_run": 16, "name": "wrong_cached_leading_minor"} +{"assertion_failures": 655, "errors": 0, "expected_outcome_met": true, "methods_run": 16, "name": "cache_hit_by_shape_only"} +{"assertion_failures": 162, "errors": 0, "expected_outcome_met": true, "methods_run": 16, "name": "zero_pivot_returns_zero"} diff --git a/research/gram-prefix-performance/evidence/verify-python313.txt b/research/gram-prefix-performance/evidence/verify-python313.txt new file mode 100644 index 0000000000..37e7722dee --- /dev/null +++ b/research/gram-prefix-performance/evidence/verify-python313.txt @@ -0,0 +1,29 @@ +test_all_small_binary_matrices (test_kernel.PrefixDeterminantTests.test_all_small_binary_matrices) ... ok +test_cached_input_is_value_sensitive_and_copied (test_kernel.PrefixDeterminantTests.test_cached_input_is_value_sensitive_and_copied) ... ok +test_determinant_identities_on_larger_matrices (test_kernel.PrefixDeterminantTests.test_determinant_identities_on_larger_matrices) ... ok +test_empty_scalar_and_tuple_inputs (test_kernel.PrefixDeterminantTests.test_empty_scalar_and_tuple_inputs) ... ok +test_hand_computable_determinants (test_kernel.PrefixDeterminantTests.test_hand_computable_determinants) ... ok +test_integers_beyond_machine_precision (test_kernel.PrefixDeterminantTests.test_integers_beyond_machine_precision) ... ok +test_interleaved_matrices_and_out_of_order_prefixes (test_kernel.PrefixDeterminantTests.test_interleaved_matrices_and_out_of_order_prefixes) ... ok +test_negative_pivots_and_indefinite_forms (test_kernel.PrefixDeterminantTests.test_negative_pivots_and_indefinite_forms) ... ok +test_positive_definite_gram_prefixes (test_kernel.PrefixDeterminantTests.test_positive_definite_gram_prefixes) ... ok +test_previous_matrix_cache_stays_bounded (test_kernel.PrefixDeterminantTests.test_previous_matrix_cache_stays_bounded) ... ok +test_rejects_invalid_shapes_and_noninteger_entries (test_kernel.PrefixDeterminantTests.test_rejects_invalid_shapes_and_noninteger_entries) ... ok +test_seed88_larger_matrices_against_original (test_kernel.PrefixDeterminantTests.test_seed88_larger_matrices_against_original) ... ok +test_seed88_small_signed_matrices (test_kernel.PrefixDeterminantTests.test_seed88_small_signed_matrices) ... ok +test_singular_and_repeated_rows (test_kernel.PrefixDeterminantTests.test_singular_and_repeated_rows) ... ok +test_zero_leading_minors_with_nonsingular_full_matrix (test_kernel.PrefixDeterminantTests.test_zero_leading_minors_with_nonsingular_full_matrix) ... ok +test_zero_pivot_delegates_to_original (test_kernel.PrefixDeterminantTests.test_zero_pivot_delegates_to_original) ... ok +test_cli_assertions_and_output_preservation (test_package.PackageTests.test_cli_assertions_and_output_preservation) ... ok +test_fixture_rebuild (test_package.PackageTests.test_fixture_rebuild) ... ok +test_frame_rejections (test_package.PackageTests.test_frame_rejections) ... ok +test_new_frame_filter (test_package.PackageTests.test_new_frame_filter) ... ok +test_selected_all_determinants_and_receipt (test_package.PackageTests.test_selected_all_determinants_and_receipt) ... ok +test_source_tampering (test_package.PackageTests.test_source_tampering) ... ok +test_zero_pivot_and_negative_gram_rejections (test_package.PackageTests.test_zero_pivot_and_negative_gram_rejections) ... ok + +---------------------------------------------------------------------- +Ran 23 tests in 1.934s + +OK +PASS_GRAM_PREFIX_VERIFICATION diff --git a/research/gram-prefix-performance/evidence/verify-python314.txt b/research/gram-prefix-performance/evidence/verify-python314.txt new file mode 100644 index 0000000000..dca6cfddb9 --- /dev/null +++ b/research/gram-prefix-performance/evidence/verify-python314.txt @@ -0,0 +1,29 @@ +test_all_small_binary_matrices (test_kernel.PrefixDeterminantTests.test_all_small_binary_matrices) ... ok +test_cached_input_is_value_sensitive_and_copied (test_kernel.PrefixDeterminantTests.test_cached_input_is_value_sensitive_and_copied) ... ok +test_determinant_identities_on_larger_matrices (test_kernel.PrefixDeterminantTests.test_determinant_identities_on_larger_matrices) ... ok +test_empty_scalar_and_tuple_inputs (test_kernel.PrefixDeterminantTests.test_empty_scalar_and_tuple_inputs) ... ok +test_hand_computable_determinants (test_kernel.PrefixDeterminantTests.test_hand_computable_determinants) ... ok +test_integers_beyond_machine_precision (test_kernel.PrefixDeterminantTests.test_integers_beyond_machine_precision) ... ok +test_interleaved_matrices_and_out_of_order_prefixes (test_kernel.PrefixDeterminantTests.test_interleaved_matrices_and_out_of_order_prefixes) ... ok +test_negative_pivots_and_indefinite_forms (test_kernel.PrefixDeterminantTests.test_negative_pivots_and_indefinite_forms) ... ok +test_positive_definite_gram_prefixes (test_kernel.PrefixDeterminantTests.test_positive_definite_gram_prefixes) ... ok +test_previous_matrix_cache_stays_bounded (test_kernel.PrefixDeterminantTests.test_previous_matrix_cache_stays_bounded) ... ok +test_rejects_invalid_shapes_and_noninteger_entries (test_kernel.PrefixDeterminantTests.test_rejects_invalid_shapes_and_noninteger_entries) ... ok +test_seed88_larger_matrices_against_original (test_kernel.PrefixDeterminantTests.test_seed88_larger_matrices_against_original) ... ok +test_seed88_small_signed_matrices (test_kernel.PrefixDeterminantTests.test_seed88_small_signed_matrices) ... ok +test_singular_and_repeated_rows (test_kernel.PrefixDeterminantTests.test_singular_and_repeated_rows) ... ok +test_zero_leading_minors_with_nonsingular_full_matrix (test_kernel.PrefixDeterminantTests.test_zero_leading_minors_with_nonsingular_full_matrix) ... ok +test_zero_pivot_delegates_to_original (test_kernel.PrefixDeterminantTests.test_zero_pivot_delegates_to_original) ... ok +test_cli_assertions_and_output_preservation (test_package.PackageTests.test_cli_assertions_and_output_preservation) ... ok +test_fixture_rebuild (test_package.PackageTests.test_fixture_rebuild) ... ok +test_frame_rejections (test_package.PackageTests.test_frame_rejections) ... ok +test_new_frame_filter (test_package.PackageTests.test_new_frame_filter) ... ok +test_selected_all_determinants_and_receipt (test_package.PackageTests.test_selected_all_determinants_and_receipt) ... ok +test_source_tampering (test_package.PackageTests.test_source_tampering) ... ok +test_zero_pivot_and_negative_gram_rejections (test_package.PackageTests.test_zero_pivot_and_negative_gram_rejections) ... ok + +---------------------------------------------------------------------- +Ran 23 tests in 2.115s + +OK +PASS_GRAM_PREFIX_VERIFICATION diff --git a/research/gram-prefix-performance/evidence/wall-only-benchmark.py.txt b/research/gram-prefix-performance/evidence/wall-only-benchmark.py.txt new file mode 100644 index 0000000000..48f7fac69a --- /dev/null +++ b/research/gram-prefix-performance/evidence/wall-only-benchmark.py.txt @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +"""Alternate fresh-process complete Gram checks on identical R420 inputs.""" +import argparse +import hashlib +import json +import importlib.util +from pathlib import Path +import platform +import statistics +import subprocess +import sys +import tempfile +import time + +import adapter + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--pairs', type=int, default=15) + ap.add_argument('--out', type=Path, required=True) + args = ap.parse_args() + adapter.require(not sys.flags.optimize, 'enabled assertions required') + adapter.require(args.pairs >= 3, 'at least three pairs required') + adapter.require(not args.out.exists(), 'output already exists') + pins, payload = adapter.source_check() + samples = [] + kernel_samples = [] + with tempfile.TemporaryDirectory(prefix='gram-prefix-benchmark-') as tmp: + frames = Path(tmp) + (frames / 'frames.json').write_bytes(payload) + # Untimed exact comparison covers every actual determinant call first. + requests = [] + reference = adapter.execute('reference', frames, trace=True, requests=requests) + compared = adapter.execute('compare', frames, trace=True) + for key in ('stdout', 'determinant_calls', 'determinant_trace_sha256'): + adapter.require(reference[key] == compared[key], 'reference mismatch: ' + key) + # Seed 88 chooses reference first; order reverses in each following pair. + for pair in range(args.pairs): + engines = ('reference', 'prefix') if (88 + pair) % 2 == 0 else ('prefix', 'reference') + row = {'pair': pair, 'order': list(engines)} + for engine in engines: + command = [sys.executable, '-B', str(adapter.HERE / 'adapter.py'), + '--frames', str(frames), '--engine', engine] + start = time.perf_counter() + process = subprocess.run(command, capture_output=True, text=True) + seconds = time.perf_counter() - start + adapter.require(process.returncode == 0, process.stderr) + adapter.require(process.stdout == reference['stdout'], 'complete checker output changed') + row[engine + '_seconds'] = seconds + row[engine + '_stdout_sha256'] = hashlib.sha256(process.stdout.encode()).hexdigest() + samples.append(row) + # A separate in-process workload uses the exact recorded request order. + # Input loading, imports, equality checks and hashing are outside timing. + from kernel import PrefixDeterminant + path = adapter.ROOT / 'research/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py' + spec = importlib.util.spec_from_file_location('gram_benchmark_reference', path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + expected = [module.det(matrix) for matrix in requests] + for pair in range(args.pairs): + engines = ('reference', 'prefix') if (88 + pair) % 2 == 0 else ('prefix', 'reference') + row = {'pair': pair, 'order': list(engines)} + for engine in engines: + determinant = module.det if engine == 'reference' else PrefixDeterminant(module.det) + start = time.perf_counter() + actual = [determinant(matrix) for matrix in requests] + row[engine + '_seconds'] = time.perf_counter() - start + adapter.require(actual == expected, 'timed determinant stream changed') + kernel_samples.append(row) + medians = {engine: statistics.median(row[engine + '_seconds'] for row in samples) + for engine in ('reference', 'prefix')} + kernel_medians = {engine: statistics.median(row[engine + '_seconds'] for row in kernel_samples) + for engine in ('reference', 'prefix')} + own_sources = {p.name: hashlib.sha256(p.read_bytes()).hexdigest() + for p in sorted(adapter.HERE.glob('*.py'))} + result = dict(status='PASS_GRAM_PREFIX_BENCHMARK', + scope='Complete 672-frame Gram checker including adapter startup and source/fixture validation, fresh processes, existing exported inputs; no exporter or full frontier replay timing.', + environment=dict(python=sys.version, executable=sys.executable, platform=platform.platform(), + machine=platform.machine(), filesystem_caches_flushed=False), + source=pins, package_python_sha256=own_sources, + reference_receipt=reference, compared_receipt=compared, + samples=samples, median_seconds=medians, + determinant_stream=dict(requests=len(requests), samples=kernel_samples, + median_seconds=kernel_medians, speedup=kernel_medians['reference']/kernel_medians['prefix'], + result_sha256=hashlib.sha256(json.dumps(expected, separators=(',', ':')).encode()).hexdigest()), + speedup=medians['reference']/medians['prefix'], + wall_time_reduction=1-medians['prefix']/medians['reference']) + with args.out.open('x') as stream: + json.dump(result, stream, indent=2) + stream.write('\n') + print('PASS_GRAM_PREFIX_BENCHMARK', json.dumps(medians), 'speedup', result['speedup']) + + +if __name__ == '__main__': + main() diff --git a/research/gram-prefix-performance/frames.json.gz b/research/gram-prefix-performance/frames.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..b36593e6f3ee1733cba97867a735af1ae4bc8049 GIT binary patch literal 8396 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 literal 0 HcmV?d00001 diff --git a/research/gram-prefix-performance/kernel.py b/research/gram-prefix-performance/kernel.py new file mode 100644 index 0000000000..54f94d4543 --- /dev/null +++ b/research/gram-prefix-performance/kernel.py @@ -0,0 +1,87 @@ +"""Exact leading-principal determinant reuse for the pinned Gram checker. + +This module has no dependencies outside Python. See PROOF.md for the integer +identity, cache contract, and the zero-pivot fallback. +""" + +from itertools import chain + + +class PrefixDeterminant: + """Callable determinant with one bounded cache of leading principal minors. + + ``reference_det`` must compute exact determinants of square integer matrices. + A miss replaces the cache. A hit retains the previous cache, so a full-matrix + request followed by all its leading prefixes requires one elimination pass. + Only built-in ``int`` entries are accepted; bool and float are rejected. + Instances are intended for sequential use, as in the pinned checker. + """ + + def __init__(self, reference_det): + if not callable(reference_det): + raise TypeError("reference_det must be callable") + self.reference_det = reference_det + self.stats = {"calls": 0, "hits": 0, "fallbacks": 0} + self._cache = {} + + @property + def cache_size(self): + """Number of stored determinants, bounded by the last missed dimension.""" + return len(self._cache) + + def __call__(self, matrix): + self.stats["calls"] += 1 + key = tuple(map(tuple, matrix)) + n = len(key) + if set(map(len, key)) - {n}: + raise ValueError("determinant requires a square matrix") + if set(map(type, chain.from_iterable(key))) - {int}: + raise TypeError("matrix entries must be built-in integers") + + cached = self._cache.get(key) + if cached is not None: + self.stats["hits"] += 1 + return cached + + # Evict the old root before computation. Never combine unrelated roots. + self._cache = {} + if not n: + return 1 + + work = [list(row) for row in key] + minors = [] + previous = 1 + result = None + for k in range(n - 1): + pivot = work[k][k] + minors.append(pivot) + if pivot == 0: + self.stats["fallbacks"] += 1 + # Pass a separate mutable copy to preserve both the input and + # the immutable cache keys, even if the reference mutates it. + result = self.reference_det([list(row) for row in key]) + break + if previous == 0: + raise ArithmeticError("zero Bareiss divisor") + for i in range(k + 1, n): + for j in range(k + 1, n): + numerator = work[i][j] * pivot - work[i][k] * work[k][j] + quotient, remainder = divmod(numerator, previous) + if remainder != 0: + raise ArithmeticError("non-exact Bareiss division") + work[i][j] = quotient + work[i][k] = 0 + previous = pivot + else: + result = work[-1][-1] + minors.append(result) + + # Each key contains every entry of the corresponding requested matrix. + # Mutable caller objects and their identities never serve as cache keys. + self._cache = { + tuple(row[:size] for row in key[:size]): value + for size, value in enumerate(minors, start=1) + if size < n + } + self._cache[key] = result + return result diff --git a/research/gram-prefix-performance/test_kernel.py b/research/gram-prefix-performance/test_kernel.py new file mode 100644 index 0000000000..144c7cedfb --- /dev/null +++ b/research/gram-prefix-performance/test_kernel.py @@ -0,0 +1,339 @@ +"""Independent exact controls for the optional determinant-prefix engine. + +Run with ``python3 research/gram-prefix-performance/test_kernel.py``. +Small cases use the Leibniz formula, with no elimination or prefix reuse. +Larger controls use the original prime-witness determinant implementation. +""" + +import importlib.util +import itertools +import json +from pathlib import Path +import random +import sys +import types +import unittest + +from kernel import PrefixDeterminant + + +HERE = Path(__file__).resolve().parent +REFERENCE = HERE.parent / "e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py" +SPEC = importlib.util.spec_from_file_location("original_prime_witnesses", REFERENCE) +REFERENCE_MODULE = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(REFERENCE_MODULE) +reference_det = REFERENCE_MODULE.det + + +def permutation_det(matrix): + """Leibniz determinant with the sign obtained from inversion parity.""" + n = len(matrix) + total = 0 + for permutation in itertools.permutations(range(n)): + term = 1 + for row, column in enumerate(permutation): + term *= matrix[row][column] + inversions = sum( + permutation[i] > permutation[j] + for i in range(n) + for j in range(i + 1, n) + ) + total += -term if inversions % 2 else term + return total + + +def leading(matrix, dimension): + return [row[:dimension] for row in matrix[:dimension]] + + +def transpose(matrix): + return [list(row) for row in zip(*matrix)] + + +def positive_gram(matrix): + dimension = len(matrix[0]) + return [ + [ + sum(row[i] * row[j] for row in matrix) + (i == j) + for j in range(dimension) + ] + for i in range(dimension) + ] + + +class PrefixDeterminantTests(unittest.TestCase): + def setUp(self): + self.engine = PrefixDeterminant(reference_det) + + def assert_exact(self, matrix, oracle=permutation_det): + before = [list(row) for row in matrix] + actual = self.engine(matrix) + self.assertIs(type(actual), int) + self.assertEqual(actual, oracle(before), before) + self.assertEqual([list(row) for row in matrix], before, "input changed") + + def assert_all_prefixes(self, matrix, oracle=permutation_det): + # The production checker requests the full determinant before its minors. + self.assert_exact(matrix, oracle) + dimensions = list(range(1, len(matrix) + 1)) + [0] + for dimension in dimensions + list(reversed(dimensions)): + self.assert_exact(leading(matrix, dimension), oracle) + + def test_empty_scalar_and_tuple_inputs(self): + for matrix in ([], (), [[0]], [[1]], [[-7]], ((3, 2), (4, 5))): + with self.subTest(matrix=matrix): + self.assert_exact(matrix) + + def test_rejects_invalid_shapes_and_noninteger_entries(self): + for matrix in ([[1, 2]], [[1], [2]], [[1, 2], [3]]): + with self.subTest(matrix=matrix), self.assertRaises(ValueError): + self.engine(matrix) + for entry in (True, 1.0, "1", None): + with self.subTest(entry=entry), self.assertRaises(TypeError): + self.engine([[entry]]) + + def test_previous_matrix_cache_stays_bounded(self): + for dimension in (12, 3, 9, 1, 8, 2): + matrix = [ + [100 + dimension + row if row == column else 0 + for column in range(dimension)] + for row in range(dimension) + ] + self.assert_exact(matrix, reference_det) + self.assertLessEqual(self.engine.cache_size, dimension) + for size in range(1, dimension + 1): + self.assert_exact(leading(matrix, size), reference_det) + self.assertLessEqual(self.engine.cache_size, dimension) + + def test_zero_pivot_delegates_to_original(self): + delegated = [] + + def recording_reference(matrix): + delegated.append([list(row) for row in matrix]) + return reference_det(matrix) + + self.engine = PrefixDeterminant(recording_reference) + matrix = [[1, 1, 0], [1, 1, 1], [0, 1, 1]] + self.assert_exact(matrix) + self.assertIn(matrix, delegated) + + def test_hand_computable_determinants(self): + controls = ( + ([], 1), + ([[0, 1], [1, 0]], -1), + ([[2, 3], [5, 7]], -1), + ([[2, 1], [1, 3]], 5), + ([[-2, 1], [1, -3]], 5), + ([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 0), + ([[0, 1, 0], [0, 0, 1], [1, 0, 0]], 1), + ) + for matrix, expected in controls: + with self.subTest(matrix=matrix): + self.assertEqual(permutation_det(matrix), expected) + self.assertEqual(self.engine(matrix), expected) + + def test_all_small_binary_matrices(self): + # Exhaustive inputs include singular, nonsymmetric, and pivot-swap cases. + for dimension in range(1, 4): + for entries in itertools.product((0, 1), repeat=dimension**2): + matrix = [ + list(entries[row * dimension : (row + 1) * dimension]) + for row in range(dimension) + ] + with self.subTest(dimension=dimension, entries=entries): + self.assert_all_prefixes(matrix) + + def test_seed88_small_signed_matrices(self): + rng = random.Random(88) + for dimension in range(1, 6): + for case in range(48): + matrix = [ + [rng.randint(-7, 7) for _ in range(dimension)] + for _ in range(dimension) + ] + with self.subTest(dimension=dimension, case=case): + self.assert_all_prefixes(matrix) + + def test_positive_definite_gram_prefixes(self): + rng = random.Random(88) + for dimension in range(1, 10): + for case in range(12): + basis = [ + [rng.randint(-4, 4) for _ in range(dimension)] + for _ in range(dimension + 2) + ] + matrix = positive_gram(basis) + oracle = permutation_det if dimension <= 5 else reference_det + with self.subTest(dimension=dimension, case=case): + self.assert_all_prefixes(matrix, oracle) + for size in range(1, dimension + 1): + self.assertGreater(self.engine(leading(matrix, size)), 0) + + def test_negative_pivots_and_indefinite_forms(self): + matrices = ( + [[-3, 0, 0], [0, -5, 0], [0, 0, -7]], + [[-3, 2, 1], [2, 5, 4], [1, 4, -2]], + [[1, 0, 0, 0], [0, -2, 0, 0], [0, 0, 3, 0], [0, 0, 0, -4]], + [[-2, 4, 1], [3, -7, 5], [2, 0, -9]], + ) + for matrix in matrices: + with self.subTest(matrix=matrix): + self.assert_all_prefixes(matrix) + + def test_zero_leading_minors_with_nonsingular_full_matrix(self): + matrices = ( + [[0, 2], [3, 4]], + [[1, 1, 0], [1, 1, 1], [0, 1, 1]], + [[0, 1, 0], [0, 0, 1], [1, 0, 0]], + [[1, 0, 0, 0], [0, 0, 0, 1], [0, 1, 0, 0], [0, 0, 1, 0]], + ) + for matrix in matrices: + with self.subTest(matrix=matrix): + self.assertNotEqual(permutation_det(matrix), 0) + self.assertTrue( + any(permutation_det(leading(matrix, k)) == 0 + for k in range(1, len(matrix))) + ) + self.assert_all_prefixes(matrix) + + def test_singular_and_repeated_rows(self): + rng = random.Random(88) + for dimension in range(2, 10): + matrix = [ + [rng.randint(-11, 11) for _ in range(dimension)] + for _ in range(dimension) + ] + matrix[-1] = matrix[0][:] + oracle = permutation_det if dimension <= 5 else reference_det + with self.subTest(dimension=dimension): + self.assertEqual(oracle(matrix), 0) + self.assert_all_prefixes(matrix, oracle) + shared_row = [2, 3, 5] + self.assert_all_prefixes([shared_row, shared_row, shared_row]) + + def test_integers_beyond_machine_precision(self): + huge = 2**137 + 2**61 + 17 + matrices = ( + [[huge, huge - 1], [huge + 1, huge]], + [[huge, 1, 0], [1, -huge, 3], [0, 3, huge + 7]], + [[0, huge, 1], [huge + 1, 2, 4], [5, 6, -huge]], + ) + self.assertEqual(permutation_det(matrices[0]), 1) + for matrix in matrices: + with self.subTest(matrix=matrix): + self.assert_all_prefixes(matrix) + + def test_cached_input_is_value_sensitive_and_copied(self): + matrix = [[4, 1, 2, 0], [1, 5, 3, 1], [2, 3, 7, 2], [0, 1, 2, 6]] + self.assert_all_prefixes(matrix) + # Mutate the same nested lists, including both cached and uncached corners. + for row, column, change in ((0, 0, 2), (0, 1, -5), (3, 3, 7), (2, 0, 3)): + matrix[row][column] += change + self.assert_all_prefixes(matrix) + # A new object with the same value must remain correct after caller edits. + other = [row[:] for row in matrix] + self.assert_exact(other) + matrix[0][0] += 99 + self.assert_all_prefixes(other) + self.assert_all_prefixes(matrix) + + def test_interleaved_matrices_and_out_of_order_prefixes(self): + matrices = ( + [[4, 1, 2], [1, 5, 3], [2, 3, 7]], + [[4, 1, 9], [1, 6, 3], [8, 3, -2]], + [[0, 1, 2], [1, 0, 3], [2, 3, 0]], + ) + for size in (3, 1, 2, 0, 3, 2, 1): + for matrix in matrices: + self.assert_exact(leading(matrix, size)) + + def test_seed88_larger_matrices_against_original(self): + rng = random.Random(88) + for dimension in (6, 7, 8, 9, 12, 16): + for case in range(24): + matrix = [ + [rng.randint(-20, 20) for _ in range(dimension)] + for _ in range(dimension) + ] + with self.subTest(dimension=dimension, case=case): + self.assert_all_prefixes(matrix, reference_det) + + def test_determinant_identities_on_larger_matrices(self): + # These metamorphic controls do not obtain expected values from reference_det. + rng = random.Random(88) + for dimension in (6, 9, 12): + matrix = [ + [rng.randint(-9, 9) for _ in range(dimension)] + for _ in range(dimension) + ] + original = self.engine(matrix) + self.assertEqual(self.engine(transpose(matrix)), original) + swapped = [row[:] for row in matrix] + swapped[0], swapped[-1] = swapped[-1], swapped[0] + self.assertEqual(self.engine(swapped), -original) + added = [row[:] for row in matrix] + added[2] = [a + 7 * b for a, b in zip(added[2], added[0])] + self.assertEqual(self.engine(added), original) + scaled = [row[:] for row in matrix] + scaled[1] = [-3 * entry for entry in scaled[1]] + self.assertEqual(self.engine(scaled), -3 * original) + + +def run_mutation_controls(): + """Run the real suite against isolated source mutants; never edit kernel.py.""" + global PrefixDeterminant + original_engine = PrefixDeterminant + source = (HERE / "kernel.py").read_text() + mutations = { + "wrong_full_determinant_sign": ( + "result = work[-1][-1]", + "result = -work[-1][-1]", + ), + "wrong_cached_leading_minor": ( + "minors.append(pivot)", + "minors.append(pivot + 1)", + ), + "cache_hit_by_shape_only": ( + "cached = self._cache.get(key)", + "cached = next((value for prior, value in self._cache.items()" + " if len(prior) == n), None)", + ), + "zero_pivot_returns_zero": ( + "result = self.reference_det([list(row) for row in key])", + "result = 0", + ), + } + outcomes = [] + try: + for name, replacement in [("baseline", None)] + list(mutations.items()): + if replacement is None: + PrefixDeterminant = original_engine + else: + before, after = replacement + if source.count(before) != 1: + raise RuntimeError("Mutation anchor changed: " + name) + mutant = types.ModuleType("kernel_mutant_" + name) + exec(compile(source.replace(before, after, 1), name, "exec"), mutant.__dict__) + PrefixDeterminant = mutant.PrefixDeterminant + result = unittest.TestResult() + suite = unittest.defaultTestLoader.loadTestsFromTestCase(PrefixDeterminantTests) + suite.run(result) + outcome = dict( + name=name, + methods_run=result.testsRun, + assertion_failures=len(result.failures), + errors=len(result.errors), + expected_outcome_met=(result.wasSuccessful() if name == "baseline" + else bool(result.failures) and not result.errors), + ) + outcomes.append(outcome) + print(json.dumps(outcome, sort_keys=True)) + finally: + PrefixDeterminant = original_engine + return all(outcome["expected_outcome_met"] for outcome in outcomes) + + +if __name__ == "__main__": + if sys.argv[1:] == ["--mutations"]: + sys.exit(0 if run_mutation_controls() else 1) + unittest.main(verbosity=2) diff --git a/research/gram-prefix-performance/test_package.py b/research/gram-prefix-performance/test_package.py new file mode 100644 index 0000000000..2f4437f247 --- /dev/null +++ b/research/gram-prefix-performance/test_package.py @@ -0,0 +1,119 @@ +"""End-to-end equivalence and rejection controls for the pinned Gram checker.""" +import copy +import gzip +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest + +import adapter + + +class PackageTests(unittest.TestCase): + def run_frames(self, engine, frames, **kwargs): + with tempfile.TemporaryDirectory() as tmp: + directory = Path(tmp) + (directory / 'frames.json').write_text(json.dumps({'frames': frames})) + return adapter.execute(engine, directory, **kwargs) + + def test_selected_all_determinants_and_receipt(self): + frames = json.loads(adapter.source_check()[1])['frames'] + receipts = [self.run_frames(engine, frames, trace=True) + for engine in ('reference', 'prefix', 'compare')] + self.assertIn('672 frames checked', receipts[0]['stdout']) + for key in ('stdout', 'determinant_calls', 'determinant_trace_sha256'): + self.assertEqual(len({r[key] for r in receipts}), 1, key) + self.assertGreater(receipts[1]['kernel_stats']['hits'], 0) + + def test_fixture_rebuild(self): + with tempfile.TemporaryDirectory() as tmp: + process = subprocess.run([sys.executable, '-B', str(adapter.ROOT / + 'research/e8-bit-carrier-skeleton/code/bit/export_records.py'), + str(adapter.ROOT / 'research/e8-bit-r420/data/bitE8mut-r420.json.gz'), tmp], + capture_output=True, text=True) + self.assertEqual(process.returncode, 0, process.stderr) + self.assertEqual((Path(tmp) / 'frames.json').read_bytes(), adapter.source_check()[1]) + + def test_frame_rejections(self): + selected = json.loads(adapter.source_check()[1])['frames'] + bad_dimension = copy.deepcopy(selected) + bad_dimension['1']['dim'] += 1 + dependent = {'bad': {'dim': 2, 'B': [[1, 0], [1, 0]], 'A': []}} + annihilator = {'bad': {'dim': 1, 'B': [[1, 0]], 'A': [[1, 0]]}} + large_residual = {'bad': {'dim': 1, 'B': [[2**127 - 1]], 'A': []}} + singular_gram = {'bad': {'dim': 1, 'B': [[1] * 9], 'A': []}} + cases = [(bad_dimension, {}), (dependent, {'h': 2}), + (annihilator, {'h': 2}), (large_residual, {'h': 1}), + (singular_gram, {'gram': 'triple9', 'h': 9})] + for frames, kwargs in cases: + errors = [] + for engine in ('reference', 'prefix', 'compare'): + with self.subTest(engine=engine, kwargs=kwargs): + with self.assertRaises(AssertionError) as caught: + self.run_frames(engine, frames, **kwargs) + errors.append(caught.exception.args) + self.assertTrue(all(error == errors[0] for error in errors)) + + def test_zero_pivot_and_negative_gram_rejections(self): + cases = [([[1] * 10], 10), + ([[1] * 9 + [0], [0] * 8 + [1, 1]], 10)] + for basis, dimension in cases: + frames = {'synthetic': {'dim': len(basis), 'B': basis, 'A': []}} + outputs = [] + errors = [] + for engine in ('reference', 'prefix', 'compare'): + kwargs = dict(gram='triple9', h=dimension) + with self.assertRaises(AssertionError) as caught: + self.run_frames(engine, frames, **kwargs) + errors.append(caught.exception.args) + outputs.append(self.run_frames(engine, frames, positive=False, trace=True, **kwargs)) + self.assertTrue(all(error == errors[0] for error in errors)) + self.assertEqual(len({r['stdout'] for r in outputs}), 1) + self.assertEqual(len({r['determinant_trace_sha256'] for r in outputs}), 1) + + def test_source_tampering(self): + pins, _ = adapter.source_check() + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + for name in pins['source_sha256']: + target = root / name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes((adapter.ROOT / name).read_bytes()) + adapter.source_check(root) + for name in pins['source_sha256']: + target = root / name + original = target.read_bytes() + target.write_bytes(original + b'\n') + with self.assertRaisesRegex(ValueError, 'source pin mismatch'): + adapter.source_check(root) + target.write_bytes(original) + + def test_new_frame_filter(self): + frames = json.loads(adapter.source_check()[1])['frames'] + with tempfile.TemporaryDirectory() as tmp: + old = Path(tmp) + (old / 'frames.json').write_text(json.dumps({'frames': dict(list(frames.items())[::2])})) + outputs = [self.run_frames(engine, frames, old=old, trace=True) + for engine in ('reference', 'prefix', 'compare')] + self.assertIn('336 frames checked', outputs[0]['stdout']) + self.assertEqual(len({r['stdout'] for r in outputs}), 1) + self.assertEqual(len({r['determinant_trace_sha256'] for r in outputs}), 1) + + def test_cli_assertions_and_output_preservation(self): + command = [sys.executable, '-B', str(adapter.HERE / 'adapter.py')] + optimized = subprocess.run(command[:1] + ['-O'] + command[1:], capture_output=True, text=True) + self.assertNotEqual(optimized.returncode, 0) + self.assertIn('enabled assertions', optimized.stderr) + with tempfile.TemporaryDirectory() as tmp: + path = Path(tmp) / 'receipt.json' + path.write_text('preserve this result') + existing = subprocess.run(command + ['--out', str(path)], capture_output=True, text=True) + self.assertNotEqual(existing.returncode, 0) + self.assertIn('output already exists', existing.stderr) + self.assertEqual(path.read_text(), 'preserve this result') + + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/research/gram-prefix-performance/verify.py b/research/gram-prefix-performance/verify.py new file mode 100644 index 0000000000..64779f8bb5 --- /dev/null +++ b/research/gram-prefix-performance/verify.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 +"""Rebuild the selected frame fixture and run exact differential and rejection checks.""" +from pathlib import Path +import sys +import unittest + +HERE = Path(__file__).resolve().parent +if sys.flags.optimize: + raise SystemExit('enabled assertions required by the pinned checker') +suite = unittest.defaultTestLoader.discover(str(HERE), pattern='test_*.py') +result = unittest.TextTestRunner(verbosity=2).run(suite) +if not result.wasSuccessful(): + raise SystemExit(1) +print('PASS_GRAM_PREFIX_VERIFICATION')