diff --git a/.github/repository_metadata.json b/.github/repository_metadata.json new file mode 100644 index 0000000..c1c0cee --- /dev/null +++ b/.github/repository_metadata.json @@ -0,0 +1,5 @@ +{ + "description": "Quantitative moonshine VOA identification from near-extremal correlations, with exact certificates and a physics-first CFT tutorial.", + "topics": ["conformal-field-theory", "vertex-operator-algebras", "moonshine", "monster-group", "correlation-functions", "rigidity", "interval-arithmetic", "mathematical-physics"], + "scope": "Desired About-sidebar values; this file does not itself change GitHub repository settings." +} diff --git a/.github/workflows/quantitative-core-review.yml b/.github/workflows/quantitative-core-review.yml index 4a47c44..4951300 100644 --- a/.github/workflows/quantitative-core-review.yml +++ b/.github/workflows/quantitative-core-review.yml @@ -7,7 +7,7 @@ on: permissions: contents: read jobs: - verify: + preserved_history: runs-on: ubuntu-24.04 timeout-minutes: 5 env: @@ -38,6 +38,7 @@ jobs: persist-credentials: false - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 with: + ref: ecd0623e9de41b49754b6ca16dc23752443143af path: candidate persist-credentials: false - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 @@ -92,7 +93,7 @@ jobs: cmp /tmp/pr31-normal.json /tmp/pr31-O.json cmp /tmp/pr31-normal.json /tmp/pr31-OO.json cat /tmp/pr31-normal.json - - name: Current fenced-math checks and exact presentation delta + - name: Frozen pre-release fenced-math and presentation evidence run: | cd candidate python3 checks/verify_teaching.py --baseline ../displaybase > /tmp/display-normal.json @@ -102,7 +103,7 @@ jobs: cmp /tmp/display-normal.json /tmp/display-OO.json cat /tmp/display-normal.json python3 checks/verify_display.py --export-math /tmp/monster-math.json - - name: Parse every active-page expression with MathJax + - name: Parse the frozen pre-release expression corpus run: | npm install --prefix "$RUNNER_TEMP/monster-math" --ignore-scripts --no-audit --no-fund mathjax-full@3.2.1 cd candidate @@ -151,3 +152,45 @@ jobs: PYCODE git diff --check test -z "$(git status --porcelain)" + current: + runs-on: ubuntu-24.04 + timeout-minutes: 8 + env: + PYTHONDONTWRITEBYTECODE: '1' + OPENBLAS_NUM_THREADS: '1' + OMP_NUM_THREADS: '1' + MKL_NUM_THREADS: '1' + steps: + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 + with: + ref: ecd0623e9de41b49754b6ca16dc23752443143af + path: releasebase + persist-credentials: false + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 + with: + path: current + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.13.5' + - name: Install the pinned reproduction dependency + run: python -m pip install -r current/requirements-reproduce.txt + - name: Current full suite, exact delta, and separate historical outcomes + run: | + cd current + python verify_current.py --all --baseline ../releasebase --output "$RUNNER_TEMP/current-reports" + python checks/verify_display.py --export-math "$RUNNER_TEMP/current-math.json" + git diff --check + test -z "$(git status --porcelain)" + - name: Parse the complete current reader corpus + run: | + npm install --prefix "$RUNNER_TEMP/current-renderer" --ignore-scripts --no-audit --no-fund mathjax-full@3.2.1 + NODE_PATH="$RUNNER_TEMP/current-renderer/node_modules" node current/checks/render_math.cjs "$RUNNER_TEMP/current-math.json" + - name: Retain current verification stdout and stderr + if: always() + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 + with: + name: current-verification-reports + path: ${{ runner.temp }}/current-reports + retention-days: 30 + if-no-files-found: warn diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..1fa7768 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,30 @@ +# Changelog + +## Unreleased — release preparation, 27 September 2026 + +Corrected a small-scale interval-calibration exception without changing the +analytic theorem, exact premises, or sufficient error tolerances. Added adaptive +exact square-root enclosures, an explicit precision-work-limit outcome, and +scale/interval regression checks. Current report fingerprints are separate from +preserved historical outputs. + +Added `verify_current.py`, a pinned reproduction requirements file, a +reproduction guide, current release integrity checks, and a clear distinction +between exact certification, historical strict replay, and bounded portability. + +Clarified current versus historical status, indexed preserved and pending work, +and replaced ambiguous missing-file references with pinned destinations. Added +citation metadata, a scope-accurate LLM source map, and release-scope notes. +The Gaberdiel-first physics teaching path and approved native mathematics remain. + +No manuscript, DOI, tagged release, or merge of unrelated research branches is +included. Protected historical notes, provenance archives, the original license, +and existing recorded evidence are retained. + +## Prior integrated research and presentation + +The selected quantitative core, calibration/sharpness results, and bounded +review were integrated before this release-preparation pass. Five physics +lessons and subsequent math-rendering improvements form the current teaching +path. Consult the [archive index](docs/ARCHIVE.md) and Git history for exact +historical commits rather than interpreting those integrations as formal releases. diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..f5e5a51 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,24 @@ +cff-version: 1.2.0 +message: "Please cite this research repository and include the exact commit or tagged version used. Citation is a scholarly request, not an additional license condition." +type: software +title: "Monster Correlation Rigidity" +authors: + - family-names: "Lin" + given-names: "Ruge" + email: "gogoko699@gmail.com" +repository-code: "https://github.com/GoGoKo699/Monster-Correlation-Rigidity" +url: "https://github.com/GoGoKo699/Monster-Correlation-Rigidity" +license: MIT +abstract: >- + Research proofs, exact finite certificates, and a physics-first tutorial for + quantitative conditional identification of the moonshine vertex operator + algebra from near-extremal correlation coefficients. The exact ambient + assumptions and imported classification endpoint remain explicit. +keywords: + - conformal-field-theory + - vertex-operator-algebras + - moonshine + - monster-group + - correlation-functions + - rigidity + - interval-arithmetic diff --git a/PHYSICS_STATUS.md b/PHYSICS_STATUS.md index 45065ee..6f3b8eb 100644 --- a/PHYSICS_STATUS.md +++ b/PHYSICS_STATUS.md @@ -1,3 +1,5 @@ +> **Historical record, not the current project status.** The dated ledger below is preserved unchanged. Start with [current scientific status](docs/RESEARCH_STATUS.md), [the physics learning path](docs/learn/README.md), or [the archive index](docs/ARCHIVE.md). + # Physical-selection ledger — 25 September 2026 Latest base: `ba02084a1a74fc0b4db1299f6ab3bc327a0901ef`. Physical selection remains the objective. STATUS_CURRENT.md and STATUS.md retain the former certification and import records unchanged. diff --git a/README.md b/README.md index 33e797d..df4cf16 100644 --- a/README.md +++ b/README.md @@ -47,19 +47,52 @@ Finite coefficient tolerances are not approximate VOA axioms or a device-indepen ## Reproduce the selected certificates +The current exact checks and documentation checks use Python's standard library: + ```sh -python checks/verify_extraction_core.py -python checks/verify_calibration_and_sharpness.py -python checks/audit_quantitative_core.py -# Each script also runs unchanged with python -O and python -OO. +python verify_current.py ``` -The preserved core reports have 63 and 74 labeled checks. The final review adds 23 labeled controls, including exact interval and independent rational-oracle cases. No full Monster tensor is simulated. Passing finite checks is not a proof-assistant verification of the source theorems or an independent human review. +For the complete checker inventory and the separate historical comparisons, +use the [pinned reproduction environment](docs/REPRODUCIBILITY.md): -The historical `verify.py` and `checks/replay_portability.py` are unchanged. Their strict replay and bounded-portability outcomes are reported separately; a green overall job is not a claim of byte-identical historical floating-point output. +```sh +python -m pip install -r requirements-reproduce.txt +python verify_current.py --all +``` -## Earlier research and preservation +The wrapper runs each selected checker in normal, `-O`, and `-OO` modes and +compares the current exact report fingerprints. The original 63-, 74-, and +23-check evidence is retained at its recorded versions. The repaired calibration +has its own current fingerprint and additional scale-regression checks; see +[calibration precision](docs/CALIBRATION_PRECISION.md) and +[current report metadata](results/current_reports.json). -The earlier [physical-selection ledger](PHYSICS_STATUS.md), [claim ledger](STATUS.md), numbered research notes, immutable archives, code and recorded results remain available as historical research. Their older “current” labels do not supersede [the active work order](work_orders/CURRENT.md) or [the present status](docs/RESEARCH_STATUS.md). Unrelated pending branches are not merged merely to create this reader path. +The historical `verify.py` is **not** the current suite. Its strict byte replay +and the unchanged bounded-portability comparison are reported separately. +A historical floating-point mismatch remains a strict failure even when the +current exact suite and bounded comparison pass. The reproduction guide explains +exit codes and the optional strict-replay requirement. + +No full Monster tensor is simulated. Finite checks do not verify the imported +classification theorems or constitute independent human review. + +## Earlier research and preservation -Original code and documentation retain the owner's [MIT license](LICENSE). Imported mathematical results remain attributed to their authors. Research inquiries and corrections may be sent to Ruge Lin at gogoko699@gmail.com. +Use [the archive and pending-work index](docs/ARCHIVE.md) for older gate-testing, +circuit, and readout records. The dated ledgers now carry historical banners. +Their older “current” labels do not supersede +[the current scientific status](docs/RESEARCH_STATUS.md). Protected source notes, +provenance archives, and saved evidence remain available unchanged; legacy +mathematics may not render correctly in every GitHub viewer. + +[Release scope](docs/RELEASE.md), [the changelog](CHANGELOG.md), and +[citation metadata](CITATION.cff) describe the current research package without +claiming a manuscript, publication, DOI, or tagged release. For LLM-assisted +research, [the source map](llms.txt) points questions to the theorem, its exact +assumptions, teaching anchors, verification, and historical boundaries. + +Original code and documentation retain the owner's [MIT license](LICENSE). +Imported mathematical results remain attributed to their authors. **Manuscript +writing remains on hold.** Potential collaborators, readers with corrections, +and other research inquiries may contact Ruge Lin at gogoko699@gmail.com. diff --git a/STATUS_CURRENT.md b/STATUS_CURRENT.md index bc9c5a4..968a0ae 100644 --- a/STATUS_CURRENT.md +++ b/STATUS_CURRENT.md @@ -1,3 +1,5 @@ +> **Historical record, not the current project status.** The dated ledger below is preserved unchanged. Start with [current scientific status](docs/RESEARCH_STATUS.md), [the physics learning path](docs/learn/README.md), or [the archive index](docs/ARCHIVE.md). + # Current claim ledger — 25 September 2026 Latest continuation base: `85215c45005a3241485b99b57b2dc9de63b85702`. diff --git a/audits/calibration_scale_erratum.md b/audits/calibration_scale_erratum.md new file mode 100644 index 0000000..33bd9f2 --- /dev/null +++ b/audits/calibration_scale_erratum.md @@ -0,0 +1,52 @@ +# Calibration implementation erratum: positive small denominators + +Baseline: `ecd0623e9de41b49754b6ca16dc23752443143af`. +Affected code: `checks/verify_calibration_and_sharpness.py`. +The normalized-correlation theorem, calibration identities, and all physical +hypotheses and comparison tolerances are unchanged. + +## Reproduced defect + +For exact orthogonal Ising stress tensors $e,f$, let $w_1=s e$, $w_2=s f$ with +$s=2^{-39}$. The seven exact scalar inputs in the public function's order are + +```math +(s^2/4,\ s^2/4,\ s/4,\ s/4,\ s^3/2,\ s^3/2,\ 0). +``` + +Each projected norm is $(47/192)s^2$. The positive cross denominator equals +$(47/48)2^{-80}$, but the old absolute $2^{-80}$ grid gives it a zero lower +endpoint. The subsequent interval division raises `ValueError`. This is an +implementation exception on valid scaled inputs, not a false-positive +certificate or a counterexample to the analytic theorem. + +The [pinned audit report](https://github.com/GoGoKo699/Monster-Correlation-Rigidity/blob/62cba790ac69b8cf7ad339ad8d0aa21578366770/audits/release_sanity_20260927.md) +and its recorded runner logs preserve the original finding. + +## Correction and evidence + +`checks/scale_safe_roots.py` refines the dyadic grid using exact numerator and +denominator bit lengths. The [arithmetic proof](../docs/CALIBRATION_PRECISION.md) +shows that every positive accepted radicand receives a positive lower root bound +and an outward enclosure. The public calibration function returns an explicit +inconclusive result at the documented square-root work limit. + +`checks/verify_calibration_scales.py` reproduces the old zero-lower-endpoint +calculation without restoring the old bug. It tests the corrected public path +on exact and finite-width independently scaled pairs, very small/large scales, +known stress shifts, near-zero norm boundaries, negative signs, duplicate fields, +impossible couplings, and the resource-limit case. Existing calibration controls +and the adversarial rational/bisection audit are also rerun on the repaired code. + +The old 74-check stdout is not overwritten. The refined enclosures change that +output; [current report metadata](../results/current_reports.json) records the +new fingerprint separately. The earlier audit's source-hash expectation is +updated explicitly for the repaired source, while its mathematical and +implementation controls are retained. All historical source bytes remain +accessible at the baseline commit, and all pre-existing saved report files +remain unchanged. + +No Monte Carlo or full VOA simulation is used. A false or inconclusive answer +does not establish that the theory differs from moonshine. The certificate +continues to assume the exact ambient class, weight, real structure, and known +stress tensor; it does not infer those premises from the seven numbers. diff --git a/audits/release_preparation.md b/audits/release_preparation.md new file mode 100644 index 0000000..08d2b58 --- /dev/null +++ b/audits/release_preparation.md @@ -0,0 +1,77 @@ +# Release-preparation integration + +Base commit: `ecd0623e9de41b49754b6ca16dc23752443143af`. +Base tree: `20c5252c0bd5e83d6a908ee226e5799e947280fc`. +The repository owner authorized the bounded repairs from the pre-release audit +and modifications to the GitHub-facing documentation. No release, manuscript, +DOI, outreach, or unrelated research-branch merge is included. + +## Source and preservation + +A read-only GitHub Actions artifact supplied the exact baseline source archive. +Its 110 extracted files reproduced the baseline Git tree above. Local tests +therefore use the actual complete source bytes, not a hand-reconstructed subset. +Network Git cloning in the local container was unavailable. + +The release manifest declares every source change and addition and fingerprints +all other baseline files. Protected numbered research notes, provenance files, +original license, historical root verifier, bounded-portability policy, and all +pre-existing saved result files remain byte-identical. The gate-testing and +physical-selection ledgers retain their bodies below new historical banners. +The seed-protected `STATUS.md` remains wholly unchanged; the archive index +identifies it as historical. Canonical proof mathematics is +compared expression by expression; only provenance and implementation pointers +were added to those proofs. + +## Calibration correction + +The small-scale exception is fixed by scale-aware exact square-root enclosures. +The public function catches a typed precision-work-limit condition and returns +an explicit inconclusive result. The seven-scalar identities, physical premises, +and numerical comparison tolerances are unchanged. The original calibration +controls and independent bisection audit run on the corrected implementation. +The new scale checker covers exact and finite-width independently scaled fields, +stress shifts, tiny and large scales, sign/cap/duplicate controls, and the +resource-limit case. See [the erratum](calibration_scale_erratum.md). + +Current exact outputs are recorded separately in +[current report metadata](../results/current_reports.json). Old 74-check and +23-check report fingerprints remain as historical evidence, not falsely +relabelled as the current implementation's output. The extraction output is +unchanged. Normal, `-O`, and `-OO` outputs agree in the local exact-check replay. + +## Reader and reproduction repair + +The current wrapper separates selected exact checks, documentation checks, +historical strict replay, and bounded portability. A pinned reproduction file, +archive/pending-work index, citation metadata, source map, changelog, and release +scope accompany it. The old integration workflow still executes its complete +chain on the frozen pre-release tree; an additional job checks the real candidate +against that tree and runs the complete current suite. This is not a replacement +of the archived science by a formatting-only check. + +The desired About-sidebar description/topics are stored in +[repository metadata](../.github/repository_metadata.json). File creation does +not itself alter GitHub repository settings; no settings-write result is implied. + +## Verification boundaries + +The exact candidate's CI stdout/stderr is retained as a workflow artifact. +The pull-request validation record contains the actual final runner results, +including strict-versus-portability outcomes; an aggregate green workflow is not +a claim of strict byte identity. Local rendering uses Chromium/MathJax previews, +not GitHub's live browser. The active page inventory is explicit in the release +manifest; legacy rendering limitations remain documented in the archive index. + +These are implementation, preservation, and release-readiness checks, not a new +scientific campaign, independent human review, complete audit of the research +backlog, or proof-assistant verification. Manuscript writing remains on hold. + +## Integration regression caught before merge + +The first candidate added a historical banner to the seed-protected `STATUS.md`. +The complete CI suite correctly rejected that edit through the unchanged +provenance verifier. The banner was removed and the exact original file restored; +`STATUS.md` is now also explicitly protected by the current integrity check. +No historical checker, source hash, or numerical tolerance was weakened to +accept the edit. Current readers are directed through the archive index instead. diff --git a/checks/audit_quantitative_core.py b/checks/audit_quantitative_core.py index e283a9e..71e912b 100644 --- a/checks/audit_quantitative_core.py +++ b/checks/audit_quantitative_core.py @@ -193,13 +193,14 @@ def calibration_audit(): def main(): files={'verify_extraction_core.py':'d2062b1577beb7a34c0665fc358da7b1daf846886cd48dfa0b26acf83c107e83', - 'verify_calibration_and_sharpness.py':'d2c16a6c9c01af9d1198cfc2b4459d78966a42c314b8a0575bd37626bcd2eef1'} + 'verify_calibration_and_sharpness.py':'7a2b98dab6df116ea804706d75e8fb5a0d246ea889f6381f13e88dd85bedbb5a'} for path,h in files.items(): need(hashlib.sha256(Path(__file__).with_name(path).read_bytes()).hexdigest()==h, 'preservation:'+path) structural_identities(); interval_audit(); calibration_audit() print(json.dumps({'status':'PASS bounded adversarial implementation and normalization checks', - 'reviewed_head':'6d460bef7041f17cba1658c99d6797ef4b00275c', + 'original_reviewed_head':'6d460bef7041f17cba1658c99d6797ef4b00275c', + 'implementation_scope':'scale-safe calibration repair; original controls retained', 'checks':len(LABELS),'labels':LABELS,'case_counts':COUNTS, 'arithmetic':'rational arithmetic; independent bisection oracle', 'largest_physical_coefficient_vector':3,'full_VOA_simulated':False, diff --git a/checks/release_integrity.py b/checks/release_integrity.py new file mode 100644 index 0000000..cc19cfb --- /dev/null +++ b/checks/release_integrity.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +"""Current file integrity with a separate, immutable pre-release baseline. + +The manifest declares an intentional delta; it is not a cryptographic proof +of the mathematical results. Historical manifests are never rewritten here. +""" +from __future__ import annotations +import argparse +import hashlib +import json +from pathlib import Path +import re +import subprocess + +ROOT = Path(__file__).resolve().parents[1] +MANIFEST = 'results/release_preparation.json' +BASE = 'ecd0623e9de41b49754b6ca16dc23752443143af' +BASE_TREE = '20c5252c0bd5e83d6a908ee226e5799e947280fc' +PROOFS = ('research/uniform_extraction_core.md', 'research/sharpness_and_calibration.md') + + +def require(ok: bool, message: str) -> None: + if not ok: + raise RuntimeError(message) + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def safe(root: Path, name: str) -> Path: + relative = Path(name) + require(not relative.is_absolute() and '..' not in relative.parts, 'Unsafe manifest path') + path = root / relative + require(path.resolve().is_relative_to(root.resolve()) and not path.is_symlink(), + 'Escaping or symbolic manifest path: ' + name) + return path + + +def tracked(root: Path) -> set[str] | None: + # An exported source ZIP is also a supported verification input. + if not (root / '.git').exists(): + return None + raw = subprocess.check_output(['git', '-C', str(root), 'ls-files', '-z']) + return set(filter(None, raw.decode().split('\0'))) + + +def protected(name: str) -> bool: + return (name in ('LICENSE', 'STATUS.md', 'verify.py', 'checks/replay_portability.py') + or name.startswith('provenance/') + or bool(re.match(r'research/\d\d_', name)) + or name.startswith('results/')) + + +def verify_files(root: Path = ROOT, baseline: Path | None = None) -> dict: + root = root.resolve() + m = json.loads((root / MANIFEST).read_text()) + require(m['base_commit'] == BASE and m['base_tree'] == BASE_TREE, + 'Unexpected release-preparation baseline') + groups = [m[k] for k in ('modified', 'added', 'preserved')] + entries = [item for group in groups for item in group] + names = [e['path'] for e in entries] + require(len(names) == len(set(names)) and MANIFEST not in names, + 'Duplicate or self-referential release manifest') + require(not any(protected(e['path']) for e in m['modified']), + 'Protected historical source or evidence declared modified') + for e in entries: + raw = safe(root, e['path']).read_bytes() + require(len(raw) == e['bytes'] and sha(raw) == e['sha256'], + 'Current fingerprint mismatch: ' + e['path']) + index = tracked(root) + if index is not None: + require(index == set(names) | {MANIFEST}, 'Tracked-file inventory mismatch') + # The seed-era snapshot is still usable by the unchanged root verifier. + snapshot = json.loads((root / 'snapshot_manifest.json').read_text()) + for e in snapshot['files']: + raw = safe(root, e['path']).read_bytes() + require(len(raw) == e['bytes'] and sha(raw) == e['sha256'], + 'Current seed snapshot mismatch: ' + e['path']) + if baseline is not None: + baseline = baseline.resolve() + require(baseline != root, 'The current tree cannot be its own baseline') + old_names = {e['path'] for e in m['modified'] + m['preserved']} + old_index = tracked(baseline) + if old_index is not None: + require(old_index == old_names, 'Baseline inventory mismatch') + old_tree = subprocess.check_output( + ['git', '-C', str(baseline), 'write-tree'], text=True).strip() + require(old_tree == BASE_TREE, 'Wrong baseline Git tree') + for e in m['modified']: + require(sha(safe(baseline, e['path']).read_bytes()) == e['previous_sha256'], + 'Pre-change source mismatch: ' + e['path']) + for e in m['preserved']: + require(safe(baseline, e['path']).read_bytes() == safe(root, e['path']).read_bytes(), + 'Preserved baseline file changed: ' + e['path']) + from verify_display import inspect_page + for name in PROOFS: + old = inspect_page((baseline / name).read_text(), name) + new = inspect_page((root / name).read_text(), name) + require(old == new, 'Canonical proof mathematics changed: ' + name) + for name in ('STATUS_CURRENT.md', 'PHYSICS_STATUS.md'): + body = (root / name).read_text().split('\n\n', 1)[1] + require(body == (baseline / name).read_text(), 'Historical ledger body changed: ' + name) + return {'files': len(entries) + 1, 'baseline_compared': baseline is not None, + 'base_commit': BASE, 'mathematical_theorems_verified': False} + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--baseline', type=Path) + args = parser.parse_args() + print(json.dumps({'status': 'PASS current release-source integrity', + **verify_files(baseline=args.baseline)}, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/checks/scale_safe_roots.py b/checks/scale_safe_roots.py new file mode 100644 index 0000000..08321e8 --- /dev/null +++ b/checks/scale_safe_roots.py @@ -0,0 +1,40 @@ +"""Exact outward square-root bounds with scale-aware dyadic precision. + +This is arithmetic support, not a test of the supplied physical premises. +""" +from fractions import Fraction as Q +from math import isqrt + +MAX_ROOT_BITS = 16384 + + +class SquareRootPrecisionLimit(ArithmeticError): + """The required dyadic denominator exceeds the declared work budget.""" + + +def sqrt_bounds(x: Q, bits: int = 80) -> tuple[Q, Q]: + """Enclose sqrt(x), retaining positive lower bounds for positive x. + + `bits` controls relative resolution for small values and absolute + resolution for values at least one. Only exact rational inputs are used. + Exceeding MAX_ROOT_BITS raises a typed, recoverable precision exception. + """ + if isinstance(bits, bool) or not isinstance(bits, int): + raise TypeError('integer bit count required') + if not isinstance(x, (int, Q)) or isinstance(x, bool): + raise TypeError('exact integer or Fraction radicand required') + x = Q(x) + if x < 0 or bits < 0: + raise ValueError('nonnegative radicand and bit count required') + if x == 0: + return Q(0), Q(0) + gap = x.denominator.bit_length() - x.numerator.bit_length() + extra = max(0, (gap + 2) // 2) + precision = bits + extra + if precision > MAX_ROOT_BITS: + raise SquareRootPrecisionLimit('square-root precision budget exceeded') + d = 1 << precision + k = isqrt(x.numerator * d * d // x.denominator) + lo = Q(k, d) + hi = lo if lo * lo == x else Q(k + 1, d) + return lo, hi diff --git a/checks/verify_calibration_and_sharpness.py b/checks/verify_calibration_and_sharpness.py index a553e5b..110c36e 100644 --- a/checks/verify_calibration_and_sharpness.py +++ b/checks/verify_calibration_and_sharpness.py @@ -8,7 +8,10 @@ from __future__ import annotations from dataclasses import dataclass from fractions import Fraction as Q -from math import isqrt +if __package__: + from .scale_safe_roots import sqrt_bounds, SquareRootPrecisionLimit +else: + from scale_safe_roots import sqrt_bounds, SquareRootPrecisionLimit import json BASE = '09e3f98ad79034eefab43f4fb9ea432368fc19e7' @@ -21,15 +24,6 @@ def need(ok: bool, label: str) -> None: LABELS.append(label) -def sqrt_bounds(x: Q, bits: int = 80) -> tuple[Q, Q]: - if x < 0 or bits < 0: - raise ValueError('nonnegative radicand and bit count required') - d = 1 << bits - k = isqrt(x.numerator * d * d // x.denominator) - lo = Q(k, d) - hi = lo if lo * lo == x else Q(k + 1, d) - return lo, hi - @dataclass(frozen=True) class Interval: @@ -96,7 +90,7 @@ def contains(self, x) -> bool: return self.lo <= x <= self.hi -def calibrated_criterion(n1: Interval, n2: Interval, tau1: Interval, +def _calibrated_criterion(n1: Interval, n2: Interval, tau1: Interval, tau2: Interval, q1: Interval, q2: Interval, mutual: Interval) -> dict: """Conservative sufficient test on seven certified scalar intervals. @@ -130,6 +124,26 @@ def calibrated_criterion(n1: Interval, n2: Interval, tau1: Interval, 'premises_tested_by_this_program': False} +def calibrated_criterion(n1: Interval, n2: Interval, tau1: Interval, + tau2: Interval, q1: Interval, q2: Interval, + mutual: Interval) -> dict: + """Apply the sufficient criterion with scale-aware exact root enclosures. + + Exact physical premises remain supplied, not verified. A work-budget + limit returns an explicit inconclusive result. Invalid input types and + malformed intervals are not disguised as physical certification failures. + """ + values = (n1, n2, tau1, tau2, q1, q2, mutual) + if not all(isinstance(v, Interval) for v in values): + raise TypeError('seven exact Interval inputs required') + try: + return _calibrated_criterion(*values) + except SquareRootPrecisionLimit: + return {'certified': False, + 'reason': 'inconclusive: square-root precision budget exceeded', + 'premises_tested_by_this_program': False} + + # Three commuting stress components, charges 1/2,1/2,23. This is the weight-two # subalgebra generated by an orthogonal Ising pair and ambient omega, not an # assumed tensor-product decomposition of the entire moonshine theory. diff --git a/checks/verify_calibration_scales.py b/checks/verify_calibration_scales.py new file mode 100644 index 0000000..2a2c5f4 --- /dev/null +++ b/checks/verify_calibration_scales.py @@ -0,0 +1,126 @@ +#!/usr/bin/env python3 +"""Regression tests for the audited small-scale calibration exception. + +Exact scalar families only; no full VOA construction or theorem simulation. +""" +from fractions import Fraction as Q +from math import isqrt +import json +from verify_calibration_and_sharpness import Interval as I, calibrated_criterion +from scale_safe_roots import sqrt_bounds, SquareRootPrecisionLimit, MAX_ROOT_BITS + +LABELS = [] + + +def need(ok, label): + if not ok: + raise RuntimeError(label) + LABELS.append(label) + + +def pair(k, ell, radius=Q(0), shift1=Q(0), shift2=Q(0)): + s, t = Q(2)**(-k), Q(2)**(-ell) + # w1 = s e + shift1*omega; w2 = t f + shift2*omega. + def raw(scale, shift): + n = scale**2/4 + scale*shift/2 + 12*shift**2 + tau = scale/4 + 12*shift + cubic = scale**3/2 + Q(3,2)*scale**2*shift + Q(3,2)*scale*shift**2 + 24*shift**3 + return n, tau, cubic + n1, a1, c1 = raw(s, shift1) + n2, a2, c2 = raw(t, shift2) + mutual = s*shift2/4 + t*shift1/4 + 12*shift1*shift2 + values = (n1, n2, a1, a2, c1, c2, mutual) + weights = (s*s, t*t, s, t, s**3, t**3, s*t) + return [I.radius(v, radius*w) for v, w in zip(values, weights)] + + +def root_tests(): + # An exact squared inequality checks containment without another sqrt call. + for bits in (0, 1, 8, 80): + for p in range(1, 20): + for q in range(1, 20): + x = Q(p, q) + lo, hi = sqrt_bounds(x, bits) + need(0 < lo <= hi and lo*lo <= x <= hi*hi, + f'root:{bits}:{p}:{q}') + need(hi-lo <= max(Q(1), hi)/2**bits, + f'root_resolution:{bits}:{p}:{q}') + for k in (-4096, -512, -100, 0, 39, 100, 512, 4096): + x = Q(47, 192) * Q(2)**(2*k) + lo, hi = sqrt_bounds(x) + need(0 < lo and lo*lo <= x <= hi*hi, f'root_extreme:{k}') + need(sqrt_bounds(Q(0)) == (0, 0), 'root:zero') + for x, bits in ((Q(-1), 80), (Q(1), -1), (Q(1), 1.5)): + try: + sqrt_bounds(x, bits) + except (ValueError, TypeError): + need(True, f'root:invalid:{x}:{bits}') + else: + raise RuntimeError('invalid square-root argument accepted') + # Reproduce the old absolute-grid failure without altering the new function. + N = Q(47, 192) * Q(2)**(-78) + old_k = isqrt((N*N).numerator * 2**160 // (N*N).denominator) + need(old_k == 0 and N > 0, 'old_absolute_grid:zero_lower_bound_reproduced') + need(sqrt_bounds(N*N)[0] > 0, 'adaptive_grid:positive_lower_bound') + try: + sqrt_bounds(Q(2)**(-2*(MAX_ROOT_BITS+1))) + except SquareRootPrecisionLimit: + need(True, 'root:typed_budget_limit') + else: + raise RuntimeError('precision limit not enforced') + + +def calibration_tests(): + powers = (-512, -100, 0, 10, 38, 39, 40, 60, 100, 512, 4096) + cases = [(k, k) for k in powers] + [(k, -k) for k in powers] + cases += [(39, 40), (40, 100), (100, 512)] + cases = list(dict.fromkeys(cases)) + for k, ell in cases: + result = calibrated_criterion(*pair(k, ell)) + need(result['certified'], f'pair_exact:{k}:{ell}') + for index, f in enumerate(result['self_coupling_intervals']): + need(f.lo > 0 and f.lo*f.lo <= Q(2116,141) <= f.hi*f.hi, + f'cap_inclusion:{k}:{ell}:{index}') + need(result['primary_overlap_interval'].contains(-Q(1,47)), + f'overlap_inclusion:{k}:{ell}') + need(result['budget_upper'] < Q(3,188), f'budget:{k}:{ell}') + noisy = calibrated_criterion(*pair(k, ell, Q(1,10**12))) + need(noisy['certified'], f'pair_intervals:{k}:{ell}') + wider = calibrated_criterion(*pair(k, ell, Q(1,10))) + need(not wider['certified'], f'wide_intervals_inconclusive:{k}:{ell}') + for k, ell in ((0,0), (39,40), (100,512), (-100,60)): + answer = calibrated_criterion(*pair(k, ell, shift1=Q(1), shift2=-Q(2))) + need(answer['certified'], f'exact_stress_shift:{k}:{ell}') + args = pair(0,0) + args[0] = I(Q(0), args[0].hi) + need(not calibrated_criterion(*args)['certified'], 'norm_interval_reaches_zero') + args = [I.point(v) for v in (12,Q(1,4),12,Q(1,4),24,Q(1,2),Q(1,4))] + need(not calibrated_criterion(*args)['certified'], 'pure_stress_not_normalized') + args = pair(0,0) + args[2], args[4] = -args[2], -args[4] + need(not calibrated_criterion(*args)['certified'], 'negative_sign_not_changed') + args = pair(0,0) + args[-1] = I.point(Q(1,4)) + need(not calibrated_criterion(*args)['certified'], 'duplicate_pair_rejected') + args = pair(0,0) + args[4] = I.point(100) + need(not calibrated_criterion(*args)['certified'], 'impossible_coupling_rejected') + answer = calibrated_criterion(*pair(20000,20000)) + need(not answer['certified'] and 'precision budget' in answer['reason'], + 'resource_limit_is_explicit_inconclusive') + return len(cases) + + +def main(): + root_tests() + pairs = calibration_tests() + need(len(LABELS) == len(set(LABELS)), 'unique_regression_labels') + print(json.dumps({'status':'PASS scale-aware calibration regression', + 'checks':len(LABELS),'labels':LABELS, + 'scale_pairs':pairs,'largest_field_scale_power':4096, + 'resource_limit_probe_power':20000, + 'largest_physical_coefficient_vector':3, + 'full_VOA_simulated':False}, sort_keys=True, indent=2)) + +if __name__ == '__main__': + main() diff --git a/checks/verify_display.py b/checks/verify_display.py index f3d665d..2d1cecf 100644 --- a/checks/verify_display.py +++ b/checks/verify_display.py @@ -152,6 +152,8 @@ def split_fences(text: str, name: str) -> list[tuple[str, str]]: def inspect_page(text: str, name: str, root: Path | None = None) -> list[dict]: + require(not any(ord(c) < 32 and c not in '\n\r\t' for c in text), + 'Unexpected control character in Markdown: ' + name) require(not any(s.rstrip() != s for s in text.splitlines()), 'Trailing whitespace: ' + name) require(text.count('
') == text.count('
'), 'Unclosed details: ' + name) corpus, outside = [], [] @@ -195,7 +197,7 @@ def negative_controls() -> int: tests += [r'$x=1', 'A bare sqrt(141) remains.', '```math\nx=1\n', '```math\nx=1\n~~~', '```Math\nx=1\n```', '```math\n$x$\n```', '```math extra\nx=1\n```', - '```python\nx=1\n', r'$\frac{1}{2$'] + '```python\nx=1\n', r'$\frac{1}{2$', '```math\nx=\x0crac{1}{2}\n```'] for s in tests: try: inspect_page(s, PROOFS[0]) @@ -223,6 +225,12 @@ def positive_controls() -> int: def main() -> None: + # Historical style manifests remain frozen; current packaging is checked + # against its separately declared source delta, not by rewriting old hashes. + if (ROOT/'results/release_preparation.json').is_file(): + from verify_release_package import main as release_main + release_main() + return parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--baseline', type=Path) parser.add_argument('--export-math', type=Path) diff --git a/checks/verify_release_package.py b/checks/verify_release_package.py new file mode 100644 index 0000000..5ec37e3 --- /dev/null +++ b/checks/verify_release_package.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +"""Validate the active reader package, not live browser rendering or VOA axioms.""" +from __future__ import annotations +import argparse +import hashlib +import json +from pathlib import Path +import re +from urllib.parse import unquote, urlsplit +from release_integrity import ROOT, MANIFEST, verify_files, require +from verify_display import inspect_page, split_fences, negative_controls, positive_controls + + +def corpus_for(root: Path, pages: list[str]) -> list[dict]: + corpus = [] + for name in pages: + text = (root / name).read_text() + require(all('$$' not in s for kind, s in split_fences(text, name) if kind != 'code'), + 'Active displays must use math fences: ' + name) + corpus.extend(inspect_page(text, name, root)) + return corpus + + +def corpus_digest(corpus: list[dict]) -> str: + data = json.dumps(corpus, sort_keys=True, separators=(',', ':')).encode() + return hashlib.sha256(data).hexdigest() + + +def all_links(root: Path) -> int: + count = 0 + for path in sorted(root.rglob('*.md')): + if any(x in path.relative_to(root).parts for x in ('.git', '.venv', 'node_modules')): + continue + # This file-level scan includes historical pages without rewriting them. + text = '\n'.join(s for kind, s in split_fences(path.read_text(), str(path)) if kind == 'prose') + for link in re.findall(r'\[[^\]]+\]\(([^)\s]+)\)', text): + u = urlsplit(link) + if u.scheme or u.netloc or not u.path: + continue + target = (path.parent / unquote(u.path)).resolve() + require(target.is_relative_to(root.resolve()) and target.is_file(), + 'Broken repository link: ' + str(path.relative_to(root)) + ' -> ' + link) + count += 1 + return count + + +def metadata(root: Path) -> None: + # Structural checks only; this is not an implementation of the full CFF schema. + cff = (root / 'CITATION.cff').read_text() + for field in ('cff-version: 1.2.0', 'authors:', 'title:', 'repository-code:', 'license: MIT'): + require(field in cff, 'Missing citation field: ' + field) + require('doi:' not in cff and 'date-released:' not in cff, 'Unissued DOI/release date in citation') + about = json.loads((root / '.github/repository_metadata.json').read_text()) + require(0 < len(about['description']) <= 350, 'Invalid About description') + require(0 < len(about['topics']) <= 20 and len(set(about['topics'])) == len(about['topics']), + 'Invalid or duplicate topics') + require(all(re.fullmatch(r'[a-z0-9-]{1,50}', t) for t in about['topics']), 'Invalid topic syntax') + require('numpy==2.3.5' in (root / 'requirements-reproduce.txt').read_text(), 'Missing reproduction pin') + require('## Unreleased' in (root / 'CHANGELOG.md').read_text(), 'Missing unreleased changelog') + source_map = (root / 'llms.txt').read_text() + require('Gaberdiel' in source_map and 'Yamauchi' in source_map, 'Teaching anchors not retained') + for p in ('STATUS_CURRENT.md', 'PHYSICS_STATUS.md'): + require((root / p).read_text().startswith('> **Historical record'), 'Missing historical banner') + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--baseline', type=Path) + parser.add_argument('--export-math', type=Path) + args = parser.parse_args() + integrity = verify_files(baseline=args.baseline) + m = json.loads((ROOT / MANIFEST).read_text()) + corpus = corpus_for(ROOT, m['active_pages']) + expected = m['math_corpus'] + require(len(corpus) == expected['expressions'] and + sum(e['display'] for e in corpus) == expected['display_equations'] and + corpus_digest(corpus) == expected['sha256'], 'Unexpected or omitted mathematics') + from verify_teaching import arithmetic, documents, LABELS + LABELS.clear(); arithmetic(); documents(ROOT) + nc, pc = negative_controls(), positive_controls() + links = all_links(ROOT) + metadata(ROOT) + if args.export_math: + require(not args.export_math.resolve().is_relative_to(ROOT.resolve()), + 'Export mathematics outside the checkout') + args.export_math.write_text(json.dumps(corpus, indent=2) + '\n') + print(json.dumps({'status': 'PASS current release package and active math', + 'pages': len(m['active_pages']), 'math_expressions': len(corpus), + 'display_equations': sum(e['display'] for e in corpus), + 'negative_controls': nc, 'positive_controls': pc, + 'teaching_checks': len(LABELS), 'relative_links': links, + 'integrity': integrity, 'live_GitHub_render_verified': False, + 'full_CFF_schema_validation': False}, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/docs/ARCHIVE.md b/docs/ARCHIVE.md new file mode 100644 index 0000000..b795f76 --- /dev/null +++ b/docs/ARCHIVE.md @@ -0,0 +1,57 @@ +# Archive and pending-work index + +[Overview](../README.md) · [Current scientific status](RESEARCH_STATUS.md) · [Reproduction](REPRODUCIBILITY.md) + +## The active path + +The released-science scope, when a release is tagged, is the +[quantitative correlation criterion](../research/uniform_extraction_core.md) +and [sharpness/calibration](../research/sharpness_and_calibration.md). +Start learning with [Gaberdiel and the physics lessons](learn/README.md), using +Yamauchi only as the secondary algebraic supplement. + +**Only [Current scientific status](RESEARCH_STATUS.md) is authoritative for the +present project.** The older ledgers below describe earlier research directions. +They are preserved as records, not silently reinterpreted as current claims. + +## Historical research on main + +| Records | What they contain | +|---|---| +| [Import-era ledger](../STATUS.md), [gate-testing ledger](../STATUS_CURRENT.md), [physical-selection ledger](../PHYSICS_STATUS.md) | Dated scope and claim decisions from before selection of the current core. | +| [Notes 01](../research/01_local_rigidity.md), [02](../research/02_pair_correlations.md), [03](../research/03_uniform_axis_rounding.md), [04](../research/04_average_transport.md), [05](../research/05_normalizer_rounding.md) | Protected original local/global gate-rigidity and transport derivations. | +| [Notes 06](../research/06_probe_access.md), [07](../research/07_seysen_qqa_block.md), [08](../research/08_leech_xxa_block.md), [09](../research/09_jordan_and_a0_sector.md) | Access assumptions and bounded circuit constructions, not a complete practical Monster test. | +| [Notes 10](../research/10_normalizer_stability_comparison.md), [11](../research/11_pair_test_prior_art_and_conditioning.md) | Earlier normalizer and support-test comparisons and their limitations. | +| [Notes 12](../research/12_physical_selection_from_extremality.md), [13](../research/13_weight_three_ope_channel.md), [14](../research/14_weight_four_and_four_point_closure.md) | Physical-selection and higher-weight/OPE investigations that are not dependencies of the current core. | +| [VOA audit](../audits/voa_extrema_audit.md), [robustness audit](../audits/robustness_proof_audit.md) | Earlier corrections and their source-interface depth. Consult these before relying on an uncorrected historical statement. | +| [Replay erratum](../audits/physical_integration_replay_erratum.md), [integration dossier](BOUNDED_CORE_STATUS.md) | Recorded verification and integration stages, not current release announcements. | + +**Legacy rendering:** all fourteen numbered notes and the two older mathematical +audits retain their original notation. Some macros can fail in GitHub viewers. +Use the source view for those records. The protected notes and provenance ZIPs +have not been rewritten to conceal either display defects or scientific errata. +The active learning/proof path uses the approved native-math display style. + +The [license/source notice](../COPYING.md) describes retained archives and +external attribution. Frozen manifests must be checked against their own +recorded versions; do not overwrite them to match a later layout change. + +## Pending branches are not released dependencies + +The links below point to fixed commits, so they remain unambiguous even if a +branch later changes. They identify provenance or separate work, **not a review +or a merge of those proposals**. + +| Record | Fixed destination | Relation to the current theorem | +|---|---|---| +| Earlier two-field bridge, PR23 | [Selection note](https://github.com/GoGoKo699/Monster-Correlation-Rigidity/blob/ac5acad7cad4a63f0d879e4ea716f5a27c3bcd61/research/two_field_selection.md) | Historical provenance. The active core states its own proof and does not require this unmerged file. | +| Extended-six-sevenths proposal, PR27 | [Existence proposal](https://github.com/GoGoKo699/Monster-Correlation-Rigidity/blob/576fd31b53862d0b7667a723330ae27c859cc774/research/extended_six_sevenths_forces_ising.md) | Separate proposed sufficient hypothesis; not a premise or certified part of the release scope. | +| General-readout scope audit, PR22 | [Readout comparison](https://github.com/GoGoKo699/Monster-Correlation-Rigidity/blob/d2b85266d4273ae7c6ce32d87e0b6060a881b87e/audits/readout_scope_audit.md) | Separate readout question; not the Monster-specific identification claim selected here. | + +Other pending pull requests remain separate as well. The release is not a +certification of the full research backlog. Manuscript writing remains on hold. + +The import-era `STATUS.md` is protected by the original seed verifier and remains +byte-identical, including its dated headings. Use this index and the current +scientific-status page rather than interpreting its old “current” label as a +statement about the release candidate. diff --git a/docs/BOUNDED_CORE_STATUS.md b/docs/BOUNDED_CORE_STATUS.md index be3565a..1a16c17 100644 --- a/docs/BOUNDED_CORE_STATUS.md +++ b/docs/BOUNDED_CORE_STATUS.md @@ -1,3 +1,5 @@ +> **Historical integration-stage dossier.** For the active theorem and current code use [current status](RESEARCH_STATUS.md) and [reproduction](REPRODUCIBILITY.md). Old fingerprint and “remaining integration” statements below describe their recorded version, not today's release candidate. + > Integration note (26 September 2026): PR28 is now merged. The dated text below records its pre-integration stage. See [current scientific status](RESEARCH_STATUS.md) and [the final bounded review](../audits/final_quantitative_review.md) for the active disposition. # Bounded research core: status and remaining integration work diff --git a/docs/CALIBRATION_PRECISION.md b/docs/CALIBRATION_PRECISION.md new file mode 100644 index 0000000..dc0821f --- /dev/null +++ b/docs/CALIBRATION_PRECISION.md @@ -0,0 +1,77 @@ +# Scale-safe calibration arithmetic + +[Overview](../README.md) · [Calibration identities](../research/sharpness_and_calibration.md) · [Reproduction](REPRODUCIBILITY.md) + +## What was repaired + +The exact seven-scalar identities do not depend on a field's positive overall +scale. The original square-root implementation nevertheless used a fixed +absolute dyadic grid. For very small positive norms, its lower square-root bound +could become zero and cause division by an interval containing zero. + +The current `sqrt_bounds` chooses the grid from the size of the exact rational +radicand. It never replaces exact interval arithmetic with floating point, and +it never changes the theorem's comparison thresholds. The +[implementation erratum](../audits/calibration_scale_erratum.md) gives the concrete +failing input and separates the code correction from the unchanged theorem. + +## Why the lower bound stays positive + +Write a positive rational as $x=p/q$, with positive integers $p,q$. Let $g$ be +the bit length of $q$ minus the bit length of $p$. Then + +```math +x>2^{-g-1}. +``` + +For the requested bit count $b$, the implementation sets + +```math +h=\frac{1}{2^{b+e}}, +\qquad e=\max\left(0,\left\lfloor\frac{g+2}{2}\right\rfloor\right). +``` + +Consequently $x\,2^{2e}>1$, so even when $b=0$ the lower grid point is positive. +An integer square root computes + +```math +k=\left\lfloor\sqrt{\left\lfloor x/h^2\right\rfloor}\right\rfloor. +``` + +The returned lower endpoint is $kh$. The upper endpoint is the same number +when its square equals $x$, and otherwise $(k+1)h$. Therefore + +```math +0 Integration note (26 September 2026): PR28 is now merged. The dated text below records its pre-integration stage. See [current scientific status](RESEARCH_STATUS.md) and [the final bounded review](../audits/final_quantitative_review.md) for the active disposition. - # Quantitative correlation criterion: research entry -Manuscript writing remains on hold. This page is an entry to the completed proof records and their stated review boundaries, not manuscript prose. - -The selected claim is a sufficient, uniform criterion in an **exact** unitary rational C2-cofinite holomorphic VOA of CFT type with c=24 and no weight-one states. Near-maximal self-three-point coefficients of two actual real unit primary fields, together with a near-orthogonal-Ising overlap, force exact orthogonal Ising subalgebras and then the ambient moonshine VOA by a prior theorem. - -Read the [self-contained theorem and proof](../research/uniform_extraction_core.md) first. The [sharpness and calibration note](../research/sharpness_and_calibration.md) proves the optimal field-distance exponent and gives exact stress/norm correction for seven scalar inputs. The [direct contribution comparison](../audits/quantitative_contribution_verdict.md) credits the older variational and classification results and states the bounded priority verdict. The [background claim ledger](background_claims.md) separates evidence for eventual framing from draft prose. The [status map](BOUNDED_CORE_STATUS.md) records remaining review and integration work. - -The theorem does not prove that every theory in the bare class is moonshine, infer exact axioms from experimental data, find the relevant fields efficiently, or establish optimal numerical tolerances. Its square-root extraction exponent is sharp; the new calibration result retains exact grade-two, real-field, and known-stress assumptions. All source classification theorems remain attributed. +[Overview](../README.md) · [Current status](RESEARCH_STATUS.md) · [Physics learning path](learn/README.md) -## Reproduction +The active theorem and its exact hypotheses are in the +[self-contained core proof](../research/uniform_extraction_core.md). +[Sharpness and calibration](../research/sharpness_and_calibration.md) supplies the +optimal field-distance exponent and seven-scalar preprocessing identities. +The [precision implementation note](CALIBRATION_PRECISION.md) describes the +scale-safe arithmetic used by the current code. -```sh -python checks/verify_extraction_core.py -python -O checks/verify_extraction_core.py -python -OO checks/verify_extraction_core.py -python checks/verify_calibration_and_sharpness.py -python -O checks/verify_calibration_and_sharpness.py -python -OO checks/verify_calibration_and_sharpness.py -``` +Read [the contribution comparison](../audits/quantitative_contribution_verdict.md) +for the role of prior variational methods and classification theorems. It is a +bounded scholarly assessment, not an exhaustive originality guarantee. -The first report has63 labelled checks; the second has74. Compare the exact stdout hashes with `results/quantitative_core_reports.json`. These are rational/polynomial controls, not a full Monster simulation or formal verification of the source theorems. The standalone checkpoint also includes the complete emitted JSON reports and a file-hash verifier. +Run `python verify_current.py`. The [reproduction guide](REPRODUCIBILITY.md) +explains current report fingerprints, frozen evidence, and the historical +floating-point replay distinction. A failed sufficient certificate does not +exclude moonshine, and coefficient checks do not verify the ambient VOA axioms. -The additive candidate preserves every pre-existing main file, including historical notes, data, root verification, portability policy and the original MIT license. No unrelated pending branch is integrated by this reader path. Refer to the actual integration record and workflow logs for strict historical byte replay versus bounded portability; a green job alone is not evidence of strict byte identity. +The older integration-stage version of this page is retained in +[the pinned pre-release tree](https://github.com/GoGoKo699/Monster-Correlation-Rigidity/blob/ecd0623e9de41b49754b6ca16dc23752443143af/docs/QUANTITATIVE_CORE.md). +Manuscript writing remains on hold. diff --git a/docs/RELEASE.md b/docs/RELEASE.md new file mode 100644 index 0000000..9262d45 --- /dev/null +++ b/docs/RELEASE.md @@ -0,0 +1,48 @@ +# Release scope + +[Overview](../README.md) · [Current status](RESEARCH_STATUS.md) · [Changelog](../CHANGELOG.md) + +## Research package, not a manuscript + +This package contains the selected quantitative correlation-identification +proof, sharpness and calibration results, the physics-first tutorial path, +finite verification code, attributed source comparisons, and preserved research +history. These notes prepare a future tagged release; they do not create or +announce a tag, DOI, publication, or manuscript. + +The criterion is conditional on an exact simple unitary rational C2-cofinite +holomorphic VOA of CFT type, central charge 24, no weight-one states, and actual +fields with the stated properties. Its classification endpoint belongs to +Abe–Lam–Yamada. Neither an experimental device nor all ambient axioms are +identified by three untrusted measurements. + +## Changes since the pre-release audit + +The calibration routine now uses scale-aware exact root enclosures and returns +an explicit inconclusive result at its work limit. The current verification +entry point separates exact certificates, documentation, historical strict +replay, and bounded portability. Pinned reproduction requirements, current +fingerprints, citation metadata, and a source map accompany the code. + +The historical ledgers have visible status banners. Pinned links replace +ambiguous references to unmerged work. The active path retains the approved +Hopf-style native mathematics, Gaberdiel as the primary anchor, and Yamauchi as +the secondary supplement. Original protected notes, archives, and saved reports +remain intact. + +## Boundaries to retain in a future release announcement + +The code and mathematical checks do not verify imported classifications or +constitute independent human/formal review. Generic variational methods and +exact Ising-pair classification remain attributed to prior work. The square-root +exponent is sharp; the numerical tolerances are sufficient, not claimed optimal. +No practical field-finding algorithm or sample-complexity result is supplied. + +Historical floating-point byte replay may fail while the separate bounded +comparison passes; see [reproduction](REPRODUCIBILITY.md). Legacy archive pages +may contain unsupported macros; see [the archive index](ARCHIVE.md). Neither +limitation should be relabeled a successful strict or universal rendering test. + +The original MIT license remains in force. Questions, corrections, and potential +collaborations may be addressed to Ruge Lin at gogoko699@gmail.com. +**Manuscript writing remains on hold.** diff --git a/docs/REPRODUCIBILITY.md b/docs/REPRODUCIBILITY.md new file mode 100644 index 0000000..d5db5b0 --- /dev/null +++ b/docs/REPRODUCIBILITY.md @@ -0,0 +1,103 @@ +# Reproduce the current research package + +[Overview](../README.md) · [Current status](RESEARCH_STATUS.md) · [Archive index](ARCHIVE.md) + +## The current command + +From the repository root, run: + +```sh +python verify_current.py +``` + +This standard-library-only suite checks current file integrity, the selected +extraction proof's finite certificate, the calibration/sharpness certificate, +the adversarial core controls, the scale regressions, and active documentation. +Each checker runs in normal Python, `-O`, and `-OO`. Differences between those +outputs or a mismatching current exact fingerprint fail the command. + +The recorded environment is **Python 3.13.5**. A virtual environment is recommended +but no third-party package is needed for this default command. + +## The complete inventory and the historical comparisons + +For the original NumPy-based small examples as well: + +```sh +python3.13 -m venv .venv +. .venv/bin/activate +python -m pip install -r requirements-reproduce.txt +python verify_current.py --all +``` + +Use Python 3.13.5 when an exact match to the recorded interpreter is needed. +The dedicated requirements file pins NumPy 2.3.5. The original `requirements.txt` +is retained for historical compatibility; it is not the pinned reproduction file. + +`--all` runs every current checker entry point, then reports historical +`verify.py` byte replay and the unchanged bounded-portability comparison +**separately**. NumPy and interpreter pins do not guarantee identical floating +point on every operating system, processor, or numerical backend. + +| Outcome | Meaning | Default exit code | +|---|---|---:| +| Current exact/documentation suite passes | The selected code and finite certificates match their current records. | 0 | +| Known historical floating-report mismatch, bounded portability passes | Current checks passed; historical strict replay still failed. The JSON status explicitly reports both. | 0 | +| Current failure, changed exact fingerprint, unexpected historical failure, or failed bounded comparison | Investigation is required; no tolerance is automatically relaxed. | 1 | + +For a strict archival gate instead, run: + +```sh +python verify_current.py --all --require-strict-replay +``` + +That command returns nonzero for **any** failed historical strict replay, +including the known floating-report mismatch. It never relabels a bounded +comparison as strict equality. + +Save individual stdout/stderr and a summary outside the checkout with: + +```sh +python verify_current.py --all --output ../monster-verification +``` + +The output directory must be outside the repository, so verification cannot +silently alter a tracked source or manifest. The wrapper has bounded subprocess +timeouts and reports an exception or timeout as failure. + +## Which fingerprints should match? + +[Current report metadata](../results/current_reports.json) describes the current +implementation. The earlier report manifests are frozen evidence of earlier +commits, not assertions that every formatted document or repaired implementation +has the same bytes today. The [release manifest](../results/release_preparation.json) +records intentional source changes and all preserved files. + +The square-root repair refines rational enclosures in the calibration report; +its current output is deliberately recorded separately from the older 74-check +output. The original logical checks remain. The extraction certificate retains +its original fingerprint. [The erratum](../audits/calibration_scale_erratum.md) +explains the change and its regression family. + +## Mathematical rendering + +The default command checks fenced/inline math extraction, delimiters, local +links, parser controls, and the expected expression inventory. CI additionally +parses the exported expressions with the existing MathJax 3.2.1 checker: + +```sh +python checks/verify_display.py --export-math ../monster-math.json +npm install --prefix ../monster-renderer --ignore-scripts --no-audit --no-fund mathjax-full@3.2.1 +NODE_PATH=../monster-renderer/node_modules node checks/render_math.cjs ../monster-math.json +``` + +This is syntax checking, not a promise about every GitHub browser, screen size, +or historical page. The [archive index](ARCHIVE.md) identifies legacy rendering +boundaries. No MathJax package, generated website, paper, or font is bundled. + +## Evidence boundary + +These programs check arithmetic, finite examples, implementation behavior, +source integrity, and documentation. They do not prove the imported VOA +classifications, simulate the full Monster tensor, establish practical +measurement complexity, or constitute independent human review. diff --git a/docs/RESEARCH_STATUS.md b/docs/RESEARCH_STATUS.md index a3158b0..a80c57b 100644 --- a/docs/RESEARCH_STATUS.md +++ b/docs/RESEARCH_STATUS.md @@ -2,13 +2,17 @@ The selected quantitative result has a complete written proof, sharpness and calibration boundaries, primary-source comparisons, and a final falsification-oriented review with no blocking error found at its documented scope. See [the final review](../audits/final_quantitative_review.md). This status replaces the pre-integration coordination notes, not the historical mathematical record. -**Manuscript writing is on hold.** No abstract, introduction, conclusion, cover letter, submission or release has been drafted or initiated. Scientific evidence for eventual framing is in [background_claims.md](background_claims.md). +**Manuscript writing is on hold.** No manuscript, submission, DOI, or tagged GitHub release has been created. The repository now includes release-preparation notes and a changelog. Scientific evidence for eventual framing is in [background_claims.md](background_claims.md). ## The bounded contribution Within an exact simple unitary rational C2-cofinite holomorphic VOA of CFT type with c=24 and V1=0, sufficiently near-extremal coefficients of two actual real weight-two primaries force exact orthogonal Ising subalgebras and hence the underlying moonshine VOA by the prior Abe–Lam–Yamada theorem. The square-root field-distance exponent is optimal. Seven certified scalar intervals suffice to remove known stress contamination and normalization from actual real weight-two inputs. -The [core](../research/uniform_extraction_core.md), [precision results](../research/sharpness_and_calibration.md), [prior comparison](../audits/quantitative_contribution_verdict.md), and [final review](../audits/final_quantitative_review.md) are the active scientific path. The original 63- and 74-check reports are unchanged; the final audit adds 23 labeled adversarial controls. +The [core](../research/uniform_extraction_core.md), [precision results](../research/sharpness_and_calibration.md), [prior comparison](../audits/quantitative_contribution_verdict.md), and [final review](../audits/final_quantitative_review.md) are the active scientific path. The original 63- and 74-check reports and the 23-check audit record are preserved +at their historical versions. The calibration implementation now has scale-aware +square-root enclosures, updated current report fingerprints, and additional +scale-regression tests. [The implementation erratum](../audits/calibration_scale_erratum.md) +records the exact correction; it does not change the analytic theorem. No additional essential lemma has been identified as missing for this bounded claim. The directed priority assessment is a revisable scholarly judgment, not an exhaustive firstness assertion or a guarantee of importance. The review was conducted by the research assistant, not an independent human referee or proof assistant. @@ -20,6 +24,22 @@ The extended-six-sevenths implication, generic readout results, and other open P ## Evidence access -Run `checks/verify_extraction_core.py`, `checks/verify_calibration_and_sharpness.py`, and `checks/audit_quantitative_core.py` under normal Python, -O and -OO. The selected-source fingerprints and manifest checks are separate from the historical root replay. See the CI logs for actual strict-versus-portability outcomes; no earlier result or tolerance was changed to remove a mismatch. +Run `python verify_current.py` for the selected exact and documentation suite. +Run `python verify_current.py --all` in the +[pinned reproduction environment](REPRODUCIBILITY.md) for every current checker +and the separate historical comparisons. [Current fingerprints](../results/current_reports.json) +and [release integrity](../results/release_preparation.json) are distinct from +the frozen historical manifests. Strict byte replay and bounded portability +retain separate outcomes; no prior result or tolerance was overwritten. + +The small-scale exception identified in the pre-release audit is corrected by +adaptive exact precision and covered by direct regression tests. The explicit +square-root work limit returns an inconclusive certificate, not an unexplained +exception or a positive result. All exact ambient, grading, reality, and +known-stress assumptions remain supplied premises. + +The [archive index](ARCHIVE.md) is the entry for older status ledgers and pending +research. The [release scope](RELEASE.md) describes what a future tag would contain; +it does not announce a release. Future work on the bounded result should respond to a concrete proof objection, source overlap, or documentation defect. Enlarging the theorem or beginning manuscript drafting requires a separate scope decision; an unresolved stronger conjecture is not by itself a reason to keep extending this paper's research indefinitely. diff --git a/docs/background_claims.md b/docs/background_claims.md index 2d38fd7..b6bfc6c 100644 --- a/docs/background_claims.md +++ b/docs/background_claims.md @@ -10,7 +10,6 @@ | A02 | The error thresholds are uniform over unknown admissible candidates and do not start from a supplied nearby Ising vector. | Q1–Q3; same gap, radius, and quadratic-growth constants in every candidate. | No compactness of the moduli space of VOAs, construction of an isomorphism, or efficient field search is asserted. | | A03 | The exact orthogonal-Ising-pair classification is an imported final step. | Abe–Lam–Yamada, Theorem A.1 [ALY]. | The exact classification must be attributed; it is not the new theorem. | | A04 | The rounding proof combines a discrete critical-value gap, a local quadratic estimate, global compactness, and a discrete overlap gap. | Q1–Q4; [W,S]. | Quadratic growth and compactness are standard tools; the fractions alone do not establish novelty. | -| A05 | An actual W(6/7) extension implies at least one Ising vector under the stronger ambient trace assumptions. | Existing `research/extended_six_sevenths_forces_ising.md`, pending PR27, with its module/trace dependencies. | Supporting result only. It does not prove existence of the extension, supply a second orthogonal Ising vector, or identify the full VOA on its own. | Do not use unqualified wording such as “three measurements identify a physical theory,” “robust under arbitrary CFT errors,” “self-testing the Monster,” “first characterization,” or “proves moonshine uniqueness.” Those assertions exceed the present evidence. A failed sufficient test does not exclude moonshine. @@ -25,7 +24,6 @@ Do not use unqualified wording such as “three measurements identify a physical | B05 | Normalized two- and three-point coefficients are genuinely interaction-sensitive inputs. | Invariant metric and mode/state-field definitions [M, section 1]; Q0 gives the actual coefficient convention. | Explain the observables mathematically. Do not infer an apparatus, noise model, or number of statistical samples. | | B06 | Quantitative Morse/near-critical-point methods predate this project. | Loi–Phien, Lemma 2.11 and Theorem 3.1 [LP]. | Credit the general geometry. Their main theorem perturbs a smooth function to obtain Morse properties; that is not a physically allowed modification of an exact VOA's product. | | B07 | Other exact two-Ising results classify the subVOA generated by a specified exact pair. | Jiao–Zheng [JZ], introduction and main result. | Compare the actual hypotheses and endpoint, not just the word “two.” Local subVOA identification is different from the ALY ambient conclusion. | -| B08 | The general low-weight readout/stability package is not Monster-specific. | Project `audits/readout_scope_audit.md` at PR22; its explicit nonholomorphic lattice comparator. | Keep this as supporting or separate work, not the core evidence of exceptionalism. | The current paper's theorem may take c24 and V1=0 as explicit assumptions. Re-proving the broader minimum-central-charge characterization is unnecessary for that bounded theorem. If a future framing promotes that minimization to a physical-selection principle, its source and assumption audit becomes part of the required core, not an unstated motivation. @@ -39,11 +37,26 @@ A common source of overclaim is the word “finite”: a finite list of coeffici | C02 | The proof does not require a chosen Monster matrix representation or its multiplication table as input. | The background class itself is established by those three coefficients, or the theorem is device independent. | | C03 | The result supplies a sufficient correlation criterion with an attained region in the known example. | A hypothetical non-moonshine candidate exists; finite separation proves that such a competitor has been constructed. | | C04 | The geometric extraction method and its discrete classification inputs have distinct roles. | A new general Morse theorem, an independently proved FQS/Sakuma/ALY classification, or optimal constants. | -| C05 | The extended-6/7 implication is an existence application with different assumptions and a smaller endpoint. | Every bare6/7 vector extends, or one Ising component forces an orthogonal partner. | | C06 | Automatic existence of a pair and robustness to approximate axioms are legitimate future questions. | Either is a missing lemma required to prove the stated conditional theorem. They become required only if the advertised claim is enlarged. | The research-completion boundary is not “every stronger theorem is proved.” It is that every scientific assertion needed by the CHOSEN contribution and its framing has proof or accurately scoped primary evidence. No essential reasoning is to be left for the manuscript-writing stage. +## Separate pending work, not evidence for the selected release + +The following entries are deliberately outside the active tables. They are not +premises of the correlation criterion and have not been merged or certified as +part of this release-preparation pass. IDs are retained to make older references +interpretable; their presence is not an endorsement of the pending claims. + +| Earlier ID | Pinned record | Role and boundary | +|---|---|---| +| A05 / C05 | [Extended-six-sevenths proposal, PR27](https://github.com/GoGoKo699/Monster-Correlation-Rigidity/blob/576fd31b53862d0b7667a723330ae27c859cc774/research/extended_six_sevenths_forces_ising.md) | Separate proposed existence implication with additional module/trace inputs; not released evidence or a premise of the selected theorem. | +| B08 | [Readout-scope audit, PR22](https://github.com/GoGoKo699/Monster-Correlation-Rigidity/blob/d2b85266d4273ae7c6ce32d87e0b6060a881b87e/audits/readout_scope_audit.md) | Separate general-readout comparison; not part of the selected release proof. | + +The [archive index](ARCHIVE.md) distinguishes historical provenance, pending +branches, and the authoritative current path. Do not merge unrelated results +merely to resolve a file reference. + ## 4. Source reading in this continuation [ALY] T. Abe, C. H. Lam, H. Yamada, arXiv:1705.09022v4, Appendix A, Theorem A.1 and A.6–A.8. The exact theorem and its role were rechecked; PDF index9 (printed10) was visually inspected. Orbifold and extension-uniqueness proofs are imported, not independently reconstructed. diff --git a/llms.txt b/llms.txt new file mode 100644 index 0000000..bb7c063 --- /dev/null +++ b/llms.txt @@ -0,0 +1,39 @@ +# Monster Correlation Rigidity + +> Quantitative conditional identification of the moonshine vertex operator +> algebra from near-extremal low-weight correlation coefficients. Research by +> Ruge Lin. Manuscript writing is on hold; no tagged release is implied. + +## When this repository is relevant + +Use it for a uniform value-to-Ising-direction estimate, a sufficient two-field +correlation criterion, the sharp square-root field-distance exponent, or +certified stress subtraction and normalization from seven exact scalar intervals. +It is not a source for device-independent self-testing, automatic first-Ising +existence, bare-class uniqueness, optimal numerical tolerances, or a practical +Monster-tensor simulation. + +## Authoritative sources + +- [Current status](docs/RESEARCH_STATUS.md): exact claim scope and what is not asserted. +- [Core proof](research/uniform_extraction_core.md): hypotheses, normalization, local-to-global localization, discrete overlap rounding, and the prior Abe–Lam–Yamada endpoint. +- [Sharpness and calibration](research/sharpness_and_calibration.md): analytic precision results, not a reconstruction of the imported classifications. +- [Current arithmetic](docs/CALIBRATION_PRECISION.md): scale-safe interval implementation and its work-limit boundary. +- [Reproduction](docs/REPRODUCIBILITY.md): current command, pinned numerical environment, current versus historical report fingerprints, and strict versus bounded replay. + +## Teaching and attribution + +- [Physics learning path](docs/learn/README.md): Gaberdiel, An Introduction to Conformal Field Theory, is the primary anchor; Yamauchi Section 4 is a guided secondary supplement. +- [Assumptions and source roles](docs/learn/assumptions_and_sources.md): tutorial sources are not substitutes for primary theorem attribution. +- [Contribution comparison](audits/quantitative_contribution_verdict.md): bounded source comparison, not exhaustive novelty certification. +- [Final bounded review](audits/final_quantitative_review.md): dated assistant review and its explicit source depth. +- [Calibration erratum](audits/calibration_scale_erratum.md): implementation correction and preserved old evidence. + +## Historical and release boundaries + +- [Archive index](docs/ARCHIVE.md): older status ledgers and pending branches do not supersede the active status or supply silently imported release dependencies. +- [Release scope](docs/RELEASE.md): research package and exact assumptions, not a paper or release announcement. +- [Citation](CITATION.cff): cite the repository and exact commit used; do not invent a paper, DOI, external review, or proof-assistant certificate. +- [License](LICENSE): original MIT license for repository code and documentation, with imported results attributed to their authors. + +Questions, corrections, and potential collaborations: gogoko699@gmail.com. diff --git a/requirements-reproduce.txt b/requirements-reproduce.txt new file mode 100644 index 0000000..454c3b7 --- /dev/null +++ b/requirements-reproduce.txt @@ -0,0 +1,4 @@ +# Complete historical-check environment; selected exact checks need no packages. +# Use Python 3.13.5 to match the recorded runner. Byte identity is not promised +# across platforms, even with this NumPy pin. +numpy==2.3.5 diff --git a/research/sharpness_and_calibration.md b/research/sharpness_and_calibration.md index 2e4efd5..81727a5 100644 --- a/research/sharpness_and_calibration.md +++ b/research/sharpness_and_calibration.md @@ -76,6 +76,8 @@ Solving for $q(z)$ gives $q-\tau n/2+\tau^3/36$. The bilinear projection identit This argument needs no multiplication table and no chosen Ising vector in the unknown candidate. It does not alter the field signs: a negative primary self-coupling remains negative unless a sign change and the accompanying overlap change are explicitly made. +The current implementation uses scale-aware outward square-root bounds. The [calibration precision note](../docs/CALIBRATION_PRECISION.md) proves the arithmetic enclosure and explains its explicit work limit; the [implementation erratum](../audits/calibration_scale_erratum.md) records the earlier small-scale exception. The identities and physical premises above are unchanged. + ### Certified scalar intervals Suppose each of the seven exact numbers lies in a supplied rational interval. Evaluate (1) by outward interval arithmetic, first requiring strict positive lower bounds for both $N_i$. If the resulting lower bounds on $f(x_i)$ and upper bound on the overlap error satisfy the original sufficient criterion, the conclusion follows for every exact input consistent with those intervals. diff --git a/research/uniform_extraction_core.md b/research/uniform_extraction_core.md index 02632fe..2ae5711 100644 --- a/research/uniform_extraction_core.md +++ b/research/uniform_extraction_core.md @@ -3,7 +3,7 @@ [← Learning path](../docs/learn/README.md) · [Overview](../README.md) · [Sharpness and calibration →](sharpness_and_calibration.md) Research proof record, 26 September 2026. Read baseline: `09e3f98ad79034eefab43f4fb9ea432368fc19e7`. -This is a self-contained consolidation of the quantitative part of `research/two_field_selection.md`, not a manuscript or a new exact classification theorem. The geometric argument is elementary quadratic growth plus compactness. Its novelty must not be conflated with the old classification theorems. +This is a self-contained consolidation of the quantitative part of [the earlier two-field selection note](https://github.com/GoGoKo699/Monster-Correlation-Rigidity/blob/ac5acad7cad4a63f0d879e4ea716f5a27c3bcd61/research/two_field_selection.md) (historical provenance in unmerged PR23, not an omitted prerequisite), not a manuscript or a new exact classification theorem. The geometric argument is elementary quadratic growth plus compactness. Its novelty must not be conflated with the old classification theorems. ## Q0. Fixed scope and normalization diff --git a/results/current_reports.json b/results/current_reports.json new file mode 100644 index 0000000..fb690f4 --- /dev/null +++ b/results/current_reports.json @@ -0,0 +1,32 @@ +{ + "reports": [ + { + "script": "checks/verify_extraction_core.py", + "checks": 63, + "sha256": "1dc55b7cdb8a614af4aaece9099f9bb4282e3583a0032a9050914e5f3873e06d", + "source_sha256": "d2062b1577beb7a34c0665fc358da7b1daf846886cd48dfa0b26acf83c107e83", + "historical_report_sha256": "1dc55b7cdb8a614af4aaece9099f9bb4282e3583a0032a9050914e5f3873e06d" + }, + { + "script": "checks/verify_calibration_and_sharpness.py", + "checks": 74, + "sha256": "36a602a1fb4c75a46db41766b7da1031b8ac7bc5cec200eafac46df2b45552b1", + "source_sha256": "7a2b98dab6df116ea804706d75e8fb5a0d246ea889f6381f13e88dd85bedbb5a", + "historical_report_sha256": "13a5cc28750faa5c5916f4d9e2717ccdc4cc3957c4911fb98b434dcc522d6ca3" + }, + { + "script": "checks/audit_quantitative_core.py", + "checks": 23, + "sha256": "23add83ad8021a1fab2212f0bf1931b00bca68171e8b82b4bcd405286c5a5c38", + "source_sha256": "227fc983f450b615b7b34231a0d806ca8d49ae80c0abb7927be6bb1f4922d3ff", + "historical_report_sha256": "2b863f6f9edbc17abed7eaf4bb6bc832cf0f356d44280467a5fcc51ac6b495e2" + }, + { + "script": "checks/verify_calibration_scales.py", + "checks": 3082, + "sha256": "845e824d1bf2470c3bf401d741e506bd47cc03d2cc168fcbcede5570881c15b9", + "source_sha256": "c311e90fda80858d5d0e64e86c035a8f7bec287e275ae76e4f7367160d2dc77b" + } + ], + "scope": "Current exact outputs after the scale-safe repair. Earlier report manifests and saved reports remain unchanged; code and source theorem validation are distinct." +} diff --git a/results/release_preparation.json b/results/release_preparation.json new file mode 100644 index 0000000..9701be0 --- /dev/null +++ b/results/release_preparation.json @@ -0,0 +1,689 @@ +{ + "schema_version": 1, + "base_commit": "ecd0623e9de41b49754b6ca16dc23752443143af", + "base_tree": "20c5252c0bd5e83d6a908ee226e5799e947280fc", + "modified": [ + { + "path": ".github/workflows/quantitative-core-review.yml", + "bytes": 10130, + "sha256": "efe50fbbd5fe3919847298ba76bff37c36495730ce2246b181424f778a04cdf6", + "previous_sha256": "77bca74a609cbf8eb162b23de7655ab97a850bf57a64aae6a60a0a6b6c1c0d8d" + }, + { + "path": "PHYSICS_STATUS.md", + "bytes": 5631, + "sha256": "55effd5dc57bc13e279a743127d0495bd919f9ffbcc3b3755f3b176fd259fc4d", + "previous_sha256": "7a7f71821342d6ef8c8867b0967d68c4055f38575ebdae2123c9d1e3afa36729" + }, + { + "path": "README.md", + "bytes": 6384, + "sha256": "977289a6e03fa80a987d25a8baed1554ea373a1fbf2eeec877aa417312dd452b", + "previous_sha256": "07c05d6314d03e76b786acf32d85d8533a5a5f5b350a06268e865df3ec8d2f5f" + }, + { + "path": "STATUS_CURRENT.md", + "bytes": 11106, + "sha256": "9d8f96cca1cb89368cb4f43cace66f8aedc71fad447dfaa29c6c0b368f448200", + "previous_sha256": "cf7a7fa4cbed6e4234e480f07992081ff46ccb535a3a9544de92aa4feef932f2" + }, + { + "path": "checks/audit_quantitative_core.py", + "bytes": 9949, + "sha256": "227fc983f450b615b7b34231a0d806ca8d49ae80c0abb7927be6bb1f4922d3ff", + "previous_sha256": "59272de376aae3b03c1408aab2dd39adc7e3d60fdaf824fb19f18c1ea7643c62" + }, + { + "path": "checks/verify_calibration_and_sharpness.py", + "bytes": 13648, + "sha256": "7a2b98dab6df116ea804706d75e8fb5a0d246ea889f6381f13e88dd85bedbb5a", + "previous_sha256": "d2c16a6c9c01af9d1198cfc2b4459d78966a42c314b8a0575bd37626bcd2eef1" + }, + { + "path": "checks/verify_display.py", + "bytes": 12689, + "sha256": "f411177b0b28c4da2b3217f159034217c845a70ee4f0572e88356309b52b2d1b", + "previous_sha256": "a0e14ed9bf99a60dc21dae52b78e07f47b4aff34367b2e54a57f7a3aa9ffb622" + }, + { + "path": "docs/BOUNDED_CORE_STATUS.md", + "bytes": 5873, + "sha256": "697788ff568f6234d33d7f3c7c0ae4b72d266c488f5becceb1371874df385143", + "previous_sha256": "dc450a28853e99a909660b400783cc6d1886491249644a64fbcc77d38b273340" + }, + { + "path": "docs/QUANTITATIVE_CORE.md", + "bytes": 1375, + "sha256": "42e7294bc0ee20c84b26f24070acaf9b86140d39225024c96edbcbc2ff286532", + "previous_sha256": "b87aa137897c0f84fd0ec8231110fddc2d2a6adef498e88e66398c55ea9646e5" + }, + { + "path": "docs/RESEARCH_STATUS.md", + "bytes": 4373, + "sha256": "04c2aec2ad32986a825062d88f73d3db4f234f62607c3c6c54c46557a4810307", + "previous_sha256": "8c6a616753f0a4011c10cc1256077979bfd7c3d1d304efeb54091bfe64fc3ef5" + }, + { + "path": "docs/background_claims.md", + "bytes": 10602, + "sha256": "5ab91dc7fda957f10b6f5265ca91f11a5f6b5d25d5b9ddf81f525e5f099c6039", + "previous_sha256": "8ca74a07e83d05fcbfccbaed73b2b0cb1791594d393f668cacfd55979b16d800" + }, + { + "path": "research/sharpness_and_calibration.md", + "bytes": 12929, + "sha256": "b1ab9d8d8ad4dd56cbb3c6cacacb6b8f870ee188ee4784fb86670f6d977e059c", + "previous_sha256": "713c77bf5b1811f8566485305b117294828a31497cfdd006b69a728f26dd521a" + }, + { + "path": "research/uniform_extraction_core.md", + "bytes": 13699, + "sha256": "e5fb2e80392d427853eaf9eb1a46d979488fba2a7053832fefe18a745f39d118", + "previous_sha256": "2bf8232fa14ecdd28a108d5e911ee500cf4f1498df3a1c5517ae6b895a22be6c" + }, + { + "path": "snapshot_manifest.json", + "bytes": 10245, + "sha256": "713faba50b42c8bb3a2f80d2b5b920c83a8d0911d4ea6af28cdc8aafd8be44a9", + "previous_sha256": "3e798b9d48a94406348f65e65acc9673d17cab380849631244be6002c240134d" + } + ], + "added": [ + { + "path": ".github/repository_metadata.json", + "bytes": 443, + "sha256": "e97e68b840861271fd60d8b433ec3f6f5f8f432496d459b9670682111880b29c" + }, + { + "path": "CHANGELOG.md", + "bytes": 1602, + "sha256": "7e6e8d6019b64d3237f9e35efb6fe0ddd9c30690aa35db193f0ae7028031e1e8" + }, + { + "path": "CITATION.cff", + "bytes": 957, + "sha256": "2cf7f891ee6dfaa908350ea364908012122819ba7db0aa4134960432a1407255" + }, + { + "path": "audits/calibration_scale_erratum.md", + "bytes": 2801, + "sha256": "d9f436f3eda1e11ec72789f2a17a8a2d2b24ca1b7c228239d42a0907078789dd" + }, + { + "path": "audits/release_preparation.md", + "bytes": 4374, + "sha256": "55eb0a9635ca844432625e9907d8f6e370d7610a26f71d2cae7d4531d94a0220" + }, + { + "path": "checks/release_integrity.py", + "bytes": 5168, + "sha256": "6ef07ba7e6efe709c101ab2637e5da373a5fb939d49e02bfd29f2320f89708b1" + }, + { + "path": "checks/scale_safe_roots.py", + "bytes": 1513, + "sha256": "7b6cb83309f0194f8725b5fa7dc9c699a3501ca19e75073fa4e0d62ba22932ed" + }, + { + "path": "checks/verify_calibration_scales.py", + "bytes": 5459, + "sha256": "c311e90fda80858d5d0e64e86c035a8f7bec287e275ae76e4f7367160d2dc77b" + }, + { + "path": "checks/verify_release_package.py", + "bytes": 4854, + "sha256": "7b7e8369277754f2f9db8af0e5436cfc52e3c73489b270e585b8a6f17eb57b0e" + }, + { + "path": "docs/ARCHIVE.md", + "bytes": 4794, + "sha256": "7794cb8f6bc7007e2dcd9fa81129031cc34097152fab0ab7f1cf7e7941c8ff76" + }, + { + "path": "docs/CALIBRATION_PRECISION.md", + "bytes": 3375, + "sha256": "f2d7f0b27bf93d6dd860b2fdfa71f1a9c86e4d597ba89a601433be5f906b963a" + }, + { + "path": "docs/RELEASE.md", + "bytes": 2557, + "sha256": "7fbbb394fff3a797bcdf4099f8f6ebf9aa74e7431281fd0d5cf504a7cc6444f0" + }, + { + "path": "docs/REPRODUCIBILITY.md", + "bytes": 4593, + "sha256": "f9bb4d63c774e24f87686ebd40e8251632d8c084363447919a0a47989a6378c6" + }, + { + "path": "llms.txt", + "bytes": 2848, + "sha256": "8f66bf42d7366093e63b935449a876ff38cb1d2e15c72dcd981bdc098e392ab0" + }, + { + "path": "requirements-reproduce.txt", + "bytes": 220, + "sha256": "295df3d0ca113d36afc54a0f7f00a2dea4a0493a710e33d3acfd3f500cb048a6" + }, + { + "path": "results/current_reports.json", + "bytes": 1555, + "sha256": "94d1f145b9d2f944c4fc4e77b6b880bb4676e7a36a0786a8eae9dfd6c4bb204b" + }, + { + "path": "verify_current.py", + "bytes": 6877, + "sha256": "3cdbb41789541c7cd04d3984dcaca6667a8a9729531a5c0b0aafae47d7c57f85" + } + ], + "preserved": [ + { + "path": ".github/workflows/research-checks.yml", + "bytes": 4288, + "sha256": "2711277a2159a5fc4dcf44e1ccf65187c25567a2e51b33e4aa5a0c3bad6860e8" + }, + { + "path": ".gitignore", + "bytes": 55, + "sha256": "4ba859c0b25cbb1709b401dd85682d4445f38e7d9237a9b90cf3f9fca642f00e" + }, + { + "path": "AGENTS.md", + "bytes": 2367, + "sha256": "e1e288d4ad55d6804c322a165ee74bfa0e28ef668fd118a4a37794bfd20cb393" + }, + { + "path": "COPYING.md", + "bytes": 907, + "sha256": "2ea9d486f9dc494c4ded969798acb6c7688ec71140bf33dcb2b2e1d857883873" + }, + { + "path": "LICENSE", + "bytes": 1065, + "sha256": "a92600540b1ab7a18301e2632a29334b3df227ad836e88df9967d69e3c86db66" + }, + { + "path": "STATUS.md", + "bytes": 4398, + "sha256": "7546c5a5449dfeb43c8575f9939e3f0971b4d7869377ccb6864c0bc082f8eef4" + }, + { + "path": "WORKSPACES.md", + "bytes": 2261, + "sha256": "e10b268c0668b9dec24dec715f6462fda7cf2d6df04fbc3694def4dcb886fd66" + }, + { + "path": "audits/README.md", + "bytes": 1702, + "sha256": "11e8429fe585af944f71f3599503ee72dccbb8d121e9c5838b04a3fc57a8d9b4" + }, + { + "path": "audits/final_quantitative_review.md", + "bytes": 9745, + "sha256": "3a1810f167c9646d49726bf036a6af589d6d8bebcd228c2be63c9b7fed19a408" + }, + { + "path": "audits/hopf_style_integration.md", + "bytes": 4026, + "sha256": "f8534d589a8e11ac708de7dd0ad980da6bc211a672f0cfa49125f04c0c3ecde0" + }, + { + "path": "audits/integration_20260925.md", + "bytes": 4941, + "sha256": "3f0531fde8bfe6599f261e2c1817697cabaf07be01b68c2cd116b345f0d33af7" + }, + { + "path": "audits/math_rendering_repair.md", + "bytes": 3717, + "sha256": "d440b78694af5a818696a4dc3b5c24ed80de064af9e8977703ebccf0cb1b5922" + }, + { + "path": "audits/physical_integration_replay_erratum.md", + "bytes": 1897, + "sha256": "f0144624a15ca5beb602a173184b8a1f9f2d84616fb24f5e49b4dd44a8854667" + }, + { + "path": "audits/physics_teaching_integration.md", + "bytes": 4084, + "sha256": "bdf8b83b4d970dcfab7fb4b50cfd150fc11d94fd3f498bfca2527207f6da601b" + }, + { + "path": "audits/priority_matrix.md", + "bytes": 5616, + "sha256": "28a0bcfe5c8c99b8907fb4e36d7601aaf6fdf3a006d39466a45c6a2b7d8bf37a" + }, + { + "path": "audits/quantitative_contribution_verdict.md", + "bytes": 14039, + "sha256": "e478d8a1a5c1e2c939f21f6cdd39bf5d822d97778380f9ec8c091815d6274299" + }, + { + "path": "audits/robustness_proof_audit.md", + "bytes": 29095, + "sha256": "810bb5d07df79dda965d0cadc2ff09b31b5a1075b59c8b5f44c28a962a978e69" + }, + { + "path": "audits/voa_extrema_audit.md", + "bytes": 30655, + "sha256": "75569858501ad1d9e0961588a41dbe039b7b8bf46938c9df6b0af0374f6b7275" + }, + { + "path": "checks/audit_parameter_domains.py", + "bytes": 11473, + "sha256": "2c0f2829ab86609f87622f06087f677abf170fc212c690dad1232f4a03656ebe" + }, + { + "path": "checks/render_math.cjs", + "bytes": 1717, + "sha256": "56099b0d3987da819bf0cc4695ff9b7e9907f5fc33aa350cbcc348d7d6d118aa" + }, + { + "path": "checks/replay_portability.py", + "bytes": 5818, + "sha256": "91a6be536bd797007548ec5912c272e9d389d9a2e2622337f55135ba23798749" + }, + { + "path": "checks/verify_a0_sector.py", + "bytes": 17553, + "sha256": "7ffcfefd58f58af90bd02cdf22d695f93aac06d41a5ab29023c826f5669465ba" + }, + { + "path": "checks/verify_extraction_core.py", + "bytes": 11722, + "sha256": "d2062b1577beb7a34c0665fc358da7b1daf846886cd48dfa0b26acf83c107e83" + }, + { + "path": "checks/verify_leech_xxa.py", + "bytes": 12969, + "sha256": "7a6a501009c93271966839c152c123526b3f130d7a469bb8335329a17951f829" + }, + { + "path": "checks/verify_normalizer.py", + "bytes": 5890, + "sha256": "69497daee612f35840a1dab48884c65ff38f9344f46898a1342747b224e99409" + }, + { + "path": "checks/verify_normalizer_priority.py", + "bytes": 16743, + "sha256": "39240f62d5871669e3ca83928c5dbd86a2f9c3c1c8b05ef503f089e5ab5d62c6" + }, + { + "path": "checks/verify_normalizer_toy.py", + "bytes": 6990, + "sha256": "01ab97870677f22b7ce784e185fe6560e3527836aabcf9870bbb5e0299454321" + }, + { + "path": "checks/verify_pair_prior_art.py", + "bytes": 12114, + "sha256": "c0a486cb3abff3da959fa01d189bfab31fd2ac51909180ad568e26175b0a7028" + }, + { + "path": "checks/verify_physical_selection.py", + "bytes": 8321, + "sha256": "8e3eb1db20f65d67f65abfc17207ea9018c4dfecef7d722c4a074930cad7c1b1" + }, + { + "path": "checks/verify_probe_access.py", + "bytes": 6205, + "sha256": "a5ae69e572d2c986de623bd89e8b388027e103af47899af18144bfe55ab14bdb" + }, + { + "path": "checks/verify_repository_integrity.py", + "bytes": 2459, + "sha256": "a00edffbdbb000e98bd765b9fd1b222507b265702372cb55c777b88844434e01" + }, + { + "path": "checks/verify_seysen_block.py", + "bytes": 10785, + "sha256": "3f1835d390b2ab9e9a67ca44e176a7b1ae9a3753a89632d0170b5144717e8104" + }, + { + "path": "checks/verify_teaching.py", + "bytes": 8673, + "sha256": "673d7b0f3384af4669376eed93cedd224cc1855c4c667fa70cbbcf62eef3bad2" + }, + { + "path": "checks/verify_weight_four.py", + "bytes": 9443, + "sha256": "1b27619d29280059eb32d815c3f049035dec054b43cce6e0dda47c5d95200ae8" + }, + { + "path": "checks/verify_weight_three.py", + "bytes": 11868, + "sha256": "701bb43baa4198dab9a4639c6e763b7d0e809e1a516b011f973432fedcb9a724" + }, + { + "path": "circuits/a0_sector.py", + "bytes": 8515, + "sha256": "fae6dd1368ed0d1da22cb11abe1d324b49df04efccd307ff81fd6fa19e5799bc" + }, + { + "path": "circuits/jordan_aaa.py", + "bytes": 6784, + "sha256": "a871f4a1db268063fd7de98cc4fde71efbe0164c5aeb250de8bc517b30849c3e" + }, + { + "path": "circuits/leech_xxa.py", + "bytes": 10936, + "sha256": "0cfee265c6ef61cb3c43a225006f63a9f395503c60521436c4ef7263c48bceb7" + }, + { + "path": "circuits/seysen_qqa.py", + "bytes": 8100, + "sha256": "e72b8924d898f9c676d9584a4df857fd9a86dcd3ff970aee6821b9e43907826a" + }, + { + "path": "data/monster_character_excerpt.json", + "bytes": 4229, + "sha256": "70218f4f87e67896a64c8577b7a86fb0c46cebe3c71678397a7654b8ef0596e0" + }, + { + "path": "docs/learn/01_correlations.md", + "bytes": 4853, + "sha256": "e8610c886da179faf8eab8a09dfe832d5a96b352f2551d5715a19329464788d8" + }, + { + "path": "docs/learn/02_weight_two.md", + "bytes": 4586, + "sha256": "1e2e8b35a924a7b90aeb508f6c8efc2224951a832713a459d9da179839bb3791" + }, + { + "path": "docs/learn/03_ising.md", + "bytes": 5622, + "sha256": "754aa3aa9ee670aeafc2cf7002d2843ee3c8a7639a152faf68bc59c6df6dbb1b" + }, + { + "path": "docs/learn/04_rounding.md", + "bytes": 5793, + "sha256": "27d775490fda1291da07b136774972ff559ec4ae62c9161e0213dd1f5c6b65d3" + }, + { + "path": "docs/learn/05_worked_certificate.md", + "bytes": 5822, + "sha256": "fd4e01fb1b8578598055d1024f39013bab419f0d17300956e759d69d39f7a4c4" + }, + { + "path": "docs/learn/README.md", + "bytes": 5297, + "sha256": "de4724dbfb263fd1bae102ed3f7044039739851a5e3bb7f86b0a917109104877" + }, + { + "path": "docs/learn/assumptions_and_sources.md", + "bytes": 5823, + "sha256": "ea1098995d91e05442b84db3888af9546f3e3503af685166c69c0e04a3ad4de1" + }, + { + "path": "provenance/Monster_Average_Transport_Checkpoint.zip", + "bytes": 74753, + "sha256": "49cf36598860bba792dd5c4a19c8530298b1d11315721c484a61a5605a978cfb" + }, + { + "path": "provenance/Monster_Bipartite_Correlations_Checkpoint.zip", + "bytes": 31433, + "sha256": "c84add074c170ef9c144a94c1e089f8853d2e22323416af487dfcc058bd59741" + }, + { + "path": "provenance/Monster_Correlation_Local_Rigidity_Checkpoint.zip", + "bytes": 10771, + "sha256": "44ec14514af43dc75d3472ece10f3f2b15c0637ca4d73235faea7035cff27355" + }, + { + "path": "provenance/Monster_Global_Rounding_Checkpoint.zip", + "bytes": 51846, + "sha256": "5bf8a6ae9106e8126179d466c326cacb3b485e3dcb89dd761a07905a48daaf94" + }, + { + "path": "provenance/Repository_Seed_2026-09-23.zip", + "bytes": 236980, + "sha256": "1124a6477e3a71d43c5af08134dcd5347e253ce6fdd57aa257c88992a72661c8" + }, + { + "path": "provenance/import_manifest.json", + "bytes": 2568, + "sha256": "c8a62f6d0b92733dc507756b37a3c3923b9c0715f8844c3eed7f8098d40700c4" + }, + { + "path": "provenance/quantitative_core_additions_PR28.json", + "bytes": 1961, + "sha256": "2a9104dc4c816990a99bf66c7caa6f5f2ed311cf85b801c2b42ed520e7821baa" + }, + { + "path": "provenance/repository_import.json", + "bytes": 6248, + "sha256": "40cbbd8dc95d14f8e278e6ea53bd8df2ae44478bb3c58628b5255ff46cbdf6f5" + }, + { + "path": "requirements.txt", + "bytes": 115, + "sha256": "3169cba7975e0b743bc2e1b16099491cdc999dacec349ffeadd808298327f559" + }, + { + "path": "research/01_local_rigidity.md", + "bytes": 16822, + "sha256": "c1938cbc79c8deff194d68e6534a29acb4ea6336873187492652405d06a4bf8a" + }, + { + "path": "research/02_pair_correlations.md", + "bytes": 25520, + "sha256": "1cca118e861977dfe3496c1eee23b53dd78bf8c78da9078a143228e85f810191" + }, + { + "path": "research/03_uniform_axis_rounding.md", + "bytes": 20336, + "sha256": "d7d3f30e974354929d06b5f6973686f2b88e033cc335a60865c275853282d2b4" + }, + { + "path": "research/04_average_transport.md", + "bytes": 23384, + "sha256": "705d25aea83fc81f84391186895792bf54907cfaa1a4895498c33867d40a9ed4" + }, + { + "path": "research/05_normalizer_rounding.md", + "bytes": 21830, + "sha256": "ae570ca7aab3a41a33e81c092611779b53f68f5f26a9dca16b87a6a7a8bbe6fc" + }, + { + "path": "research/06_probe_access.md", + "bytes": 13813, + "sha256": "0829c7de9b788f9790ddf26a35ecaf402614cdeaee805f3428fc83bdbadac492" + }, + { + "path": "research/07_seysen_qqa_block.md", + "bytes": 17873, + "sha256": "bc4dff6c889479ac9c613874eecfcde98d7b484e878ac18cbf1c1cfb38a370e3" + }, + { + "path": "research/08_leech_xxa_block.md", + "bytes": 19450, + "sha256": "e730574946d67c830019e3a4bb69ce5201d0594248930fda9118c5ec4521613a" + }, + { + "path": "research/09_jordan_and_a0_sector.md", + "bytes": 21343, + "sha256": "ea1fa33e53f15d806a2632747f368de5158e1a1c4df861c93bcc0ae18a0df907" + }, + { + "path": "research/10_normalizer_stability_comparison.md", + "bytes": 28203, + "sha256": "435bdbe6a793d58d90b2d98da22bd48165f4488a0ef57972a812d72426ca46de" + }, + { + "path": "research/11_pair_test_prior_art_and_conditioning.md", + "bytes": 27381, + "sha256": "2ad70f631744d861d623cf239445dccae0b7bb1123382604ba9e0d66fc58c279" + }, + { + "path": "research/12_physical_selection_from_extremality.md", + "bytes": 20516, + "sha256": "84b7cc0819d6d28302f982400a36b6d4595431555c468fc826cf5f8e941cfade" + }, + { + "path": "research/13_weight_three_ope_channel.md", + "bytes": 15409, + "sha256": "5aa066d0427d61e6e5cbc6af035e37c3aa589d9bdb427223c000fdb521664edd" + }, + { + "path": "research/14_weight_four_and_four_point_closure.md", + "bytes": 19011, + "sha256": "f8238846e2a82a011a3b02bb4e7216f439731bf40c7126be635cd07ff96d11e5" + }, + { + "path": "results/a0_sector_checks.json", + "bytes": 4711, + "sha256": "8d1088aaa78d91006ce6ad8fe1d393bee026a027f45301def021e0d4a1873662" + }, + { + "path": "results/a0_sector_resources.json", + "bytes": 1680, + "sha256": "99707e5e53c8d30930075d05b6428d3dcb5e0c9164e8e0ece73a5e22e9017519" + }, + { + "path": "results/environment.json", + "bytes": 249, + "sha256": "a2bca27d98f91806f527103ca01f11699cf3e1b78b92050a24ae56f690ccf156" + }, + { + "path": "results/final_core_integration.json", + "bytes": 3211, + "sha256": "4f94eb48f23c07e0905c6f8940b5eb6f0cdae4866c7ae96006b8b96bb4af30cb" + }, + { + "path": "results/hopf_style_changes.json", + "bytes": 3620, + "sha256": "c06efbb01963198ae24b237487f5270e802bdf4811712b62dcf2b2a3a4604a2a" + }, + { + "path": "results/jordan_aaa_resources.json", + "bytes": 1131, + "sha256": "7fdc200bcab63a9513ad4ad1b23b7065f208bddc3c7ff0a213806fdf9d2d4ea3" + }, + { + "path": "results/leech_xxa_checks.json", + "bytes": 2907, + "sha256": "e7e53be06c067f4ceb1cf2aad0bfb6f27f6a18093a849be5de584cf87bde8c3b" + }, + { + "path": "results/leech_xxa_resources.json", + "bytes": 1434, + "sha256": "88cb634128bfa2a5a00739e45559e4a4a7c1d9188d06901f98ebaec596de53f1" + }, + { + "path": "results/math_rendering_changes.json", + "bytes": 1859, + "sha256": "c7b2d9b55d61f09dc30513ae0ee68266f9ea7a7b3025ce17ffe79cf2f8d648f6" + }, + { + "path": "results/normalizer_exact.json", + "bytes": 2664, + "sha256": "25302b964def841d062101339fbc9baff43f98eb7f9446bd241e83c5c926623d" + }, + { + "path": "results/normalizer_priority.json", + "bytes": 6384, + "sha256": "cd7f58dcdfb25c6b62e1d2d506c3ad2749e92c71b14ea7f07478566163fcc705" + }, + { + "path": "results/normalizer_toy.json", + "bytes": 2843, + "sha256": "6f4fccfaee44033d08efb2ba4229155c61a0a4f2c19e17a3eaf83cfef2ea16ed" + }, + { + "path": "results/pair_prior_art.json", + "bytes": 6718, + "sha256": "3cd74cfff40ebce808d31e8ad6672abf993e9424f92cdce64ff5f0a4150db463" + }, + { + "path": "results/physical_selection.json", + "bytes": 3335, + "sha256": "bcb5fb4f41e405ca58d2b0b979fec07bfc2607532addc61300bfe726248137e0" + }, + { + "path": "results/physics_teaching_manifest.json", + "bytes": 2677, + "sha256": "bbdf8f892a86ffa3ba271796d507f14243b57e768b1723604cf03132c2ed14d8" + }, + { + "path": "results/probe_access.json", + "bytes": 2043, + "sha256": "2eb5a602b494f9204e24fc88bb16e32ed36152733928389222d41405d5957337" + }, + { + "path": "results/quantitative_core_additions.json", + "bytes": 2150, + "sha256": "00dbe13b22bd61132b8987e0e00a0b54b2ce9921dbe480d86fce7b9d146e861f" + }, + { + "path": "results/quantitative_core_reports.json", + "bytes": 509, + "sha256": "9f559fb1644fab7d6ad39ada38a0307d9baf372fc3f9687dc449201c466e0a44" + }, + { + "path": "results/quantitative_final_audit.json", + "bytes": 1943, + "sha256": "2b863f6f9edbc17abed7eaf4bb6bc832cf0f356d44280467a5fcc51ac6b495e2" + }, + { + "path": "results/seysen_block.json", + "bytes": 3472, + "sha256": "2c057d1400ef4b4e7c8ccaa561def7d3895864d73e890a8eabb282aa71892b7a" + }, + { + "path": "results/verification_summary.json", + "bytes": 2969, + "sha256": "6b4c8d56fcc51f3feef8e89bec82db15724c081ac218329a3badbb25915e26ae" + }, + { + "path": "results/weight_four.json", + "bytes": 4583, + "sha256": "dd1885333e90179c93983ca9997ea65904dd0b99e85b83d31377444e5eb41302" + }, + { + "path": "results/weight_three.json", + "bytes": 3643, + "sha256": "41c04af8a7564e69c5ed8c2a0a2f5d50568ee6a3074465428821864acf7d6219" + }, + { + "path": "verify.py", + "bytes": 6660, + "sha256": "db5adc341da7c3382b7ba208b287324b20627bc1f5fa9d5b54a4d81ddccd1ce8" + }, + { + "path": "work_orders/CURRENT.md", + "bytes": 2143, + "sha256": "36f01aabd62c23e4ee157da5cd95bfe01f1f55a62eac55ff08847035ef688f26" + }, + { + "path": "work_orders/INDEPENDENT_AUDIT.md", + "bytes": 4133, + "sha256": "42fec084b5aae524e7a2ee85d9a0d68ff743faa3b32ca0fe61310c2a9240ae13" + } + ], + "active_pages": [ + "README.md", + "docs/learn/01_correlations.md", + "docs/learn/02_weight_two.md", + "docs/learn/03_ising.md", + "docs/learn/04_rounding.md", + "docs/learn/05_worked_certificate.md", + "docs/learn/README.md", + "docs/learn/assumptions_and_sources.md", + "research/uniform_extraction_core.md", + "research/sharpness_and_calibration.md", + "docs/RESEARCH_STATUS.md", + "docs/QUANTITATIVE_CORE.md", + "docs/background_claims.md", + "docs/REPRODUCIBILITY.md", + "docs/ARCHIVE.md", + "docs/CALIBRATION_PRECISION.md", + "docs/RELEASE.md", + "CHANGELOG.md", + "llms.txt", + "audits/calibration_scale_erratum.md", + "audits/release_preparation.md" + ], + "math_corpus": { + "expressions": 473, + "display_equations": 85, + "sha256": "750575a599263522257ddf895b08449f118675a2ef96b89b5d697a8a770dfcb3" + }, + "scope": "Explicit calibration reliability and reader/reproduction maintenance. All unmodified baseline bytes and historical evidence are preserved. This manifest excludes itself. No release is created; source comparisons do not verify imported mathematical theorems." +} diff --git a/snapshot_manifest.json b/snapshot_manifest.json index 0812c16..3f1059e 100644 --- a/snapshot_manifest.json +++ b/snapshot_manifest.json @@ -1 +1 @@ -{"files":[{"path":".github/workflows/research-checks.yml","bytes":4288,"sha256":"2711277a2159a5fc4dcf44e1ccf65187c25567a2e51b33e4aa5a0c3bad6860e8"},{"path":".gitignore","bytes":55,"sha256":"4ba859c0b25cbb1709b401dd85682d4445f38e7d9237a9b90cf3f9fca642f00e"},{"path":"AGENTS.md","bytes":2367,"sha256":"e1e288d4ad55d6804c322a165ee74bfa0e28ef668fd118a4a37794bfd20cb393"},{"path":"COPYING.md","bytes":907,"sha256":"2ea9d486f9dc494c4ded969798acb6c7688ec71140bf33dcb2b2e1d857883873"},{"path":"LICENSE","bytes":1065,"sha256":"a92600540b1ab7a18301e2632a29334b3df227ad836e88df9967d69e3c86db66"},{"path":"PHYSICS_STATUS.md","bytes":5369,"sha256":"7a7f71821342d6ef8c8867b0967d68c4055f38575ebdae2123c9d1e3afa36729"},{"path":"README.md","bytes":5395,"sha256":"07c05d6314d03e76b786acf32d85d8533a5a5f5b350a06268e865df3ec8d2f5f"},{"path":"STATUS.md","bytes":4398,"sha256":"7546c5a5449dfeb43c8575f9939e3f0971b4d7869377ccb6864c0bc082f8eef4"},{"path":"STATUS_CURRENT.md","bytes":10844,"sha256":"cf7a7fa4cbed6e4234e480f07992081ff46ccb535a3a9544de92aa4feef932f2"},{"path":"WORKSPACES.md","bytes":2261,"sha256":"e10b268c0668b9dec24dec715f6462fda7cf2d6df04fbc3694def4dcb886fd66"},{"path":"audits/README.md","bytes":1702,"sha256":"11e8429fe585af944f71f3599503ee72dccbb8d121e9c5838b04a3fc57a8d9b4"},{"path":"audits/integration_20260925.md","bytes":4941,"sha256":"3f0531fde8bfe6599f261e2c1817697cabaf07be01b68c2cd116b345f0d33af7"},{"path":"audits/physical_integration_replay_erratum.md","bytes":1897,"sha256":"f0144624a15ca5beb602a173184b8a1f9f2d84616fb24f5e49b4dd44a8854667"},{"path":"audits/priority_matrix.md","bytes":5616,"sha256":"28a0bcfe5c8c99b8907fb4e36d7601aaf6fdf3a006d39466a45c6a2b7d8bf37a"},{"path":"audits/robustness_proof_audit.md","bytes":29095,"sha256":"810bb5d07df79dda965d0cadc2ff09b31b5a1075b59c8b5f44c28a962a978e69"},{"path":"audits/voa_extrema_audit.md","bytes":30655,"sha256":"75569858501ad1d9e0961588a41dbe039b7b8bf46938c9df6b0af0374f6b7275"},{"path":"checks/audit_parameter_domains.py","bytes":11473,"sha256":"2c0f2829ab86609f87622f06087f677abf170fc212c690dad1232f4a03656ebe"},{"path":"checks/replay_portability.py","bytes":5818,"sha256":"91a6be536bd797007548ec5912c272e9d389d9a2e2622337f55135ba23798749"},{"path":"checks/verify_a0_sector.py","bytes":17553,"sha256":"7ffcfefd58f58af90bd02cdf22d695f93aac06d41a5ab29023c826f5669465ba"},{"path":"checks/verify_leech_xxa.py","bytes":12969,"sha256":"7a6a501009c93271966839c152c123526b3f130d7a469bb8335329a17951f829"},{"path":"checks/verify_normalizer.py","bytes":5890,"sha256":"69497daee612f35840a1dab48884c65ff38f9344f46898a1342747b224e99409"},{"path":"checks/verify_normalizer_priority.py","bytes":16743,"sha256":"39240f62d5871669e3ca83928c5dbd86a2f9c3c1c8b05ef503f089e5ab5d62c6"},{"path":"checks/verify_normalizer_toy.py","bytes":6990,"sha256":"01ab97870677f22b7ce784e185fe6560e3527836aabcf9870bbb5e0299454321"},{"path":"checks/verify_pair_prior_art.py","bytes":12114,"sha256":"c0a486cb3abff3da959fa01d189bfab31fd2ac51909180ad568e26175b0a7028"},{"path":"checks/verify_physical_selection.py","bytes":8321,"sha256":"8e3eb1db20f65d67f65abfc17207ea9018c4dfecef7d722c4a074930cad7c1b1"},{"path":"checks/verify_probe_access.py","bytes":6205,"sha256":"a5ae69e572d2c986de623bd89e8b388027e103af47899af18144bfe55ab14bdb"},{"path":"checks/verify_repository_integrity.py","bytes":2459,"sha256":"a00edffbdbb000e98bd765b9fd1b222507b265702372cb55c777b88844434e01"},{"path":"checks/verify_seysen_block.py","bytes":10785,"sha256":"3f1835d390b2ab9e9a67ca44e176a7b1ae9a3753a89632d0170b5144717e8104"},{"path":"checks/verify_weight_four.py","bytes":9443,"sha256":"1b27619d29280059eb32d815c3f049035dec054b43cce6e0dda47c5d95200ae8"},{"path":"checks/verify_weight_three.py","bytes":11868,"sha256":"701bb43baa4198dab9a4639c6e763b7d0e809e1a516b011f973432fedcb9a724"},{"path":"circuits/a0_sector.py","bytes":8515,"sha256":"fae6dd1368ed0d1da22cb11abe1d324b49df04efccd307ff81fd6fa19e5799bc"},{"path":"circuits/jordan_aaa.py","bytes":6784,"sha256":"a871f4a1db268063fd7de98cc4fde71efbe0164c5aeb250de8bc517b30849c3e"},{"path":"circuits/leech_xxa.py","bytes":10936,"sha256":"0cfee265c6ef61cb3c43a225006f63a9f395503c60521436c4ef7263c48bceb7"},{"path":"circuits/seysen_qqa.py","bytes":8100,"sha256":"e72b8924d898f9c676d9584a4df857fd9a86dcd3ff970aee6821b9e43907826a"},{"path":"data/monster_character_excerpt.json","bytes":4229,"sha256":"70218f4f87e67896a64c8577b7a86fb0c46cebe3c71678397a7654b8ef0596e0"},{"path":"provenance/Monster_Average_Transport_Checkpoint.zip","bytes":74753,"sha256":"49cf36598860bba792dd5c4a19c8530298b1d11315721c484a61a5605a978cfb"},{"path":"provenance/Monster_Bipartite_Correlations_Checkpoint.zip","bytes":31433,"sha256":"c84add074c170ef9c144a94c1e089f8853d2e22323416af487dfcc058bd59741"},{"path":"provenance/Monster_Correlation_Local_Rigidity_Checkpoint.zip","bytes":10771,"sha256":"44ec14514af43dc75d3472ece10f3f2b15c0637ca4d73235faea7035cff27355"},{"path":"provenance/Monster_Global_Rounding_Checkpoint.zip","bytes":51846,"sha256":"5bf8a6ae9106e8126179d466c326cacb3b485e3dcb89dd761a07905a48daaf94"},{"path":"provenance/Repository_Seed_2026-09-23.zip","bytes":236980,"sha256":"1124a6477e3a71d43c5af08134dcd5347e253ce6fdd57aa257c88992a72661c8"},{"path":"provenance/import_manifest.json","bytes":2568,"sha256":"c8a62f6d0b92733dc507756b37a3c3923b9c0715f8844c3eed7f8098d40700c4"},{"path":"provenance/repository_import.json","bytes":6248,"sha256":"40cbbd8dc95d14f8e278e6ea53bd8df2ae44478bb3c58628b5255ff46cbdf6f5"},{"path":"requirements.txt","bytes":115,"sha256":"3169cba7975e0b743bc2e1b16099491cdc999dacec349ffeadd808298327f559"},{"path":"research/01_local_rigidity.md","bytes":16822,"sha256":"c1938cbc79c8deff194d68e6534a29acb4ea6336873187492652405d06a4bf8a"},{"path":"research/02_pair_correlations.md","bytes":25520,"sha256":"1cca118e861977dfe3496c1eee23b53dd78bf8c78da9078a143228e85f810191"},{"path":"research/03_uniform_axis_rounding.md","bytes":20336,"sha256":"d7d3f30e974354929d06b5f6973686f2b88e033cc335a60865c275853282d2b4"},{"path":"research/04_average_transport.md","bytes":23384,"sha256":"705d25aea83fc81f84391186895792bf54907cfaa1a4895498c33867d40a9ed4"},{"path":"research/05_normalizer_rounding.md","bytes":21830,"sha256":"ae570ca7aab3a41a33e81c092611779b53f68f5f26a9dca16b87a6a7a8bbe6fc"},{"path":"research/06_probe_access.md","bytes":13813,"sha256":"0829c7de9b788f9790ddf26a35ecaf402614cdeaee805f3428fc83bdbadac492"},{"path":"research/07_seysen_qqa_block.md","bytes":17873,"sha256":"bc4dff6c889479ac9c613874eecfcde98d7b484e878ac18cbf1c1cfb38a370e3"},{"path":"research/08_leech_xxa_block.md","bytes":19450,"sha256":"e730574946d67c830019e3a4bb69ce5201d0594248930fda9118c5ec4521613a"},{"path":"research/09_jordan_and_a0_sector.md","bytes":21343,"sha256":"ea1fa33e53f15d806a2632747f368de5158e1a1c4df861c93bcc0ae18a0df907"},{"path":"research/10_normalizer_stability_comparison.md","bytes":28203,"sha256":"435bdbe6a793d58d90b2d98da22bd48165f4488a0ef57972a812d72426ca46de"},{"path":"research/11_pair_test_prior_art_and_conditioning.md","bytes":27381,"sha256":"2ad70f631744d861d623cf239445dccae0b7bb1123382604ba9e0d66fc58c279"},{"path":"research/12_physical_selection_from_extremality.md","bytes":20516,"sha256":"84b7cc0819d6d28302f982400a36b6d4595431555c468fc826cf5f8e941cfade"},{"path":"research/13_weight_three_ope_channel.md","bytes":15409,"sha256":"5aa066d0427d61e6e5cbc6af035e37c3aa589d9bdb427223c000fdb521664edd"},{"path":"research/14_weight_four_and_four_point_closure.md","bytes":19011,"sha256":"f8238846e2a82a011a3b02bb4e7216f439731bf40c7126be635cd07ff96d11e5"},{"path":"results/a0_sector_checks.json","bytes":4711,"sha256":"8d1088aaa78d91006ce6ad8fe1d393bee026a027f45301def021e0d4a1873662"},{"path":"results/a0_sector_resources.json","bytes":1680,"sha256":"99707e5e53c8d30930075d05b6428d3dcb5e0c9164e8e0ece73a5e22e9017519"},{"path":"results/environment.json","bytes":249,"sha256":"a2bca27d98f91806f527103ca01f11699cf3e1b78b92050a24ae56f690ccf156"},{"path":"results/jordan_aaa_resources.json","bytes":1131,"sha256":"7fdc200bcab63a9513ad4ad1b23b7065f208bddc3c7ff0a213806fdf9d2d4ea3"},{"path":"results/leech_xxa_checks.json","bytes":2907,"sha256":"e7e53be06c067f4ceb1cf2aad0bfb6f27f6a18093a849be5de584cf87bde8c3b"},{"path":"results/leech_xxa_resources.json","bytes":1434,"sha256":"88cb634128bfa2a5a00739e45559e4a4a7c1d9188d06901f98ebaec596de53f1"},{"path":"results/normalizer_exact.json","bytes":2664,"sha256":"25302b964def841d062101339fbc9baff43f98eb7f9446bd241e83c5c926623d"},{"path":"results/normalizer_priority.json","bytes":6384,"sha256":"cd7f58dcdfb25c6b62e1d2d506c3ad2749e92c71b14ea7f07478566163fcc705"},{"path":"results/normalizer_toy.json","bytes":2843,"sha256":"6f4fccfaee44033d08efb2ba4229155c61a0a4f2c19e17a3eaf83cfef2ea16ed"},{"path":"results/pair_prior_art.json","bytes":6718,"sha256":"3cd74cfff40ebce808d31e8ad6672abf993e9424f92cdce64ff5f0a4150db463"},{"path":"results/physical_selection.json","bytes":3335,"sha256":"bcb5fb4f41e405ca58d2b0b979fec07bfc2607532addc61300bfe726248137e0"},{"path":"results/probe_access.json","bytes":2043,"sha256":"2eb5a602b494f9204e24fc88bb16e32ed36152733928389222d41405d5957337"},{"path":"results/seysen_block.json","bytes":3472,"sha256":"2c057d1400ef4b4e7c8ccaa561def7d3895864d73e890a8eabb282aa71892b7a"},{"path":"results/verification_summary.json","bytes":2969,"sha256":"6b4c8d56fcc51f3feef8e89bec82db15724c081ac218329a3badbb25915e26ae"},{"path":"results/weight_four.json","bytes":4583,"sha256":"dd1885333e90179c93983ca9997ea65904dd0b99e85b83d31377444e5eb41302"},{"path":"results/weight_three.json","bytes":3643,"sha256":"41c04af8a7564e69c5ed8c2a0a2f5d50568ee6a3074465428821864acf7d6219"},{"path":"verify.py","bytes":6660,"sha256":"db5adc341da7c3382b7ba208b287324b20627bc1f5fa9d5b54a4d81ddccd1ce8"},{"path":"work_orders/CURRENT.md","bytes":2143,"sha256":"36f01aabd62c23e4ee157da5cd95bfe01f1f55a62eac55ff08847035ef688f26"},{"path":"work_orders/INDEPENDENT_AUDIT.md","bytes":4133,"sha256":"42fec084b5aae524e7a2ee85d9a0d68ff743faa3b32ca0fe61310c2a9240ae13"}],"scope":"Hopf-style presentation integration from 7653d6cef036f40db2746b3379e84dc161b18f55. Only the README record changes; all other snapshot records and scientific payloads remain identical. The exact eight-page presentation transform and display-check/workflow changes are declared in results/hopf_style_changes.json. Historical manifests remain unchanged."} +{"files":[{"path":".github/workflows/research-checks.yml","bytes":4288,"sha256":"2711277a2159a5fc4dcf44e1ccf65187c25567a2e51b33e4aa5a0c3bad6860e8"},{"path":".gitignore","bytes":55,"sha256":"4ba859c0b25cbb1709b401dd85682d4445f38e7d9237a9b90cf3f9fca642f00e"},{"path":"AGENTS.md","bytes":2367,"sha256":"e1e288d4ad55d6804c322a165ee74bfa0e28ef668fd118a4a37794bfd20cb393"},{"path":"COPYING.md","bytes":907,"sha256":"2ea9d486f9dc494c4ded969798acb6c7688ec71140bf33dcb2b2e1d857883873"},{"path":"LICENSE","bytes":1065,"sha256":"a92600540b1ab7a18301e2632a29334b3df227ad836e88df9967d69e3c86db66"},{"path":"PHYSICS_STATUS.md","bytes":5631,"sha256":"55effd5dc57bc13e279a743127d0495bd919f9ffbcc3b3755f3b176fd259fc4d"},{"path":"README.md","bytes":6384,"sha256":"977289a6e03fa80a987d25a8baed1554ea373a1fbf2eeec877aa417312dd452b"},{"path":"STATUS.md","bytes":4398,"sha256":"7546c5a5449dfeb43c8575f9939e3f0971b4d7869377ccb6864c0bc082f8eef4"},{"path":"STATUS_CURRENT.md","bytes":11106,"sha256":"9d8f96cca1cb89368cb4f43cace66f8aedc71fad447dfaa29c6c0b368f448200"},{"path":"WORKSPACES.md","bytes":2261,"sha256":"e10b268c0668b9dec24dec715f6462fda7cf2d6df04fbc3694def4dcb886fd66"},{"path":"audits/README.md","bytes":1702,"sha256":"11e8429fe585af944f71f3599503ee72dccbb8d121e9c5838b04a3fc57a8d9b4"},{"path":"audits/integration_20260925.md","bytes":4941,"sha256":"3f0531fde8bfe6599f261e2c1817697cabaf07be01b68c2cd116b345f0d33af7"},{"path":"audits/physical_integration_replay_erratum.md","bytes":1897,"sha256":"f0144624a15ca5beb602a173184b8a1f9f2d84616fb24f5e49b4dd44a8854667"},{"path":"audits/priority_matrix.md","bytes":5616,"sha256":"28a0bcfe5c8c99b8907fb4e36d7601aaf6fdf3a006d39466a45c6a2b7d8bf37a"},{"path":"audits/robustness_proof_audit.md","bytes":29095,"sha256":"810bb5d07df79dda965d0cadc2ff09b31b5a1075b59c8b5f44c28a962a978e69"},{"path":"audits/voa_extrema_audit.md","bytes":30655,"sha256":"75569858501ad1d9e0961588a41dbe039b7b8bf46938c9df6b0af0374f6b7275"},{"path":"checks/audit_parameter_domains.py","bytes":11473,"sha256":"2c0f2829ab86609f87622f06087f677abf170fc212c690dad1232f4a03656ebe"},{"path":"checks/replay_portability.py","bytes":5818,"sha256":"91a6be536bd797007548ec5912c272e9d389d9a2e2622337f55135ba23798749"},{"path":"checks/verify_a0_sector.py","bytes":17553,"sha256":"7ffcfefd58f58af90bd02cdf22d695f93aac06d41a5ab29023c826f5669465ba"},{"path":"checks/verify_leech_xxa.py","bytes":12969,"sha256":"7a6a501009c93271966839c152c123526b3f130d7a469bb8335329a17951f829"},{"path":"checks/verify_normalizer.py","bytes":5890,"sha256":"69497daee612f35840a1dab48884c65ff38f9344f46898a1342747b224e99409"},{"path":"checks/verify_normalizer_priority.py","bytes":16743,"sha256":"39240f62d5871669e3ca83928c5dbd86a2f9c3c1c8b05ef503f089e5ab5d62c6"},{"path":"checks/verify_normalizer_toy.py","bytes":6990,"sha256":"01ab97870677f22b7ce784e185fe6560e3527836aabcf9870bbb5e0299454321"},{"path":"checks/verify_pair_prior_art.py","bytes":12114,"sha256":"c0a486cb3abff3da959fa01d189bfab31fd2ac51909180ad568e26175b0a7028"},{"path":"checks/verify_physical_selection.py","bytes":8321,"sha256":"8e3eb1db20f65d67f65abfc17207ea9018c4dfecef7d722c4a074930cad7c1b1"},{"path":"checks/verify_probe_access.py","bytes":6205,"sha256":"a5ae69e572d2c986de623bd89e8b388027e103af47899af18144bfe55ab14bdb"},{"path":"checks/verify_repository_integrity.py","bytes":2459,"sha256":"a00edffbdbb000e98bd765b9fd1b222507b265702372cb55c777b88844434e01"},{"path":"checks/verify_seysen_block.py","bytes":10785,"sha256":"3f1835d390b2ab9e9a67ca44e176a7b1ae9a3753a89632d0170b5144717e8104"},{"path":"checks/verify_weight_four.py","bytes":9443,"sha256":"1b27619d29280059eb32d815c3f049035dec054b43cce6e0dda47c5d95200ae8"},{"path":"checks/verify_weight_three.py","bytes":11868,"sha256":"701bb43baa4198dab9a4639c6e763b7d0e809e1a516b011f973432fedcb9a724"},{"path":"circuits/a0_sector.py","bytes":8515,"sha256":"fae6dd1368ed0d1da22cb11abe1d324b49df04efccd307ff81fd6fa19e5799bc"},{"path":"circuits/jordan_aaa.py","bytes":6784,"sha256":"a871f4a1db268063fd7de98cc4fde71efbe0164c5aeb250de8bc517b30849c3e"},{"path":"circuits/leech_xxa.py","bytes":10936,"sha256":"0cfee265c6ef61cb3c43a225006f63a9f395503c60521436c4ef7263c48bceb7"},{"path":"circuits/seysen_qqa.py","bytes":8100,"sha256":"e72b8924d898f9c676d9584a4df857fd9a86dcd3ff970aee6821b9e43907826a"},{"path":"data/monster_character_excerpt.json","bytes":4229,"sha256":"70218f4f87e67896a64c8577b7a86fb0c46cebe3c71678397a7654b8ef0596e0"},{"path":"provenance/Monster_Average_Transport_Checkpoint.zip","bytes":74753,"sha256":"49cf36598860bba792dd5c4a19c8530298b1d11315721c484a61a5605a978cfb"},{"path":"provenance/Monster_Bipartite_Correlations_Checkpoint.zip","bytes":31433,"sha256":"c84add074c170ef9c144a94c1e089f8853d2e22323416af487dfcc058bd59741"},{"path":"provenance/Monster_Correlation_Local_Rigidity_Checkpoint.zip","bytes":10771,"sha256":"44ec14514af43dc75d3472ece10f3f2b15c0637ca4d73235faea7035cff27355"},{"path":"provenance/Monster_Global_Rounding_Checkpoint.zip","bytes":51846,"sha256":"5bf8a6ae9106e8126179d466c326cacb3b485e3dcb89dd761a07905a48daaf94"},{"path":"provenance/Repository_Seed_2026-09-23.zip","bytes":236980,"sha256":"1124a6477e3a71d43c5af08134dcd5347e253ce6fdd57aa257c88992a72661c8"},{"path":"provenance/import_manifest.json","bytes":2568,"sha256":"c8a62f6d0b92733dc507756b37a3c3923b9c0715f8844c3eed7f8098d40700c4"},{"path":"provenance/repository_import.json","bytes":6248,"sha256":"40cbbd8dc95d14f8e278e6ea53bd8df2ae44478bb3c58628b5255ff46cbdf6f5"},{"path":"requirements.txt","bytes":115,"sha256":"3169cba7975e0b743bc2e1b16099491cdc999dacec349ffeadd808298327f559"},{"path":"research/01_local_rigidity.md","bytes":16822,"sha256":"c1938cbc79c8deff194d68e6534a29acb4ea6336873187492652405d06a4bf8a"},{"path":"research/02_pair_correlations.md","bytes":25520,"sha256":"1cca118e861977dfe3496c1eee23b53dd78bf8c78da9078a143228e85f810191"},{"path":"research/03_uniform_axis_rounding.md","bytes":20336,"sha256":"d7d3f30e974354929d06b5f6973686f2b88e033cc335a60865c275853282d2b4"},{"path":"research/04_average_transport.md","bytes":23384,"sha256":"705d25aea83fc81f84391186895792bf54907cfaa1a4895498c33867d40a9ed4"},{"path":"research/05_normalizer_rounding.md","bytes":21830,"sha256":"ae570ca7aab3a41a33e81c092611779b53f68f5f26a9dca16b87a6a7a8bbe6fc"},{"path":"research/06_probe_access.md","bytes":13813,"sha256":"0829c7de9b788f9790ddf26a35ecaf402614cdeaee805f3428fc83bdbadac492"},{"path":"research/07_seysen_qqa_block.md","bytes":17873,"sha256":"bc4dff6c889479ac9c613874eecfcde98d7b484e878ac18cbf1c1cfb38a370e3"},{"path":"research/08_leech_xxa_block.md","bytes":19450,"sha256":"e730574946d67c830019e3a4bb69ce5201d0594248930fda9118c5ec4521613a"},{"path":"research/09_jordan_and_a0_sector.md","bytes":21343,"sha256":"ea1fa33e53f15d806a2632747f368de5158e1a1c4df861c93bcc0ae18a0df907"},{"path":"research/10_normalizer_stability_comparison.md","bytes":28203,"sha256":"435bdbe6a793d58d90b2d98da22bd48165f4488a0ef57972a812d72426ca46de"},{"path":"research/11_pair_test_prior_art_and_conditioning.md","bytes":27381,"sha256":"2ad70f631744d861d623cf239445dccae0b7bb1123382604ba9e0d66fc58c279"},{"path":"research/12_physical_selection_from_extremality.md","bytes":20516,"sha256":"84b7cc0819d6d28302f982400a36b6d4595431555c468fc826cf5f8e941cfade"},{"path":"research/13_weight_three_ope_channel.md","bytes":15409,"sha256":"5aa066d0427d61e6e5cbc6af035e37c3aa589d9bdb427223c000fdb521664edd"},{"path":"research/14_weight_four_and_four_point_closure.md","bytes":19011,"sha256":"f8238846e2a82a011a3b02bb4e7216f439731bf40c7126be635cd07ff96d11e5"},{"path":"results/a0_sector_checks.json","bytes":4711,"sha256":"8d1088aaa78d91006ce6ad8fe1d393bee026a027f45301def021e0d4a1873662"},{"path":"results/a0_sector_resources.json","bytes":1680,"sha256":"99707e5e53c8d30930075d05b6428d3dcb5e0c9164e8e0ece73a5e22e9017519"},{"path":"results/environment.json","bytes":249,"sha256":"a2bca27d98f91806f527103ca01f11699cf3e1b78b92050a24ae56f690ccf156"},{"path":"results/jordan_aaa_resources.json","bytes":1131,"sha256":"7fdc200bcab63a9513ad4ad1b23b7065f208bddc3c7ff0a213806fdf9d2d4ea3"},{"path":"results/leech_xxa_checks.json","bytes":2907,"sha256":"e7e53be06c067f4ceb1cf2aad0bfb6f27f6a18093a849be5de584cf87bde8c3b"},{"path":"results/leech_xxa_resources.json","bytes":1434,"sha256":"88cb634128bfa2a5a00739e45559e4a4a7c1d9188d06901f98ebaec596de53f1"},{"path":"results/normalizer_exact.json","bytes":2664,"sha256":"25302b964def841d062101339fbc9baff43f98eb7f9446bd241e83c5c926623d"},{"path":"results/normalizer_priority.json","bytes":6384,"sha256":"cd7f58dcdfb25c6b62e1d2d506c3ad2749e92c71b14ea7f07478566163fcc705"},{"path":"results/normalizer_toy.json","bytes":2843,"sha256":"6f4fccfaee44033d08efb2ba4229155c61a0a4f2c19e17a3eaf83cfef2ea16ed"},{"path":"results/pair_prior_art.json","bytes":6718,"sha256":"3cd74cfff40ebce808d31e8ad6672abf993e9424f92cdce64ff5f0a4150db463"},{"path":"results/physical_selection.json","bytes":3335,"sha256":"bcb5fb4f41e405ca58d2b0b979fec07bfc2607532addc61300bfe726248137e0"},{"path":"results/probe_access.json","bytes":2043,"sha256":"2eb5a602b494f9204e24fc88bb16e32ed36152733928389222d41405d5957337"},{"path":"results/seysen_block.json","bytes":3472,"sha256":"2c057d1400ef4b4e7c8ccaa561def7d3895864d73e890a8eabb282aa71892b7a"},{"path":"results/verification_summary.json","bytes":2969,"sha256":"6b4c8d56fcc51f3feef8e89bec82db15724c081ac218329a3badbb25915e26ae"},{"path":"results/weight_four.json","bytes":4583,"sha256":"dd1885333e90179c93983ca9997ea65904dd0b99e85b83d31377444e5eb41302"},{"path":"results/weight_three.json","bytes":3643,"sha256":"41c04af8a7564e69c5ed8c2a0a2f5d50568ee6a3074465428821864acf7d6219"},{"path":"verify.py","bytes":6660,"sha256":"db5adc341da7c3382b7ba208b287324b20627bc1f5fa9d5b54a4d81ddccd1ce8"},{"path":"work_orders/CURRENT.md","bytes":2143,"sha256":"36f01aabd62c23e4ee157da5cd95bfe01f1f55a62eac55ff08847035ef688f26"},{"path":"work_orders/INDEPENDENT_AUDIT.md","bytes":4133,"sha256":"42fec084b5aae524e7a2ee85d9a0d68ff743faa3b32ca0fe61310c2a9240ae13"}],"scope":"Pre-release source snapshot. Membership and all unchanged records are retained; README and historical-status banner changes are intentional. Full current inventory and declared source delta: results/release_preparation.json. Historical report and integration manifests remain frozen."} diff --git a/verify_current.py b/verify_current.py new file mode 100644 index 0000000..d22f278 --- /dev/null +++ b/verify_current.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python3 +"""Run current exact checks; keep historical strict replay and portability distinct. + +The default requires only the standard library. --all also requires the pinned +NumPy reproduction dependency. Logs may be saved outside the checkout. +""" +from __future__ import annotations +import argparse +import hashlib +import json +import os +from pathlib import Path +import subprocess +import sys + +ROOT = Path(__file__).resolve().parent +sys.path.insert(0, str(ROOT / 'checks')) +from release_integrity import verify_files, require + +CURRENT = ('checks/verify_extraction_core.py', + 'checks/verify_calibration_and_sharpness.py', + 'checks/audit_quantitative_core.py', + 'checks/verify_calibration_scales.py', + 'checks/verify_release_package.py') +KNOWN_REPLAY = { + 'RuntimeError: prior average toy differs from recorded report under None', + 'RuntimeError: prior pair toy differs from recorded report under None', +} + + +def run(script: str, flags: list[str], output: Path | None) -> tuple[dict, bytes, str]: + env = dict(os.environ, OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', + MKL_NUM_THREADS='1', PYTHONDONTWRITEBYTECODE='1') + command = [sys.executable, *flags, script] + try: + result = subprocess.run(command, cwd=ROOT, env=env, capture_output=True, timeout=120) + code, stdout, stderr = result.returncode, result.stdout, result.stderr.decode(errors='replace') + except subprocess.TimeoutExpired: + code, stdout, stderr = 124, b'', 'Verification subprocess exceeded 120 seconds' + label = flags[0] if flags else 'normal' + row = {'mode': label, 'returncode': code, 'stdout_sha256': hashlib.sha256(stdout).hexdigest()} + if output: + name = script.replace('/', '__').replace('.py', '') + '-' + label.lstrip('-') + (output / (name + '.stdout')).write_bytes(stdout) + (output / (name + '.stderr')).write_text(stderr) + if code: + row['stderr_tail'] = '\n'.join(stderr.splitlines()[-3:]) + return row, stdout, stderr + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--all', action='store_true', help='all current checkers plus historical comparisons') + parser.add_argument('--require-strict-replay', action='store_true', help='fail for any historical mismatch') + parser.add_argument('--baseline', type=Path, help='optional pinned pre-release checkout for full delta comparison') + parser.add_argument('--output', type=Path, help='save stdout/stderr outside the repository') + args = parser.parse_args() + if args.require_strict_replay and not args.all: + parser.error('--require-strict-replay requires --all') + if args.output: + args.output = args.output.resolve() + require(not args.output.is_relative_to(ROOT.resolve()), 'Output must be outside the repository') + args.output.mkdir(parents=True, exist_ok=True) + integrity = verify_files(baseline=args.baseline) + manifest_before = (ROOT / 'results/release_preparation.json').read_bytes() + expected = {r['script']: r for r in json.loads((ROOT / 'results/current_reports.json').read_text())['reports']} + scripts = list(CURRENT) + if args.all: + additional = [str(p.relative_to(ROOT)) for p in sorted((ROOT / 'checks').glob('*.py')) + if p.name.startswith(('audit_', 'verify_'))] + scripts = list(dict.fromkeys([*scripts, *additional])) + rows, failures = [], [] + for script in scripts: + runs = [run(script, opt, args.output) for opt in ([], ['-O'], ['-OO'])] + report = {'script': script, 'modes': [r[0] for r in runs], + 'mode_outputs_identical': all(r[1] == runs[0][1] for r in runs)} + ok = all(r[0]['returncode'] == 0 for r in runs) and report['mode_outputs_identical'] + if script in expected: + try: + payload = json.loads(runs[0][1]) + matches = (runs[0][0]['stdout_sha256'] == expected[script]['sha256'] and + payload['checks'] == expected[script]['checks']) + except (ValueError, KeyError): + matches = False + report['current_fingerprint_matches'] = matches + ok = ok and matches + if not ok: + failures.append(script) + rows.append(report) + print(('PASS ' if ok else 'FAIL ') + script, file=sys.stderr, flush=True) + historical = {'run': False} + if args.all: + strict = run('verify.py', [], args.output) + portable = run('checks/replay_portability.py', [], args.output) + strict_ok = strict[0]['returncode'] == 0 + error_line = strict[2].strip().splitlines()[-1] if strict[2].strip() else '' + known = not strict_ok and error_line in KNOWN_REPLAY + try: + port = json.loads(portable[1]) + port_ok = portable[0]['returncode'] == 0 and port['status'].startswith('PASS') + except (ValueError, KeyError): + port, port_ok = {}, False + historical = {'run': True, 'strict_byte_replay': 'PASS' if strict_ok else 'FAIL', + 'known_float_report_mismatch': known, + 'bounded_portability': 'PASS' if port_ok else 'FAIL', + 'all_reports_byte_identical': port.get('all_reports_byte_identical'), + 'different_float_leaves': sum(r.get('different_float_leaves', 0) for r in port.get('reports', [])), + 'strict_error': error_line if not strict_ok else None} + if not port_ok or (not strict_ok and (not known or args.require_strict_replay)): + failures.append('historical_replay_requirement') + print(json.dumps(historical, sort_keys=True), file=sys.stderr, flush=True) + verify_files(baseline=args.baseline) + require(manifest_before == (ROOT / 'results/release_preparation.json').read_bytes(), + 'Release manifest changed during verification') + status = 'FAIL' if failures else 'PASS_CURRENT' + if not failures and historical.get('strict_byte_replay') == 'FAIL': + status = 'PASS_CURRENT_WITH_HISTORICAL_STRICT_FAILURE' + summary = {'status': status, 'current_checker_count': len(rows), 'current_runs': 3*len(rows), + 'integrity': integrity, 'reports': rows, 'failures': failures, + 'historical': historical, 'source_theorems_verified': False, + 'live_GitHub_render_verified': False} + text = json.dumps(summary, sort_keys=True, indent=2) + '\n' + if args.output: + (args.output / 'summary.json').write_text(text) + print(text, end='') + return 1 if failures else 0 + + +if __name__ == '__main__': + try: + sys.exit(main()) + except (OSError, RuntimeError, ValueError, subprocess.SubprocessError) as exc: + print('FAIL current verification: ' + str(exc), file=sys.stderr) + sys.exit(1)