From fe85c2dc4903a898f1f48b3e97c5ce91fd7b7bad Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:32:13 +1000 Subject: [PATCH 01/23] Start adversarial chronometric frontier evidence repair --- .../frontier-evidence-v2/README.md | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/README.md diff --git a/chronometric-emergence/frontier-evidence-v2/README.md b/chronometric-emergence/frontier-evidence-v2/README.md new file mode 100644 index 0000000..25e9f2b --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/README.md @@ -0,0 +1,31 @@ +# Chronometric emergence — frontier evidence repair v2 + +**Author: Angus Muffatti** + +This is the adversarial repair layer created after an independent audit found that many earlier `PASS` labels proved internal consistency rather than physics. It does not conceal that result. It turns the criticism into executable gates. + +## What this package actually does + +- independently checks the magnitudes of all eleven three-loop 3PI ledger coefficients by coloured half-edge graph automorphisms; +- demonstrates that the former v1.3 RG cancellation was imposed rather than derived and formally retracts it; +- runs a genuine non-Markovian two-time scalar benchmark with independent normal-mode and causal-memory solvers, timestep/memory convergence, commutator, FDT, and energy diagnostics; +- recalculates the cascade daughter fate and supplies an exact-`Z6` gauge-charged thermalisation repair; +- evaluates the low-`f_a` ridge for Earth, Sun, white dwarfs, and neutron stars; +- quantifies a 24-link gauge/deconstruction route to the required UV quality; +- recomputes the v1.4 LPM diagnostic with the corrected collinear mass combination, executes the v1.5 high-resolution recomputation, and checks weak-scattering scaling; +- measures the v1.7/v1.8 off-shell model discrepancy and forbids table extrapolation; +- scans portability and replaces the old binary `PASS` vocabulary with an evidence taxonomy. + +## Run + +```bash +python -m pip install -e '.[test]' +python -m frontier_evidence.run_all --repo-root ../.. +pytest -q +``` + +The run writes machine-readable evidence to `results/` and a consolidated report to `docs/FRONTIER_EVIDENCE_REPORT.md`. + +## Honest status + +The package earns a **credible evidence frontier** for the narrow formal theorem, one-loop threshold interpretation, code-quality repairs, and scalar two-time infrastructure. It does **not** yet earn the claimed non-Abelian/cosmological frontier: neutron-star conversion, full UV completion, complete hard+LPM matching, and a real 3PI evolution engine remain load-bearing. From 6998c30e6f60434fd99d9d056328a3cfa898b2b2 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:32:28 +1000 Subject: [PATCH 02/23] Add frontier evidence authorship --- chronometric-emergence/frontier-evidence-v2/AUTHORS.md | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/AUTHORS.md diff --git a/chronometric-emergence/frontier-evidence-v2/AUTHORS.md b/chronometric-emergence/frontier-evidence-v2/AUTHORS.md new file mode 100644 index 0000000..d64952d --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/AUTHORS.md @@ -0,0 +1,5 @@ +# Authors + +**Angus Muffatti** — research programme, models, calculations, manuscripts, and this evidence-repair package. + +AI assistance was used for derivation, implementation, testing, and editorial work. Every result in this folder is classified by evidence type; no AI-generated statement is treated as independently verified merely because code reproduces it. From e2d4a0d17e6370fc9d8cbd13be59914bea5eb4b6 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:32:39 +1000 Subject: [PATCH 03/23] Define evidence taxonomy --- .../frontier-evidence-v2/EVIDENCE_POLICY.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/EVIDENCE_POLICY.md diff --git a/chronometric-emergence/frontier-evidence-v2/EVIDENCE_POLICY.md b/chronometric-emergence/frontier-evidence-v2/EVIDENCE_POLICY.md new file mode 100644 index 0000000..73a84a0 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/EVIDENCE_POLICY.md @@ -0,0 +1,16 @@ +# Evidence policy + +The former project matrices compressed unlike checks into the word `PASS`. This package forbids that practice. + +| Class | Meaning | What it does **not** establish | +|---|---|---| +| `IDENTITY_PIN` | An algebraic identity or construction is encoded consistently. | Physical correctness of the construction. | +| `REGRESSION` | Current code reproduces an earlier stored output. | Independent recomputation. | +| `INDEPENDENT_RECOMPUTATION` | A separate implementation reaches the result from declared inputs. | Continuum convergence or empirical truth. | +| `CONVERGENCE` | The observable stabilises under resolution, timestep, cutoff, or memory changes. | Correctness of the underlying model. | +| `EXTERNAL_BENCHMARK` | Agreement with an analytic or published result not generated by the tested code. | Validity outside the benchmark domain. | +| `PREDICTION` | A genuinely fallible calculation produces a model consequence not built into the test. | Experimental confirmation. | +| `BLOCKED` | A load-bearing issue is unresolved. | Permission to silently assume the issue away. | +| `RETRACTED` | A prior claim is withdrawn. | That downstream numbers remain valid. | + +A frontier claim requires at least one independent recomputation, one convergence study, and one external benchmark for each load-bearing numerical layer. Identity pins and regressions remain useful software tests, but they may not be cited as physical validation. From 67a57c5a2261d8253be13ce0e0850f890439b4c3 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:32:54 +1000 Subject: [PATCH 04/23] Add corrected frontier gates --- .../frontier-evidence-v2/FRONTIER_GATES.md | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/FRONTIER_GATES.md diff --git a/chronometric-emergence/frontier-evidence-v2/FRONTIER_GATES.md b/chronometric-emergence/frontier-evidence-v2/FRONTIER_GATES.md new file mode 100644 index 0000000..0f031db --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/FRONTIER_GATES.md @@ -0,0 +1,32 @@ +# Frontier gates + +## Gate A — formal core + +The universal-clock factorisation theorem and the definition of chronometric shear must be stated with their exact hypotheses. The rank diagnostic may infer the number of fields only under full-rank sensitivity and independent-excitation assumptions. + +## Gate B — QCD transmission + +`2/27` is retained strictly as the leading one-loop threshold coefficient. Higher-order matching and hadronic sensitivities must carry an uncertainty band. + +## Gate C — transport + +The v1.4 numerical table is deprecated. A corrected mass combination, convergence run, Bethe–Heitler limit, and external normalisation benchmark are required. The v1.5 implementation is the current anchor, not a proof of the complete leading-order portal rate. + +## Gate D — real-time evolution + +A real two-time calculation must evolve from equations rather than reload stored answers. Timestep and memory-window convergence, commutator normalisation, FDT/KMS, and energy diagnostics are mandatory. The scalar open-system unit tier in this package satisfies this software gate. It does not substitute for the non-Abelian 3PI solver. + +## Gate E — cosmology and compact objects + +The prompt daughter in the fermionic cascade must thermalise through an explicit interaction. The low-`f_a` ridge must be evaluated for compact objects. Neutron-star conversion and binary constraints remain model blockers unless a demonstrated screening or alternate cosmological-selection mechanism is supplied. + +## Gate F — UV quality + +The elementary global-field implementation fails the required quality bound. A local gauge/deconstructed completion must suppress the first allowed winding operator below the declared vacuum potential. + +## Current authorization + +- Scalar two-time unit tier: **authorized and implemented**. +- Corrected transport evidence run: **authorized; results generated by CI**. +- Full PT/BFM three-loop 3PI pilot: **NOT AUTHORIZED** until an actual evolution engine exists and Gates C–F are resolved at the level relevant to the claimed observable. +- Publication of the narrow formal/threshold note: **conditional** on specialist novelty review and independent source audit. From 8ea61906e10c6b17be7b4642ba25b6a18a18d4d8 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:33:13 +1000 Subject: [PATCH 05/23] Publish chronometric errata --- .../frontier-evidence-v2/ERRATA.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/ERRATA.md diff --git a/chronometric-emergence/frontier-evidence-v2/ERRATA.md b/chronometric-emergence/frontier-evidence-v2/ERRATA.md new file mode 100644 index 0000000..73c03a8 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/ERRATA.md @@ -0,0 +1,13 @@ +# Errata and claim corrections + +1. **v1.3 RG completion — retracted.** The displayed finite term was chosen to cancel the explicit matching-scale logarithm. The cancellation is an identity pin, not a derived anomalous-dimension result. The natural-scale hard matching value may be retained; the claimed RG closure may not. +2. **v1.4 direct AMY numbers — deprecated.** The collinear mass combination was implemented with the wrong structure. This package recomputes the diagnostic with the corrected combination and treats v1.5 as the principal LPM anchor. +3. **v1.5 default verifier — relabelled.** Stored high-resolution and scan values are regressions unless `--recompute-high --recompute-scan` is used. +4. **v1.7–v1.8 Ward/STI tests — relabelled.** Line-integral longitudinal vertices are construction pins. They are not evidence that a finite non-Abelian truncation preserves the full dynamical STI/Nielsen system. +5. **v1.7–v1.8 off-shell kernels — model family only.** Their on-shell anchors are useful; their arbitrary off-shell shapes are ansätze. The inter-version spread is reported as model discrepancy, not a calculated uncertainty bar. +6. **v1.9 pilot authorization — withdrawn.** The package contains specifications, ledgers, preflight checks, and loaders but no 3PI/Kadanoff–Baym evolution engine. +7. **v0.7 screening theorem — domain restricted.** Its `f_a >= M_P` corollary cannot be applied to the low-`f_a` cosmological ridge. Compact objects are recalculated here. +8. **v1.2 prompt daughter — original assumption unsupported.** A sterile/free-streaming daughter overproduces dark radiation. This package supplies an exact-replica, gauge-charged daughter repair and a rate calculation. +9. **v0.2 speed/gap relations — model-specific.** They are tree-level consequences of the minimal one-mediator EFT, not universal laws. +10. **v0.4 high-scale scalar benchmark — withdrawn as a UV-stable benchmark.** The one-loop quartic running found later requires threshold stabilisation or a two-loop vacuum analysis. +11. **Precision.** Reported digits now follow numerical resolution and theory uncertainty; symbolic identities may retain exact forms. From 7282d22f2afc331e7d16e1d0100873357e8ed32b Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:33:25 +1000 Subject: [PATCH 06/23] Add response to independent audit --- .../frontier-evidence-v2/AUDIT_RESPONSE.md | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/AUDIT_RESPONSE.md diff --git a/chronometric-emergence/frontier-evidence-v2/AUDIT_RESPONSE.md b/chronometric-emergence/frontier-evidence-v2/AUDIT_RESPONSE.md new file mode 100644 index 0000000..4571762 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/AUDIT_RESPONSE.md @@ -0,0 +1,22 @@ +# Response to the independent audit + +The audit's central criticism is accepted: the project often treated identity checks and regression fixtures as if they were independent physical evidence. The repair does not contest that by rhetoric. It changes the evidence architecture and reruns the load-bearing layers. + +## Findings accepted without qualification + +- The v1.4 collinear mass combination was structurally wrong. +- The v1.3 finite “RG completion” was chosen to cancel the scale logarithm and was not derived from an anomalous-dimension calculation. +- The v1.9 package was a specification/preflight bundle, not a 3PI evolution solver; “pilot authorized” was false. +- The v1.7/v1.8 longitudinal Ward checks were largely true by construction. +- Stored v1.5 values were regression fixtures unless explicit recomputation flags were used. +- The v0.7 `f_a >= M_P` compactness corollary was applied outside its domain on the low-`f_a` ridge. +- The prompt daughter in the v1.2 cascade had no demonstrated thermalisation channel. +- Sandbox-specific paths prevented clean-checkout reproducibility. + +## Audit numbers treated as hypotheses until reproduced + +The audit reported several precise downstream numbers. This package independently recalculates the transport shifts, prompt-daughter dark radiation, compactness, off-shell model spread, and UV-quality requirement. The audit's values are not copied into acceptance tests. + +## Scientific consequence + +The narrow formal core and leading one-loop threshold interpretation survive. The cosmological and non-Abelian-HPC superstructure does not retain frontier status merely because a preflight script passes. Negative results and blockers are now first-class outputs. From 0562fb81fa018184514164fe22893d5519501e7b Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:33:36 +1000 Subject: [PATCH 07/23] Declare frontier evidence dependencies --- .../frontier-evidence-v2/pyproject.toml | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/pyproject.toml diff --git a/chronometric-emergence/frontier-evidence-v2/pyproject.toml b/chronometric-emergence/frontier-evidence-v2/pyproject.toml new file mode 100644 index 0000000..3f96621 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/pyproject.toml @@ -0,0 +1,29 @@ +[build-system] +requires = ["setuptools>=69", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "chronometric-frontier-evidence" +version = "2.0.0" +description = "Adversarial evidence and repair suite for chronometric emergence" +requires-python = ">=3.11" +dependencies = [ + "numpy>=1.26", + "scipy>=1.12", + "sympy>=1.12", + "networkx>=3.2", + "PyYAML>=6.0", +] + +[project.optional-dependencies] +test = ["pytest>=8.0"] + +[tool.setuptools] +package-dir = {"" = "src"} + +[tool.setuptools.packages.find] +where = ["src"] + +[tool.pytest.ini_options] +testpaths = ["tests"] +addopts = "-ra" From 98578189befc9a9433cb627bab8c74f13a05fd39 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:33:52 +1000 Subject: [PATCH 08/23] Add frontier evidence build targets --- chronometric-emergence/frontier-evidence-v2/Makefile | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/Makefile diff --git a/chronometric-emergence/frontier-evidence-v2/Makefile b/chronometric-emergence/frontier-evidence-v2/Makefile new file mode 100644 index 0000000..c027286 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/Makefile @@ -0,0 +1,12 @@ +PYTHON ?= python3 +REPO_ROOT ?= ../.. + +.PHONY: reproduce test clean +reproduce: + $(PYTHON) -m frontier_evidence.run_all --repo-root $(REPO_ROOT) + +test: + pytest -q + +clean: + rm -f results/*.json results/*.csv results/*.npz docs/FRONTIER_EVIDENCE_REPORT.md From 185862570850a6b0f7dbd733f1be434e14a44c60 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:34:02 +1000 Subject: [PATCH 09/23] Initialize frontier evidence package --- .../frontier-evidence-v2/src/frontier_evidence/__init__.py | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/__init__.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/__init__.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/__init__.py new file mode 100644 index 0000000..e94addd --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/__init__.py @@ -0,0 +1,4 @@ +"""Evidence-repair suite for the chronometric-emergence programme.""" + +__all__ = ["__version__"] +__version__ = "2.0.0" From debf2a16849a8eb48caf1eb1739bbb133007e8dc Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:34:31 +1000 Subject: [PATCH 10/23] Add corrected formal-core statements --- .../src/frontier_evidence/formal_core.py | 67 +++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/formal_core.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/formal_core.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/formal_core.py new file mode 100644 index 0000000..41ae8e9 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/formal_core.py @@ -0,0 +1,67 @@ +"""Corrected formal statements for the surviving chronometric core.""" +from __future__ import annotations + +import json +from pathlib import Path + + +def run() -> dict: + return { + "evidence_class": "IDENTITY_PIN", + "universal_clock_factorisation": { + "statement": ( + "On a connected domain with positive differentiable frequencies omega_A, " + "there exist a positive scalar chi and positive constants c_A such that " + "omega_A=c_A chi for every A iff d ln(omega_A/omega_B)=0 for every pair." + ), + "proof_outline": [ + "factorisation implies every ratio is constant", + "if all ratio differentials vanish, choose a reference clock B and set chi=omega_B", + "connectedness makes each ratio omega_A/omega_B a constant c_A", + ], + "status": "EXACT_ELEMENTARY_THEOREM", + }, + "rank_diagnostic": { + "one_way_bound": "rank(clock-ratio response) <= number of independent non-universal fields", + "inference_conditions": [ + "the clock sensitivity-difference matrix has full column rank on the active fields", + "the fields are independently excited over the data set", + "noise and unmodelled systematics do not lower the observed rank", + ], + "correction": ( + "Observed rank r does not by itself prove that exactly r fields exist; it is a lower " + "bound only under the declared genericity and excitation assumptions." + ), + }, + "v0_2_relations": { + "status": "RETIRED_AS_UNIVERSAL_CLAIMS", + "retained_scope": "tree-level consistency relations of the minimal one-mediator soft-null EFT", + }, + "v0_4_benchmark": { + "status": "WITHDRAWN_AS_UV_STABLE_BENCHMARK", + "reason": "later one-loop running drove the displayed Higgs quartic negative before the heavy scale", + }, + "novelty_status": ( + "The theorem is elementary once stated. Candidate novelty lies in the clock-space quotient, " + "chronometric-shear interpretation, and its use as a model-selection/experimental framework; " + "specialist priority review remains required." + ), + } + + +def write_results(output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run() + (output_dir / "formal_core_results.json").write_text( + json.dumps(result, indent=2) + "\n", encoding="utf-8" + ) + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + answer = write_results(args.output_dir) + print(json.dumps(answer, indent=2)) From 5b9c0adc4964084f7d993588d75ef10260532353 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:34:51 +1000 Subject: [PATCH 11/23] Add QCD threshold uncertainty audit --- .../src/frontier_evidence/qcd_threshold.py | 67 +++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/qcd_threshold.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/qcd_threshold.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/qcd_threshold.py new file mode 100644 index 0000000..56d4497 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/qcd_threshold.py @@ -0,0 +1,67 @@ +"""Leading and next-to-leading heavy-threshold transmission audit.""" +from __future__ import annotations + +from dataclasses import dataclass, asdict +import json +import math +from pathlib import Path + + +@dataclass(frozen=True) +class ThresholdPoint: + alpha_s_at_heavy_threshold: float = 0.0393544 + alpha_s_scale_low: float = 0.032 + alpha_s_scale_high: float = 0.050 + + +def one_loop() -> float: + return (1.0 - 19.0 / 21.0) * (21.0 / 23.0) * (23.0 / 25.0) * (25.0 / 27.0) + + +def nlo_low_energy_theorem(alpha_s: float) -> float: + """Conventional NLO heavy-quark scalar/gluon sensitivity estimate.""" + return one_loop() * (1.0 + 11.0 * alpha_s / (4.0 * math.pi)) + + +def run(point: ThresholdPoint | None = None) -> dict: + p = point or ThresholdPoint() + leading = one_loop() + central = nlo_low_energy_theorem(p.alpha_s_at_heavy_threshold) + low = nlo_low_energy_theorem(p.alpha_s_scale_low) + high = nlo_low_energy_theorem(p.alpha_s_scale_high) + return { + "evidence_class": ["IDENTITY_PIN", "EXTERNAL_BENCHMARK"], + "point": asdict(p), + "one_loop_exact": leading, + "one_loop_exact_fraction": "2/27", + "conventional_NLO_estimate": central, + "relative_NLO_shift": central / leading - 1.0, + "alpha_s_band": [low, high], + "scientific_status": ( + "The 2/27 coefficient is valid only at leading order. The NLO estimate " + "moves it by a few percent; hadronic and multi-threshold uncertainties " + "must be propagated in any phenomenological line." + ), + "novelty_boundary": ( + "Neither 2/27 nor its heavy-quark QCD corrections are new. The project-specific " + "claim is their interpretation as transmission of a scale-lock defect." + ), + } + + +def write_results(output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run() + (output_dir / "qcd_threshold_results.json").write_text( + json.dumps(result, indent=2) + "\n", encoding="utf-8" + ) + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + result = write_results(args.output_dir) + print(json.dumps(result, indent=2)) From ba1f25de941d8935d08b55b5334b77997bd02f51 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:35:10 +1000 Subject: [PATCH 12/23] Add derivation-level RG audit --- .../src/frontier_evidence/rg_audit.py | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/rg_audit.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/rg_audit.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/rg_audit.py new file mode 100644 index 0000000..2922554 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/rg_audit.py @@ -0,0 +1,66 @@ +"""Audit the v1.3 matching-scale cancellation without laundering it as RG proof.""" +from __future__ import annotations + +import json +from pathlib import Path +import sympy as sp + + +def run() -> dict: + x, z = sp.symbols("x z", positive=True) + t = sp.symbols("t", real=True) + log_x = sp.log(x) - t + log_gap = sp.log(x - z) - t + L = sp.log(x / z) + fixed = 2 * L * log_gap - log_x**2 - 2 * sp.polylog(2, z / x) + sp.pi**2 / 3 + imposed = -2 * L * log_x + log_x**2 + completed = sp.simplify(fixed + imposed) + d_fixed = sp.simplify(sp.diff(fixed, t)) + d_imposed = sp.simplify(sp.diff(imposed, t)) + d_completed = sp.simplify(sp.diff(completed, t)) + expected_completed = sp.simplify( + 2 * L * sp.log(1 - z / x) - 2 * sp.polylog(2, z / x) + sp.pi**2 / 3 + ) + algebraic_match = sp.simplify(completed - expected_completed) == 0 + cancellation = d_completed == 0 + + return { + "evidence_class": "IDENTITY_PIN", + "fixed_order_scale_derivative": str(d_fixed), + "added_term_scale_derivative": str(d_imposed), + "sum_scale_derivative": str(d_completed), + "completed_expression": str(completed), + "algebraic_match": bool(algebraic_match), + "cancellation_is_exact": bool(cancellation), + "scientific_verdict": "RETRACTED", + "reason": ( + "The finite addition was selected so its derivative cancels the fixed-order derivative. " + "No operator anomalous-dimension matrix, threshold evolution, or counterterm derivation " + "produces this term in the archived calculation. The natural-scale hard matching value " + "may be retained, but the claimed RG completion is not established." + ), + "required_for_reinstatement": [ + "declare a complete renormalised transient-operator basis", + "derive its anomalous-dimension matrix from UV divergences", + "match at m_R and M with independent finite parts", + "run to the low scale and demonstrate scale cancellation without defining it", + ], + } + + +def write_results(output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run() + (output_dir / "rg_audit_results.json").write_text( + json.dumps(result, indent=2) + "\n", encoding="utf-8" + ) + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + result = write_results(args.output_dir) + print(json.dumps(result, indent=2)) From d34fc68398b2083839ee2689aa985497cbbebc06 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:35:33 +1000 Subject: [PATCH 13/23] Add low-fa compact-object audit --- .../src/frontier_evidence/compact_objects.py | 110 ++++++++++++++++++ 1 file changed, 110 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/compact_objects.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/compact_objects.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/compact_objects.py new file mode 100644 index 0000000..afa049a --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/compact_objects.py @@ -0,0 +1,110 @@ +"""Compact-object audit of the low-f_a chronometric ridge.""" +from __future__ import annotations + +from dataclasses import dataclass, asdict +import json +from pathlib import Path + + +MPL = 2.435e18 +P_QCD = 2.0 / 27.0 +Q_CONVERSION = 0.633135 + + +@dataclass(frozen=True) +class RidgePoint: + f_a_gev: float = 2.435e10 + epsilon: float = 2.70e-13 + d_g: float = 1.0e-6 + eta_heavy_max: float = 612.0 + + +OBJECTS = { + "Earth": 6.95e-10, + "Sun_surface": 2.12e-6, + "white_dwarf_typical": 1.0e-4, + "neutron_star_low_compactness": 0.12, + "neutron_star_typical": 0.20, + "neutron_star_high_compactness": 0.30, +} + + +def scalar_compactness(phi_newton: float, point: RidgePoint) -> float: + return 2.0 * P_QCD * point.epsilon * (MPL / point.f_a_gev) ** 2 * phi_newton + + +def run(point: RidgePoint | None = None) -> dict: + p = point or RidgePoint() + objects = [] + for name, potential in OBJECTS.items(): + q = scalar_compactness(potential, p) + objects.append( + { + "object": name, + "newtonian_potential": potential, + "q": q, + "q_over_conversion_threshold": q / Q_CONVERSION, + "conversion_necessary_condition_met": q > Q_CONVERSION, + } + ) + + y = p.f_a_gev / MPL + epsilon_from_ridge = 27.0 * p.d_g * y + relation_error = abs(epsilon_from_ridge - p.epsilon) / p.epsilon + safe_y_ns = 4.0 * p.d_g * OBJECTS["neutron_star_typical"] / Q_CONVERSION + safe_fa_ns = safe_y_ns * MPL + eta_at_no_conversion_boundary = 6.12 * p.d_g / safe_y_ns + q_eta_ratio_ns = scalar_compactness(OBJECTS["neutron_star_typical"], p) / p.eta_heavy_max + + blocker = any( + row["conversion_necessary_condition_met"] + for row in objects + if row["object"].startswith("neutron_star") + ) + return { + "evidence_class": "PREDICTION", + "point": asdict(p), + "ridge_relation_epsilon_27dg_y_relative_error": relation_error, + "objects": objects, + "no_conversion_fa_min_GeV_for_typical_NS_at_same_dg": safe_fa_ns, + "maximum_heavy_focusing_at_NS_no_conversion_boundary": eta_at_no_conversion_boundary, + "q_over_eta_for_typical_NS": q_eta_ratio_ns, + "single_source_ridge_no_go": { + "statement": ( + "Within the archived N=6 ridge relations, the same d_g/f_a combination " + "controls heavy-threshold focusing and compact-object conversion. Requiring " + "q_NS dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run() + (output_dir / "compact_object_results.json").write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + answer = write_results(args.output_dir) + print(json.dumps(answer, indent=2)) From a47188c0e8879acd726b182c558093fbfbf9d0bc Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:35:55 +1000 Subject: [PATCH 14/23] Add UV-quality calculation and deconstruction gate --- .../src/frontier_evidence/uv_quality.py | 96 +++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/uv_quality.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/uv_quality.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/uv_quality.py new file mode 100644 index 0000000..0f69ff4 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/uv_quality.py @@ -0,0 +1,96 @@ +"""Quantify elementary and deconstructed UV-quality requirements.""" +from __future__ import annotations + +from dataclasses import dataclass, asdict +import json +import math +from pathlib import Path + + +MPL = 2.435e18 + + +@dataclass(frozen=True) +class QualityPoint: + f_a_gev: float = 2.435e10 + heavy_mass_gev: float = 1.002e6 + epsilon: float = 2.70e-13 + n_color: float = 3.0 + + +def protected_amplitude(point: QualityPoint) -> float: + return 3.0 * point.heavy_mass_gev**4 * point.epsilon**6 / (1280.0 * math.pi**2) + + +def elementary_c6_bound(point: QualityPoint) -> float: + return protected_amplitude(point) * MPL**2 / point.f_a_gev**6 + + +def winding_amplitude(point: QualityPoint, links: int, cutoff: float = MPL) -> float: + f_link = math.sqrt(links) * point.f_a_gev + return f_link**4 * (f_link / cutoff) ** (links - 4) + + +def run(point: QualityPoint | None = None) -> dict: + p = point or QualityPoint() + protected = protected_amplitude(p) + c6 = elementary_c6_bound(p) + rows = [] + for links in (12, 18, 20, 24, 30): + amplitude = winding_amplitude(p, links) + rows.append( + { + "links": links, + "winding_amplitude_GeV4": amplitude, + "protected_amplitude_GeV4": protected, + "ratio_to_protected": amplitude / protected, + "quality_pass": amplitude < protected, + } + ) + passing = [row["links"] for row in rows if row["quality_pass"]] + minimum_from_scan = min(passing) if passing else None + return { + "evidence_class": "PREDICTION", + "point": asdict(p), + "protected_Z6_amplitude_GeV4": protected, + "elementary_dimension6_coefficient_upper_bound": c6, + "log10_elementary_c6_bound": math.log10(c6), + "deconstructed_scan": rows, + "minimum_passing_link_count_in_declared_scan": minimum_from_scan, + "recommended_completion": { + "links": 24, + "structure": ( + "local U(1)^24 deconstruction with the chronometric phase as a Wilson line; " + "Z6 acts as a translation by four sites and on the six replica sectors" + ), + "why": ( + "local gauge invariance forces a dangerous phase-dependent operator to wind " + "around the complete moose rather than appear as a dimension-six global-field term" + ), + }, + "status": "CONDITIONAL_UV_QUALITY_PASS" if any( + row["links"] == 24 and row["quality_pass"] for row in rows + ) else "BLOCKED", + "conditions": [ + "the moose locality and gauge symmetry survive the UV completion", + "all mixed gauge and gravitational discrete anomalies cancel", + "no lower-dimensional nonlocal gravitational operator is generated", + "messenger loops preserve the complete replica orbit", + ], + } + + +def write_results(output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run() + (output_dir / "uv_quality_results.json").write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + result = write_results(args.output_dir) + print(json.dumps(result, indent=2)) From cb98ebe3e67b9756b6da0c2512d719f77f9fa8f7 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:36:28 +1000 Subject: [PATCH 15/23] Add independent 3PI automorphism audit --- .../threepi_combinatorics.py | 191 ++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/threepi_combinatorics.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/threepi_combinatorics.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/threepi_combinatorics.py new file mode 100644 index 0000000..30bc21f --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/threepi_combinatorics.py @@ -0,0 +1,191 @@ +"""Independent coloured half-edge automorphism audit of the v1.9 3PI ledger.""" +from __future__ import annotations + +from dataclasses import dataclass +import json +from pathlib import Path +from typing import Iterable + +import networkx as nx +from networkx.algorithms.isomorphism import categorical_node_match + + +@dataclass(frozen=True) +class Vertex: + name: str + color: str + + +@dataclass(frozen=True) +class Propagator: + name: str + color: str + left_vertex: str + left_halfedge: str + right_vertex: str + right_halfedge: str + + +def incidence_graph(vertices: Iterable[Vertex], propagators: Iterable[Propagator]) -> nx.Graph: + graph = nx.Graph() + for vertex in vertices: + graph.add_node(f"V:{vertex.name}", color=f"vertex:{vertex.color}") + for prop in propagators: + pnode = f"P:{prop.name}" + graph.add_node(pnode, color=f"propagator:{prop.color}") + for side, vertex_name, halfedge_color in ( + ("L", prop.left_vertex, prop.left_halfedge), + ("R", prop.right_vertex, prop.right_halfedge), + ): + hnode = f"H:{prop.name}:{side}" + graph.add_node(hnode, color=f"halfedge:{halfedge_color}") + graph.add_edge(f"V:{vertex_name}", hnode) + graph.add_edge(hnode, pnode) + return graph + + +def automorphism_order(graph: nx.Graph) -> int: + matcher = nx.algorithms.isomorphism.GraphMatcher( + graph, graph, node_match=categorical_node_match("color", None) + ) + return sum(1 for _ in matcher.isomorphisms_iter()) + + +def bprop(name: str, left: str, right: str) -> Propagator: + return Propagator(name, "B", left, "B", right, "B") + + +def fprop(name: str, source: str, target: str) -> Propagator: + return Propagator(name, "F", source, "Fout", target, "Fin") + + +def topologies() -> dict[str, tuple[list[Vertex], list[Propagator]]]: + return { + "G20_B4_BARE": ( + [Vertex("a", "V4_bare")], + [bprop("e1", "a", "a"), bprop("e2", "a", "a")], + ), + "G20_B33_MIX": ( + [Vertex("a", "V3_dressed"), Vertex("b", "V3_bare")], + [bprop(f"e{i}", "a", "b") for i in range(3)], + ), + "G20_F3_MIX": ( + [Vertex("a", "U_dressed"), Vertex("b", "U_bare")], + [bprop("boson", "a", "b"), fprop("f1", "a", "b"), fprop("f2", "b", "a")], + ), + "G30_B44_MIX": ( + [Vertex("a", "V4_dressed"), Vertex("b", "V4_bare")], + [bprop(f"e{i}", "a", "b") for i in range(4)], + ), + "G30_B334": ( + [Vertex("a", "V3_dressed"), Vertex("b", "V3_dressed"), Vertex("c", "V4_bare")], + [ + bprop("ab", "a", "b"), + bprop("ac1", "a", "c"), + bprop("ac2", "a", "c"), + bprop("bc1", "b", "c"), + bprop("bc2", "b", "c"), + ], + ), + "G2I_B33": ( + [Vertex("a", "V3_dressed"), Vertex("b", "V3_dressed")], + [bprop(f"e{i}", "a", "b") for i in range(3)], + ), + "G2I_F3": ( + [Vertex("a", "U_dressed"), Vertex("b", "U_dressed")], + [bprop("boson", "a", "b"), fprop("f1", "a", "b"), fprop("f2", "b", "a")], + ), + "G3I_B44": ( + [Vertex("a", "V4_dressed"), Vertex("b", "V4_dressed")], + [bprop(f"e{i}", "a", "b") for i in range(4)], + ), + "G3I_B3333": ( + [Vertex(name, "V3_dressed") for name in "abcd"], + [bprop(x + y, x, y) for index, x in enumerate("abcd") for y in "abcd"[index + 1 :]], + ), + "G3I_FFFB": ( + [Vertex("x", "V3_dressed")] + [Vertex(name, "U_dressed") for name in "abc"], + [ + fprop("fab", "a", "b"), + fprop("fbc", "b", "c"), + fprop("fca", "c", "a"), + bprop("ba", "x", "a"), + bprop("bb", "x", "b"), + bprop("bc", "x", "c"), + ], + ), + "G3I_FFFF": ( + [Vertex(name, "U_dressed") for name in "abcd"], + [ + fprop("fab", "a", "b"), + fprop("fbc", "b", "c"), + fprop("fcd", "c", "d"), + fprop("fda", "d", "a"), + bprop("ac", "a", "c"), + bprop("bd", "b", "d"), + ], + ), + } + + +LEDGER_MAGNITUDES = { + "G20_B4_BARE": 1 / 8, + "G20_B33_MIX": 1 / 6, + "G20_F3_MIX": 1.0, + "G30_B44_MIX": 1 / 24, + "G30_B334": 1 / 8, + "G2I_B33": 1 / 12, + "G2I_F3": 1 / 2, + "G3I_B44": 1 / 48, + "G3I_B3333": 1 / 24, + "G3I_FFFB": 1 / 3, + "G3I_FFFF": 1 / 4, +} + + +def run() -> dict: + rows = [] + for identifier, (vertices, propagators) in topologies().items(): + order = automorphism_order(incidence_graph(vertices, propagators)) + predicted = 1.0 / order + ledger = LEDGER_MAGNITUDES[identifier] + rows.append( + { + "id": identifier, + "automorphism_order": order, + "predicted_coefficient_magnitude": predicted, + "ledger_coefficient_magnitude": ledger, + "relative_difference": abs(predicted - ledger) / ledger, + "magnitude_match": abs(predicted - ledger) < 1.0e-15, + } + ) + all_match = all(row["magnitude_match"] for row in rows) + return { + "evidence_class": "INDEPENDENT_RECOMPUTATION", + "method": "coloured half-edge incidence graph automorphisms", + "rows": rows, + "all_magnitudes_match": all_match, + "phase_and_sign_status": ( + "Powers of i and the closed-Grassmann-loop sign are not fixed by automorphism counting; " + "they remain source-convention checks against the nPI functional." + ), + } + + +def write_results(output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run() + (output_dir / "threepi_combinatorics_results.json").write_text( + json.dumps(result, indent=2) + "\n", encoding="utf-8" + ) + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + answer = write_results(args.output_dir) + print(json.dumps(answer, indent=2)) + raise SystemExit(0 if answer["all_magnitudes_match"] else 2) From c63c51c20ecb885872cdc1092cd24124bcaccf21 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:37:32 +1000 Subject: [PATCH 16/23] Add fallible scalar two-time benchmark --- .../src/frontier_evidence/scalar_two_time.py | 317 ++++++++++++++++++ 1 file changed, 317 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/scalar_two_time.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/scalar_two_time.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/scalar_two_time.py new file mode 100644 index 0000000..91f46e7 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/scalar_two_time.py @@ -0,0 +1,317 @@ +"""Fallible scalar unequal-time benchmark. + +The benchmark is a Caldeira-Leggett oscillator coupled to a discretised Drude +bath. It is deliberately solved in two independent ways: + +1. diagonalisation of the complete Hamiltonian; +2. a causal generalized-Langevin memory equation. + +The exact finite-bath solution supplies unequal-time statistical and spectral +correlators. The memory solver is evolved numerically and subjected to +resolution and memory-window scans. No stored answer is used. +""" +from __future__ import annotations + +from dataclasses import asdict, dataclass +import json +import math +from pathlib import Path + +import numpy as np +from scipy.integrate import solve_ivp + + +@dataclass(frozen=True) +class ScalarBenchmarkConfig: + omega0: float = 1.0 + gamma: float = 0.035 + cutoff: float = 3.0 + beta: float = 1.2 + bath_modes: int = 260 + bath_omega_max: float = 24.0 + t_max: float = 80.0 + exact_dt: float = 0.01 + + +def drude_spectral_density(omega: np.ndarray, gamma: float, cutoff: float) -> np.ndarray: + return 2.0 * gamma * cutoff * cutoff * omega / (omega * omega + cutoff * cutoff) + + +def build_bath(config: ScalarBenchmarkConfig) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + n = config.bath_modes + domega = config.bath_omega_max / n + omega = (np.arange(n, dtype=float) + 0.5) * domega + j = drude_spectral_density(omega, config.gamma, config.cutoff) + coupling = np.sqrt(np.maximum(2.0 * j * omega * domega / math.pi, 0.0)) + matrix = np.zeros((n + 1, n + 1), dtype=float) + counterterm = float(np.sum(coupling * coupling / (omega * omega))) + matrix[0, 0] = config.omega0**2 + counterterm + matrix[1:, 1:] = np.diag(omega * omega) + matrix[0, 1:] = -coupling + matrix[1:, 0] = -coupling + eig = np.linalg.eigvalsh(matrix) + if float(eig[0]) <= 0.0: + raise RuntimeError(f"Non-positive bath force matrix: min eigenvalue={eig[0]}") + return omega, coupling, matrix + + +def exact_correlators(config: ScalarBenchmarkConfig) -> dict[str, np.ndarray | float]: + _, _, force = build_bath(config) + eigenvalues, vectors = np.linalg.eigh(force) + frequencies = np.sqrt(eigenvalues) + weights = vectors[0, :] ** 2 + times = np.arange(0.0, config.t_max + 0.5 * config.exact_dt, config.exact_dt) + phases = np.outer(frequencies, times) + rho = np.sum((weights / frequencies)[:, None] * np.sin(phases), axis=0) + coth = 1.0 / np.tanh(0.5 * config.beta * frequencies) + statistical = np.sum( + (weights * coth / (2.0 * frequencies))[:, None] * np.cos(phases), axis=0 + ) + response = rho.copy() + + rng = np.random.default_rng(20260826) + q = vectors @ rng.normal(scale=0.1, size=len(frequencies)) + p = vectors @ rng.normal(scale=0.1, size=len(frequencies)) + dt = 0.002 + steps = int(30.0 / dt) + acceleration = -force @ q + e0 = 0.5 * float(p @ p + q @ force @ q) + max_drift = 0.0 + for _ in range(steps): + q = q + dt * p + 0.5 * dt * dt * acceleration + a_new = -force @ q + p = p + 0.5 * dt * (acceleration + a_new) + acceleration = a_new + energy = 0.5 * float(p @ p + q @ force @ q) + max_drift = max(max_drift, abs(energy - e0) / max(abs(e0), 1.0e-30)) + + return { + "time": times, + "rho": rho, + "F": statistical, + "response": response, + "frequencies": frequencies, + "weights": weights, + "energy_relative_drift": max_drift, + "commutator_derivative": float(np.sum(weights)), + "minimum_mode_frequency": float(frequencies[0]), + } + + +def embedded_memory_reference(config: ScalarBenchmarkConfig, times: np.ndarray) -> np.ndarray: + def rhs(_: float, y: np.ndarray) -> tuple[float, float, float]: + q, velocity, memory = y + return ( + velocity, + -config.omega0**2 * q - 2.0 * config.gamma * config.cutoff * memory, + velocity - config.cutoff * memory, + ) + + sol = solve_ivp( + rhs, + (float(times[0]), float(times[-1])), + (0.0, 1.0, 0.0), + t_eval=times, + method="DOP853", + rtol=2.0e-12, + atol=2.0e-14, + ) + if not sol.success: + raise RuntimeError(sol.message) + return sol.y[0] + + +def rk4_embedded(config: ScalarBenchmarkConfig, dt: float, t_max: float) -> tuple[np.ndarray, np.ndarray]: + steps = int(round(t_max / dt)) + times = np.arange(steps + 1, dtype=float) * dt + y = np.array([0.0, 1.0, 0.0], dtype=float) + q = np.empty(steps + 1, dtype=float) + q[0] = y[0] + + def f(state: np.ndarray) -> np.ndarray: + pos, vel, mem = state + return np.array( + [ + vel, + -config.omega0**2 * pos - 2.0 * config.gamma * config.cutoff * mem, + vel - config.cutoff * mem, + ], + dtype=float, + ) + + for index in range(steps): + k1 = f(y) + k2 = f(y + 0.5 * dt * k1) + k3 = f(y + 0.5 * dt * k2) + k4 = f(y + dt * k3) + y = y + dt * (k1 + 2 * k2 + 2 * k3 + k4) / 6.0 + q[index + 1] = y[0] + return times, q + + +def truncated_memory_response( + config: ScalarBenchmarkConfig, dt: float, t_max: float, window: float +) -> tuple[np.ndarray, np.ndarray]: + steps = int(round(t_max / dt)) + times = np.arange(steps + 1, dtype=float) * dt + q = np.zeros(steps + 1, dtype=float) + v = np.zeros(steps + 1, dtype=float) + q[0], v[0] = 0.0, 1.0 + memory = 0.0 + decay = math.exp(-config.cutoff * dt) + horizon = max(1, int(round(window / dt))) + coupling = 2.0 * config.gamma * config.cutoff + + acceleration = -config.omega0**2 * q[0] - coupling * memory + for n in range(steps): + q[n + 1] = q[n] + dt * v[n] + 0.5 * dt * dt * acceleration + v_predict = v[n] + dt * acceleration + source = 0.5 * dt * (v[n] + v_predict) + memory_new = decay * memory + source + expired_index = n - horizon + if expired_index >= 0: + memory_new -= 0.5 * dt * (v[expired_index] + v[expired_index + 1]) * math.exp( + -config.cutoff * window + ) + acceleration_new = -config.omega0**2 * q[n + 1] - coupling * memory_new + v[n + 1] = v[n] + 0.5 * dt * (acceleration + acceleration_new) + memory = memory_new + acceleration = acceleration_new + return times, q + + +def _relative_l2(reference: np.ndarray, candidate: np.ndarray) -> float: + return float(np.linalg.norm(candidate - reference) / max(np.linalg.norm(reference), 1.0e-30)) + + +def fdt_fft_residual( + times: np.ndarray, rho: np.ndarray, statistical: np.ndarray, beta: float +) -> dict[str, float]: + dt = float(times[1] - times[0]) + rho_full = np.concatenate((-rho[:0:-1], rho)) + f_full = np.concatenate((statistical[:0:-1], statistical)) + window = np.hanning(len(rho_full)) + rho_w = np.fft.fftshift(np.fft.fft(np.fft.ifftshift(rho_full * window))) * dt + f_w = np.fft.fftshift(np.fft.fft(np.fft.ifftshift(f_full * window))) * dt + omega = np.fft.fftshift(np.fft.fftfreq(len(rho_full), d=dt)) * 2.0 * math.pi + spectral = np.real(-1j * rho_w) + symmetric = np.real(f_w) + target = np.zeros_like(symmetric) + mask_nonzero = np.abs(omega) > 0.12 + target[mask_nonzero] = 0.5 / np.tanh(0.5 * beta * omega[mask_nonzero]) * spectral[mask_nonzero] + support = np.abs(target) > 0.015 * float(np.max(np.abs(target))) + mask = support & mask_nonzero + residuals = np.abs(symmetric[mask] - target[mask]) / np.maximum( + np.abs(symmetric[mask]) + np.abs(target[mask]), 1.0e-12 + ) + if residuals.size == 0: + raise RuntimeError("No supported bins in FDT comparison") + return { + "median_relative_residual": float(np.median(residuals)), + "p95_relative_residual": float(np.quantile(residuals, 0.95)), + "max_relative_residual": float(np.max(residuals)), + "compared_bins": int(residuals.size), + } + + +def run(config: ScalarBenchmarkConfig | None = None) -> tuple[dict, dict[str, np.ndarray]]: + cfg = config or ScalarBenchmarkConfig() + exact = exact_correlators(cfg) + times = np.asarray(exact["time"]) + continuum = embedded_memory_reference(cfg, times) + finite_bath_vs_continuum = _relative_l2(continuum, np.asarray(exact["response"])) + + dt_values = [0.04, 0.02, 0.01, 0.005] + dt_errors: dict[str, float] = {} + for dt in dt_values: + t, q = rk4_embedded(cfg, dt, 40.0) + ref = embedded_memory_reference(cfg, t) + dt_errors[f"{dt:.3f}"] = _relative_l2(ref, q) + + e20, e10, e05 = dt_errors["0.020"], dt_errors["0.010"], dt_errors["0.005"] + order_1 = math.log(e20 / e10, 2.0) + order_2 = math.log(e10 / e05, 2.0) + + windows = [1.5, 3.0, 6.0, 12.0, 24.0] + memory_changes: dict[str, float] = {} + dt_window = 0.005 + t_ref = np.arange(int(round(40.0 / dt_window)) + 1) * dt_window + ref_window = embedded_memory_reference(cfg, t_ref) + memory_arrays: dict[str, np.ndarray] = {} + for window_value in windows: + _, q = truncated_memory_response(cfg, dt_window, 40.0, window_value) + memory_changes[f"{window_value:g}"] = _relative_l2(ref_window, q) + memory_arrays[f"memory_window_{window_value:g}"] = q + + fdt = fdt_fft_residual(times, np.asarray(exact["rho"]), np.asarray(exact["F"]), cfg.beta) + + fit_mask = (times >= 12.0) & (times <= 45.0) + segment = continuum[fit_mask] + spectrum = np.fft.fft(segment) + selector = np.zeros(len(segment), dtype=float) + selector[0] = 1.0 + if len(segment) % 2 == 0: + selector[1 : len(segment) // 2] = 2.0 + selector[len(segment) // 2] = 1.0 + else: + selector[1 : (len(segment) + 1) // 2] = 2.0 + envelope = np.maximum(np.abs(np.fft.ifft(spectrum * selector)), 1.0e-12) + slope = np.polyfit(times[fit_mask], np.log(envelope), 1)[0] + fitted_damping = max(float(-slope), 0.0) + + gates = { + "force_matrix_positive": bool(exact["minimum_mode_frequency"] > 0.0), + "energy_relative_drift_lt_2e-5": bool(exact["energy_relative_drift"] < 2.0e-5), + "commutator_error_lt_3e-3": bool(abs(exact["commutator_derivative"] - 1.0) < 3.0e-3), + "timestep_convergence_order_gt_2_8": bool(min(order_1, order_2) > 2.8), + "memory_12_change_lt_2e-3": bool(memory_changes["12"] < 2.0e-3), + "fdt_p95_lt_0_08": bool(fdt["p95_relative_residual"] < 0.08), + "finite_bath_continuum_l2_lt_0_2": bool(finite_bath_vs_continuum < 0.2), + "damping_within_30_percent": bool(abs(fitted_damping - cfg.gamma) / cfg.gamma < 0.30), + } + summary = { + "evidence_class": ["INDEPENDENT_RECOMPUTATION", "CONVERGENCE", "EXTERNAL_BENCHMARK"], + "config": asdict(cfg), + "finite_bath_vs_continuum_relative_l2": finite_bath_vs_continuum, + "energy_relative_drift": float(exact["energy_relative_drift"]), + "equal_time_commutator_derivative": float(exact["commutator_derivative"]), + "timestep_relative_l2_errors": dt_errors, + "observed_orders": [order_1, order_2], + "memory_window_relative_l2_changes": memory_changes, + "fdt_fft": fdt, + "fitted_damping": fitted_damping, + "target_weak_damping": cfg.gamma, + "gates": gates, + "all_gates_pass": bool(all(gates.values())), + "scope": "Exact finite-bath scalar open-system KB benchmark; not a non-Abelian 3PI calculation.", + } + arrays = { + "time": times, + "rho_exact_bath": np.asarray(exact["rho"]), + "F_exact_bath": np.asarray(exact["F"]), + "response_exact_bath": np.asarray(exact["response"]), + "response_continuum_memory": continuum, + "memory_time": t_ref, + **memory_arrays, + } + return summary, arrays + + +def write_results(output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + summary, arrays = run() + (output_dir / "scalar_two_time_results.json").write_text( + json.dumps(summary, indent=2) + "\n", encoding="utf-8" + ) + np.savez_compressed(output_dir / "scalar_two_time_arrays.npz", **arrays) + return summary + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, default=Path("results")) + arguments = parser.parse_args() + result = write_results(arguments.output_dir) + print(json.dumps(result, indent=2)) + raise SystemExit(0 if result["all_gates_pass"] else 2) From 82ca0bee68ee2c8c0d13b30f952d23d04b572e2f Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:38:16 +1000 Subject: [PATCH 17/23] Add prompt-daughter dark-radiation repair --- .../src/frontier_evidence/nu0_fate.py | 200 ++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/nu0_fate.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/nu0_fate.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/nu0_fate.py new file mode 100644 index 0000000..0891876 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/nu0_fate.py @@ -0,0 +1,200 @@ +"""Prompt-daughter fate in the state-selected fermionic cascade. + +The archived cascade assumes that the massless daughter from N0 -> R0 + nu0 +thermalises in the visible sector. This module treats the sterile branch as a +separate radiation component, quantifies the resulting dark radiation, and +implements an exact-replica gauge-charged repair. +""" +from __future__ import annotations + +from dataclasses import dataclass, asdict +import json +import math +from pathlib import Path + +import numpy as np +from scipy.integrate import solve_ivp + + +MPL_REDUCED_GEV = 2.435e18 + + +@dataclass(frozen=True) +class CascadePoint: + m_n: float = 3.0e9 + m_r: float = 1.0e9 + gamma_n: float = 0.1 + gamma_r: float = 1.4135e-2 + b5: float = 0.005274370843322566 + g2: float = 0.57 + gstar_high: float = 117.25 + gstar_neutrino_decoupling: float = 10.75 + + +def two_body_fractions(point: CascadePoint) -> tuple[float, float]: + ratio2 = (point.m_r / point.m_n) ** 2 + daughter = 0.5 * (1.0 - ratio2) + reheaton = 0.5 * (1.0 + ratio2) + return daughter, reheaton + + +def delta_neff_from_decoupled_fraction( + ratio_to_visible_at_high_t: float, + gstar_high: float, + gstar_at_neutrino_decoupling: float = 10.75, +) -> float: + dilution = (gstar_at_neutrino_decoupling / gstar_high) ** (1.0 / 3.0) + ratio_at_decoupling = ratio_to_visible_at_high_t * dilution + one_neutrino_fraction = (7.0 / 4.0) / gstar_at_neutrino_decoupling + return ratio_at_decoupling / one_neutrino_fraction + + +def required_yukawa(point: CascadePoint) -> float: + phase = (1.0 - (point.m_r / point.m_n) ** 2) ** 2 + return math.sqrt(point.gamma_n * 32.0 * math.pi / (point.m_n * phase)) + + +def thermalisation_metrics(point: CascadePoint) -> dict[str, float]: + alpha2 = point.g2**2 / (4.0 * math.pi) + h_prefactor = math.sqrt(math.pi**2 * point.gstar_high / 90.0) + t_decay = math.sqrt(point.gamma_n * MPL_REDUCED_GEV / h_prefactor) + h_decay = h_prefactor * t_decay**2 / MPL_REDUCED_GEV + gamma_scatter = alpha2**2 * t_decay + return { + "alpha2": alpha2, + "temperature_at_N_decay_GeV": t_decay, + "H_at_N_decay_GeV": h_decay, + "conservative_weak_scattering_rate_GeV": gamma_scatter, + "scattering_over_H": gamma_scatter / h_decay, + "scattering_over_Gamma_N": gamma_scatter / point.gamma_n, + } + + +def cascade_ode(point: CascadePoint, charged_daughter: bool) -> dict[str, float]: + f_l, f_r = two_body_fractions(point) + b0 = 1.0 - point.b5 + gn = point.gamma_n / point.gamma_r + thermal = thermalisation_metrics(point) + gth = thermal["conservative_weak_scattering_rate_GeV"] / point.gamma_r + if not charged_daughter: + gth = 0.0 + + h0 = 15.0 + rho_scale = 3.0 * (MPL_REDUCED_GEV * point.gamma_r) ** 2 + y0 = np.array([h0 * h0, 0.0, 0.0, 1.0e-30, 1.0e-30], dtype=float) + + def rhs(_: float, y: np.ndarray) -> np.ndarray: + rn, rr, rd, r0, r5 = np.maximum(y, 0.0) + h = math.sqrt(max(rn + rr + rd + r0 + r5, 0.0)) + return np.array( + [ + -(3.0 * h + gn) * rn, + -3.0 * h * rr + f_r * gn * rn - rr, + -4.0 * h * rd + f_l * gn * rn - gth * rd, + -4.0 * h * r0 + gth * rd + b0 * rr, + -4.0 * h * r5 + point.b5 * rr, + ], + dtype=float, + ) + + sol = solve_ivp( + rhs, + (0.0, 500.0), + y0, + method="BDF", + rtol=2.0e-10, + atol=1.0e-16, + ) + if not sol.success: + raise RuntimeError(sol.message) + rn, rr, rd, r0, r5 = np.maximum(sol.y[:, -1], 0.0) + free_ratio = rd / max(r0, 1.0e-300) + hidden_ratio = r5 / max(r0, 1.0e-300) + delta_prompt = delta_neff_from_decoupled_fraction( + free_ratio, point.gstar_high, point.gstar_neutrino_decoupling + ) + t_ratio = hidden_ratio ** 0.25 + delta_hidden_copy = 7.403 * t_ratio**4 + return { + "N_residual": rn, + "R_residual": rr, + "prompt_daughter_to_visible": free_ratio, + "sector5_to_visible": hidden_ratio, + "T5_over_T0": t_ratio, + "DeltaNeff_prompt": delta_prompt, + "DeltaNeff_hidden_copy": delta_hidden_copy, + "DeltaNeff_total": delta_prompt + delta_hidden_copy, + "dimensionless_final_energy": float(rn + rr + rd + r0 + r5), + "rho_scale_GeV4": rho_scale, + "charged_daughter": charged_daughter, + } + + +def run(point: CascadePoint | None = None) -> dict: + p = point or CascadePoint() + f_l, f_r = two_body_fractions(p) + b0 = 1.0 - p.b5 + visible_if_sterile = f_r * b0 + sterile_ratio = f_l / visible_if_sterile + analytic_delta = delta_neff_from_decoupled_fraction(sterile_ratio, p.gstar_high) + + yukawa = required_yukawa(p) + thermal = thermalisation_metrics(p) + loop_mass_sq = yukawa**2 * p.m_n**2 / (16.0 * math.pi**2) + sterile = cascade_ode(p, charged_daughter=False) + repaired = cascade_ode(p, charged_daughter=True) + + gates = { + "sterile_branch_excluded_DeltaNeff_gt_0_1": sterile["DeltaNeff_total"] > 0.1, + "charged_daughter_thermalises_before_Hubble": thermal["scattering_over_H"] > 1.0e4, + "charged_daughter_residual_lt_1e_8": repaired["prompt_daughter_to_visible"] < 1.0e-8, + "repaired_total_DeltaNeff_lt_0_107": repaired["DeltaNeff_total"] < 0.107, + "portal_loop_correction_small": math.sqrt(loop_mass_sq) / p.m_r < 1.0e-3, + } + + return { + "evidence_class": ["INDEPENDENT_RECOMPUTATION", "PREDICTION"], + "point": asdict(p), + "two_body_energy_fractions": {"prompt_daughter": f_l, "R": f_r}, + "instantaneous_sterile_ratio_to_visible": sterile_ratio, + "instantaneous_sterile_DeltaNeff": analytic_delta, + "sterile_cascade": sterile, + "repaired_cascade": repaired, + "repair": { + "lagrangian": "-y_R sum_k R_k bar(N_k) L_k + h.c.", + "representation": ( + "N_k is a complete vectorlike SU(2)_k doublet orbit with Y=-1/2; " + "L_k is the ordinary lepton doublet in replica k." + ), + "exact_replica_symmetry": True, + "required_y_R": yukawa, + "thermalisation": thermal, + "one_loop_R_mass_correction_GeV": math.sqrt(loop_mass_sq), + "linear_isocurvature": ( + "zero for fixed branching and a heavy mixing sector; no light modulus controls y_R" + ), + }, + "gates": gates, + "all_repair_gates_pass": bool(all(gates.values())), + "scope": ( + "Energy-flow and rate closure for the daughter. A complete finite-temperature " + "spectral calculation of the new electroweak parent is not included." + ), + } + + +def write_results(output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run() + (output_dir / "nu0_fate_results.json").write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + result = write_results(args.output_dir) + print(json.dumps(result, indent=2)) + raise SystemExit(0 if result["all_repair_gates_pass"] else 2) From 1b84e2f43f6cb3a436d6e4d37e0ded06d8735553 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:38:37 +1000 Subject: [PATCH 18/23] Add clean-checkout portability audit --- .../src/frontier_evidence/portability.py | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/portability.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/portability.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/portability.py new file mode 100644 index 0000000..808828b --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/portability.py @@ -0,0 +1,73 @@ +"""Portability and reproducibility audit.""" +from __future__ import annotations + +import json +from pathlib import Path + + +TEXT_SUFFIXES = { + ".py", ".md", ".tex", ".txt", ".yaml", ".yml", ".json", ".csv", ".toml", ".sh" +} + + +def scan_tree(root: Path) -> list[dict[str, object]]: + matches: list[dict[str, object]] = [] + for path in root.rglob("*"): + if not path.is_file() or path.suffix.lower() not in TEXT_SUFFIXES: + continue + try: + text = path.read_text(encoding="utf-8") + except UnicodeDecodeError: + continue + for line_number, line in enumerate(text.splitlines(), 1): + if ("/mnt" + "/data") in line: + matches.append( + { + "path": str(path.relative_to(root)), + "line": line_number, + "text": line.strip()[:240], + } + ) + return matches + + +def run(repo_root: Path, active_root: Path) -> dict: + repo_root = repo_root.resolve() + active_root = active_root.resolve() + active_matches = scan_tree(active_root) + legacy_root = repo_root / "chronometric-emergence" / "original-info" + legacy_matches = scan_tree(legacy_root) if legacy_root.exists() else [] + dependency_files = [active_root / "pyproject.toml", active_root / "Makefile"] + return { + "evidence_class": "INDEPENDENT_RECOMPUTATION", + "active_package_absolute_path_matches": active_matches, + "active_package_match_count": len(active_matches), + "legacy_archive_absolute_path_match_count": len(legacy_matches), + "legacy_examples": legacy_matches[:20], + "dependency_declarations_exist": all(path.exists() for path in dependency_files), + "scientific_policy": ( + "Legacy artifacts remain immutable historical records and may contain sandbox paths. " + "The active evidence package must be path-relative and runnable from a clean checkout." + ), + "all_active_portability_gates_pass": len(active_matches) == 0 + and all(path.exists() for path in dependency_files), + } + + +def write_results(repo_root: Path, active_root: Path, output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run(repo_root, active_root) + (output_dir / "portability_results.json").write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--repo-root", type=Path, required=True) + parser.add_argument("--active-root", type=Path, required=True) + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + result = write_results(args.repo_root, args.active_root, args.output_dir) + print(json.dumps(result, indent=2)) + raise SystemExit(0 if result["all_active_portability_gates_pass"] else 2) From e73ee5e8fa75aab3b69647fd1fb7a52bd0a87234 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:39:26 +1000 Subject: [PATCH 19/23] Add off-shell kernel discrepancy and coverage audit --- .../frontier_evidence/kernel_uncertainty.py | 226 ++++++++++++++++++ 1 file changed, 226 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/kernel_uncertainty.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/kernel_uncertainty.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/kernel_uncertainty.py new file mode 100644 index 0000000..9490118 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/kernel_uncertainty.py @@ -0,0 +1,226 @@ +"""Inter-version off-shell kernel discrepancy and table-coverage audit.""" +from __future__ import annotations + +import json +from pathlib import Path +from typing import Mapping + +import numpy as np +from scipy.interpolate import RegularGridInterpolator +import yaml + + +def _monotonic_1d(npz: Mapping[str, np.ndarray]) -> list[tuple[str, np.ndarray]]: + candidates = [] + for key in npz.keys(): + value = np.asarray(npz[key]) + if value.ndim == 1 and len(value) >= 8 and np.issubdtype(value.dtype, np.number): + diff = np.diff(value.astype(float)) + if np.all(diff > 0.0): + candidates.append((key, value.astype(float))) + return candidates + + +def _select_axis(candidates: list[tuple[str, np.ndarray]], axis: str) -> tuple[str, np.ndarray]: + if axis == "omega": + scored = [ + (10 * ("omega" in key.lower()) + 3 * (arr[0] < 0 < arr[-1]) + np.log10(len(arr)), key, arr) + for key, arr in candidates + if arr[0] < 0.0 < arr[-1] + ] + else: + scored = [ + ( + 10 * ("k_" in key.lower() or key.lower().startswith("k") or "momentum" in key.lower()) + + 3 * (arr[0] >= 0.0) + + np.log10(len(arr)), + key, + arr, + ) + for key, arr in candidates + if arr[0] >= 0.0 and arr[-1] <= 100.0 + ] + if not scored: + raise KeyError(f"No {axis} axis candidate") + _, key, arr = max(scored, key=lambda item: item[0]) + return key, arr + + +def _select_kernel(npz: Mapping[str, np.ndarray], k: np.ndarray, omega: np.ndarray) -> tuple[str, np.ndarray]: + candidates = [] + for key in npz.keys(): + value = np.asarray(npz[key]) + if not np.issubdtype(value.dtype, np.number) or value.ndim != 2: + continue + if value.shape == (len(k), len(omega)): + array = value.astype(float) + elif value.shape == (len(omega), len(k)): + array = value.T.astype(float) + else: + continue + lower = key.lower() + score = ( + 12 * ("impi" in lower) + + 7 * ("matched" in lower or "match" in lower) + + 5 * ("total" in lower) + - 5 * ("low" in lower or "high" in lower or "noise" in lower or "repi" in lower) + ) + candidates.append((score, key, array)) + if not candidates: + raise KeyError("No two-dimensional ImPi/kernel candidate matching selected axes") + _, key, array = max(candidates, key=lambda item: item[0]) + return key, array + + +def load_kernel(path: Path, preferred: dict[str, str] | None = None) -> dict: + with np.load(path, allow_pickle=False) as data: + inventory = {key: list(np.asarray(data[key]).shape) for key in data.files} + if preferred and all(key in data.files for key in preferred.values()): + k_key, w_key, pi_key = preferred["k"], preferred["omega"], preferred["kernel"] + k = np.asarray(data[k_key], dtype=float) + omega = np.asarray(data[w_key], dtype=float) + kernel = np.asarray(data[pi_key], dtype=float) + if kernel.shape == (len(omega), len(k)): + kernel = kernel.T + else: + monotonic = _monotonic_1d(data) + k_key, k = _select_axis(monotonic, "k") + w_key, omega = _select_axis(monotonic, "omega") + pi_key, kernel = _select_kernel(data, k, omega) + return { + "path": str(path), + "k_key": k_key, + "omega_key": w_key, + "kernel_key": pi_key, + "k": k, + "omega": omega, + "kernel": kernel, + "inventory": inventory, + } + + +def run(repo_root: Path) -> dict: + base = repo_root.resolve() / "chronometric-emergence" / "original-info" + v17_path = base / "gauge_covariant_correlator_package_v1_7" / "gauge_covariant_correlator_arrays_v1_7.npz" + v18_path = base / "prehpc_closure_research_package_v1_8" / "prehpc_closure_arrays_v1_8.npz" + config_path = base / "chronometric_3pi_prehpc_v1_9" / "config" / "hpc_solver_spec_portable_v1_9.yaml" + v17 = load_kernel( + v17_path, + preferred={ + "k": "bfm_k_over_T", + "omega": "bfm_omega_over_T", + "kernel": "bfm_ImPi_total_over_T2", + }, + ) + v18 = load_kernel(v18_path) + + k_min = max(float(v17["k"][0]), float(v18["k"][0])) + k_max = min(float(v17["k"][-1]), float(v18["k"][-1])) + w_min = max(float(v17["omega"][0]), float(v18["omega"][0])) + w_max = min(float(v17["omega"][-1]), float(v18["omega"][-1])) + k_common = np.geomspace(max(k_min, 1.0e-4), k_max, 50) + omega_common = np.linspace(w_min, w_max, 801) + mesh_k, mesh_w = np.meshgrid(k_common, omega_common, indexing="ij") + points = np.column_stack((mesh_k.ravel(), mesh_w.ravel())) + + def interpolate(bundle: dict) -> np.ndarray: + interp = RegularGridInterpolator( + (bundle["k"], bundle["omega"]), bundle["kernel"], bounds_error=True + ) + return interp(points).reshape(mesh_k.shape) + + a = interpolate(v17) + b = interpolate(v18) + scale = np.maximum(np.maximum(np.abs(a), np.abs(b)), 1.0e-14) + significant = scale > 1.0e-5 * float(np.max(scale)) + relative = np.abs(a - b) / scale + selected = relative[significant] + + mass = 0.43820657 + shell = np.sqrt(k_common[:, None] ** 2 + mass**2) + distance = np.minimum(np.abs(mesh_w - shell), np.abs(mesh_w + shell)) + near = significant & (distance < 0.15) + far = significant & (distance > 1.0) + + config = yaml.safe_load(config_path.read_text(encoding="utf-8")) + requested_kmax = float(config["pilot_grid"]["radial_momentum"]["maximum_over_T"]) + table_kmax = float(v18["k"][-1]) + requested_dt = float(config["pilot_grid"]["time"]["dt_times_T"]) + requested_window_steps = int(config["pilot_grid"]["time"]["memory_window_steps"]) + requested_window = requested_dt * requested_window_steps + + repaired_config = { + "radial_momentum_maximum_over_T": table_kmax, + "table_extrapolation": "forbidden", + "memory_window_scan_Tinv": [6.0, 12.0, 24.0], + "promotion_rule": "all declared observables change by <0.5% between the two largest windows", + "pilot_authorization": False, + "reason": "no dynamical 3PI evolution engine exists", + } + + def stats(mask: np.ndarray) -> dict[str, float | int | None]: + values = relative[mask] + if values.size == 0: + return {"count": 0, "median": None, "p95": None, "max": None} + return { + "count": int(values.size), + "median": float(np.median(values)), + "p95": float(np.quantile(values, 0.95)), + "max": float(np.max(values)), + } + + return { + "evidence_class": ["INDEPENDENT_RECOMPUTATION", "MODEL_DISCREPANCY"], + "v1_7_selection": { + "k_key": v17["k_key"], + "omega_key": v17["omega_key"], + "kernel_key": v17["kernel_key"], + "shape": list(v17["kernel"].shape), + }, + "v1_8_selection": { + "k_key": v18["k_key"], + "omega_key": v18["omega_key"], + "kernel_key": v18["kernel_key"], + "shape": list(v18["kernel"].shape), + }, + "common_domain": {"k_over_T": [k_min, k_max], "omega_over_T": [w_min, w_max]}, + "relative_model_discrepancy": { + "significant_all": stats(significant), + "near_shell": stats(near), + "far_off_shell": stats(far), + }, + "interpretation": ( + "The v1.7 and v1.8 kernels share controlled on-shell anchors but use different " + "off-shell constructions. Their spread is an ansatz/model discrepancy, not a " + "statistical or perturbative uncertainty estimate." + ), + "coverage_audit": { + "v1_8_table_kmax_over_T": table_kmax, + "v1_9_requested_kmax_over_T": requested_kmax, + "requested_exceeds_table": requested_kmax > table_kmax + 1.0e-12, + "configured_memory_window_Tinv": requested_window, + }, + "repaired_config": repaired_config, + "gates": { + "no_table_extrapolation_in_repaired_config": repaired_config["radial_momentum_maximum_over_T"] <= table_kmax, + "full_3pi_pilot_not_authorized": repaired_config["pilot_authorization"] is False, + "off_shell_spread_reported": int(selected.size) > 0, + }, + } + + +def write_results(repo_root: Path, output_dir: Path) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run(repo_root) + (output_dir / "kernel_uncertainty_results.json").write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--repo-root", type=Path, required=True) + parser.add_argument("--output-dir", type=Path, default=Path("results")) + args = parser.parse_args() + answer = write_results(args.repo_root, args.output_dir) + print(json.dumps(answer, indent=2)) From 61454cace6fc853f2a7423a3909d85fecd76b71e Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:40:11 +1000 Subject: [PATCH 20/23] Add corrected LPM recomputation and convergence gates --- .../src/frontier_evidence/lpm_repair.py | 192 ++++++++++++++++++ 1 file changed, 192 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/lpm_repair.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/lpm_repair.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/lpm_repair.py new file mode 100644 index 0000000..5cef5d1 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/lpm_repair.py @@ -0,0 +1,192 @@ +"""Correct and independently re-run the v1.4/v1.5 LPM evidence layer.""" +from __future__ import annotations + +import importlib.util +import json +import math +from pathlib import Path +import sys +from typing import Any + +import numpy as np + + +def _load_module(name: str, path: Path) -> Any: + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise ImportError(f"Cannot load {name} from {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def _legacy_paths(repo_root: Path) -> tuple[Path, Path]: + base = repo_root / "chronometric-emergence" / "original-info" + v14 = base / "direct_amy_transport_research_package_v1_4" + v15 = base / "electroweak_yukawa_lpm_package_v1_5" + if not v14.exists() or not v15.exists(): + raise FileNotFoundError(f"Legacy transport packages not found below {base}") + return v14, v15 + + +def corrected_setup_factory(v14: Any): + def corrected_setup(channel: str, x: float, parameters: dict) -> tuple[tuple[float, float, float], float]: + mg = parameters["mg2_T2"] + mq = parameters["mq2_T2"] + md = parameters["mDf2_T2"] + mh = parameters["mH2_T2"] + if channel == "g_to_gg": + casimirs, masses = (v14.CA, v14.CA, v14.CA), (mg, mg, mg) + elif channel == "q_to_gq": + casimirs, masses = (v14.CF, v14.CA, v14.CF), (mq, mg, mq) + elif channel == "D_to_gD": + casimirs, masses = (v14.CF, v14.CA, v14.CF), (md, mg, md) + elif channel == "g_to_qq": + casimirs, masses = (v14.CA, v14.CF, v14.CF), (mg, mq, mq) + elif channel == "g_to_DD": + casimirs, masses = (v14.CA, v14.CF, v14.CF), (mg, md, md) + elif channel == "H_to_qD": + casimirs, masses = (0.0, v14.CF, v14.CF), (mh, mq, md) + else: + raise KeyError(channel) + parent, daughter_x, daughter_1mx = masses + mass_combination = ( + (1.0 - x) * daughter_x + + x * daughter_1mx + - x * (1.0 - x) * parent + ) / mg + return v14.ccoeff(*casimirs), mass_combination + + return corrected_setup + + +def run(repo_root: Path, full: bool = True) -> dict: + repo_root = repo_root.resolve() + v14_dir, v15_dir = _legacy_paths(repo_root) + sys.path.insert(0, str(v14_dir)) + v14 = _load_module("frontier_legacy_v14", v14_dir / "verify_full_amy_collision_v1_4.py") + original_setup = v14.setup + channels = ["g_to_gg", "q_to_gq", "D_to_gD", "g_to_qq", "g_to_DD", "H_to_qD"] + point = {"pT": 3.0, "alpha": 0.0393544, "yD": 0.30, "MDT": 0.01} + + old_rates = { + channel: float(v14.integrated_rate(channel, point["pT"], point["alpha"], point["yD"], point["MDT"])) + for channel in channels + } + v14.setup = corrected_setup_factory(v14) + corrected_rates = { + channel: float(v14.integrated_rate(channel, point["pT"], point["alpha"], point["yD"], point["MDT"])) + for channel in channels + } + v14.setup = original_setup + + rate_changes = { + channel: { + "old": old_rates[channel], + "corrected": corrected_rates[channel], + "relative_change": corrected_rates[channel] / max(old_rates[channel], 1.0e-300) - 1.0, + } + for channel in channels + } + + v14.setup = corrected_setup_factory(v14) + weak_alphas = np.asarray([1.0e-4, 2.0e-4, 4.0e-4]) + weak_rates = np.asarray( + [v14.integrated_rate("g_to_gg", 3.0, float(a), 0.30, 0.01) for a in weak_alphas] + ) + v14.setup = original_setup + weak_slope = float(np.polyfit(np.log(weak_alphas), np.log(np.maximum(weak_rates, 1.0e-300)), 1)[0]) + + deep_lpm = [] + for eta in (10.0, 100.0, 1000.0): + exact = float(v14.solve_lpm(eta, 0.5, 0.0, v14.ccoeff(v14.CA, v14.CA, v14.CA)).mu2) + asymptotic = float(v14.deep_lpm_gg(eta)) + deep_lpm.append( + { + "eta": eta, + "direct": exact, + "deep_LPM": asymptotic, + "relative_difference": (exact - asymptotic) / asymptotic, + } + ) + + sys.path.insert(0, str(v15_dir)) + v15 = _load_module("frontier_legacy_v15", v15_dir / "verify_electroweak_yukawa_lpm_v1_5.py") + qd = v15.qd_thermal_data(v15.ModelPoint()) + electron = v15.electron_thermal_data() + quality_low = v15.MEDIUM if not full else v15.HIGH8 + quality_high = v15.HIGH8 if not full else v15.HIGH10 + + electron_low, _ = v15.integrate_lpm(electron, quality_low) + electron_high, _ = v15.integrate_lpm(electron, quality_high) + qd_low, _ = v15.integrate_lpm(qd, quality_low) + qd_high, _ = v15.integrate_lpm(qd, quality_high) + susceptibility = 2.0 / 3.0 + gamma_occ = v15.NC * v15.ModelPoint().y_d**2 * qd_high / susceptibility + + gates = { + "v14_mass_formula_changed_nontrivially": any( + abs(value["relative_change"]) > 1.0e-3 for value in rate_changes.values() + ), + "weak_scattering_log_slope_near_one": abs(weak_slope - 1.0) < 0.12, + "v15_electron_external_fit_within_15_percent": abs(electron_high - electron["fit"]) / electron["fit"] < 0.15, + "v15_qd_resolution_change_lt_8_percent": abs(qd_high - qd_low) / max(abs(qd_high), 1.0e-30) < 0.08, + "v15_electron_resolution_change_lt_8_percent": abs(electron_high - electron_low) / max(abs(electron_high), 1.0e-30) < 0.08, + "corrected_rates_finite_nonnegative": all( + math.isfinite(value) and value >= 0.0 for value in corrected_rates.values() + ), + } + + return { + "evidence_class": ["INDEPENDENT_RECOMPUTATION", "CONVERGENCE", "EXTERNAL_BENCHMARK"], + "full_recomputation": full, + "benchmark_point": point, + "v14_mass_formula": { + "deprecated": "m_parent^2-(1-x)m_1^2-xm_2^2", + "corrected": "(1-x)m_1^2+xm_2^2-x(1-x)m_parent^2", + "rates": rate_changes, + "scientific_status": "DEPRECATED_NUMBERS_RECOMPUTED_AS_DIAGNOSTIC", + }, + "bethe_heitler_scaling": { + "alpha_s": weak_alphas.tolist(), + "rates": weak_rates.tolist(), + "log_log_slope": weak_slope, + }, + "deep_lpm_comparison": deep_lpm, + "v15_recomputation": { + "electron_low_resolution": electron_low, + "electron_high_resolution": electron_high, + "published_fit": electron["fit"], + "electron_high_relative_to_fit": (electron_high - electron["fit"]) / electron["fit"], + "qd_low_resolution": qd_low, + "qd_high_resolution": qd_high, + "qd_resolution_relative_change": (qd_high - qd_low) / qd_high, + "Gamma_H_occupation_over_T": gamma_occ, + "scope": ( + "collinear LPM q-D-H contribution; hard Yukawa-assisted 2<->2 cuts and full off-shell " + "matching are not included" + ), + }, + "gates": gates, + "all_gates_pass": bool(all(gates.values())), + } + + +def write_results(repo_root: Path, output_dir: Path, full: bool = True) -> dict: + output_dir.mkdir(parents=True, exist_ok=True) + result = run(repo_root, full=full) + (output_dir / "lpm_repair_results.json").write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + return result + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--repo-root", type=Path, required=True) + parser.add_argument("--output-dir", type=Path, default=Path("results")) + parser.add_argument("--fast", action="store_true") + args = parser.parse_args() + result = write_results(args.repo_root, args.output_dir, full=not args.fast) + print(json.dumps(result, indent=2)) + raise SystemExit(0 if result["all_gates_pass"] else 2) From b026895f43a6ae81c6986d7a68ce93e840771287 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:41:02 +1000 Subject: [PATCH 21/23] Add integrated frontier evidence runner --- .../src/frontier_evidence/run_all.py | 147 ++++++++++++++++++ 1 file changed, 147 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/run_all.py diff --git a/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/run_all.py b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/run_all.py new file mode 100644 index 0000000..6678c92 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/src/frontier_evidence/run_all.py @@ -0,0 +1,147 @@ +"""Run the complete adversarial evidence repair suite.""" +from __future__ import annotations + +import argparse +import csv +import json +from pathlib import Path +from typing import Any + +from . import compact_objects, formal_core, kernel_uncertainty, lpm_repair +from . import nu0_fate, portability, qcd_threshold, rg_audit +from . import scalar_two_time, threepi_combinatorics, uv_quality + + +def _write_claim_matrix(path: Path) -> None: + rows = [ + {"claim":"universal clock factorisation theorem","current_status":"RETAINED","evidence_class":"IDENTITY_PIN","frontier_effect":"formal core survives; novelty review open"}, + {"claim":"rank-r clock network identifies r fields","current_status":"CORRECTED","evidence_class":"IDENTITY_PIN","frontier_effect":"requires full-rank sensitivities and independent excitations"}, + {"claim":"2/27 exact transmission","current_status":"LEADING_ORDER_ONLY","evidence_class":"IDENTITY_PIN+EXTERNAL_BENCHMARK","frontier_effect":"NLO few-percent band required"}, + {"claim":"v1.3 RG completion","current_status":"RETRACTED","evidence_class":"IDENTITY_PIN","frontier_effect":"hard matching at natural scale retained; RG closure open"}, + {"claim":"v1.4 transport table","current_status":"DEPRECATED","evidence_class":"INDEPENDENT_RECOMPUTATION","frontier_effect":"corrected diagnostic generated; v1.5 is anchor"}, + {"claim":"v1.5 LPM portal anchor","current_status":"RETAINED_WITH_SCOPE","evidence_class":"CONVERGENCE+EXTERNAL_BENCHMARK","frontier_effect":"collinear sector only; hard cuts remain"}, + {"claim":"v1.7-v1.8 arbitrary off-shell kernel","current_status":"MODEL_FAMILY_ONLY","evidence_class":"MODEL_DISCREPANCY","frontier_effect":"no pointwise physical error bar claimed"}, + {"claim":"v1.9 pilot ready","current_status":"RETRACTED","evidence_class":"SOURCE_AUDIT","frontier_effect":"specification only; no 3PI solver"}, + {"claim":"prompt daughter harmless","current_status":"REPAIRED_CONDITIONALLY","evidence_class":"RATE_CALCULATION+PREDICTION","frontier_effect":"gauge-charged daughter thermalises; model representation changed"}, + {"claim":"low-f_a ridge environmentally safe","current_status":"BLOCKED","evidence_class":"PREDICTION","frontier_effect":"neutron-star conversion condition is met"}, + {"claim":"elementary global Z6 field has adequate UV quality","current_status":"RETRACTED","evidence_class":"PREDICTION","frontier_effect":"24-link local gauge completion is a conditional repair"}, + {"claim":"real-time infrastructure exists","current_status":"UNIT_TIER_EARNED","evidence_class":"INDEPENDENT_RECOMPUTATION+CONVERGENCE","frontier_effect":"scalar two-time gate passes; non-Abelian 3PI remains unimplemented"}, + ] + with path.open("w", newline="", encoding="utf-8") as handle: + writer = csv.DictWriter(handle, fieldnames=list(rows[0])) + writer.writeheader() + writer.writerows(rows) + + +def _render_report(results: dict[str, Any]) -> str: + scalar = results["scalar_two_time"] + lpm = results["lpm_repair"] + compact = results["compact_objects"] + kernel = results["kernel_uncertainty"] + nu = results["nu0_fate"] + uv = results["uv_quality"] + threepi = results["threepi_combinatorics"] + qcd = results["qcd_threshold"] + lines = [ + "# Frontier evidence report v2", + "", + "**Author: Angus Muffatti**", + "", + "## Executive result", + "", + "The repair suite earns a defensible **evidence frontier** for the narrow formal core, the leading QCD-threshold interpretation, the corrected LPM evidence layer, exact 3PI combinatorial magnitudes, and a real scalar unequal-time unit tier.", + "", + "It does **not** authorize the full non-Abelian pilot or establish a viable cosmological completion. Neutron-star conversion and the absence of a working 3PI evolution engine remain load-bearing blockers.", + "", + "## Results", + "", + f"- Scalar unequal-time gates: **{sum(scalar['gates'].values())}/{len(scalar['gates'])}**; all pass = `{scalar['all_gates_pass']}`.", + f"- 3PI coefficient magnitudes: **{len(threepi['rows'])}/11** checked; all match = `{threepi['all_magnitudes_match']}`.", + f"- v1.3 RG closure: **{results['rg_audit']['scientific_verdict']}**.", + f"- Corrected LPM evidence gates: **{sum(lpm['gates'].values())}/{len(lpm['gates'])}**; all pass = `{lpm['all_gates_pass']}`.", + f"- v1.5 recomputed portal occupation width: `{lpm['v15_recomputation']['Gamma_H_occupation_over_T']:.6g} T`.", + f"- Leading QCD coefficient: `{qcd['one_loop_exact']:.9g}`; conventional NLO estimate: `{qcd['conventional_NLO_estimate']:.9g}`.", + f"- Sterile prompt-daughter Delta N_eff: `{nu['sterile_cascade']['DeltaNeff_total']:.4g}`; repaired Delta N_eff: `{nu['repaired_cascade']['DeltaNeff_total']:.4g}`.", + f"- Neutron-star blocker: `{compact['neutron_star_blocker']}`.", + f"- UV-quality status: `{uv['status']}`.", + f"- v1.7/v1.8 far-off-shell p95 model discrepancy: `{kernel['relative_model_discrepancy']['far_off_shell']['p95']}`.", + "", + "## Evidence boundary", + "", + "The scalar unit tier is a genuine calculation, but it is an exactly specified open scalar system rather than the desired gauge plasma. The 3PI graph audit independently validates coefficient magnitudes, not Minkowski phases or the correctness of a future discretised functional derivative. The LPM run validates the collinear layer, not the missing hard cuts.", + "", + "## Frontier decision", + "", + "| Frontier | Decision |", + "|---|---|", + "| Formal chronometric-shear programme | **CONDITIONALLY EARNED** |", + "| Leading threshold phenomenology | **EARNED AT ONE LOOP; NLO BAND ADDED** |", + "| Scalar real-time software unit tier | **EARNED** |", + "| Full q-D-H hard+LPM thermal correlator | **NOT YET** |", + "| PT/BFM three-loop 3PI pilot | **NOT AUTHORIZED** |", + "| Cosmological realization | **BLOCKED BY COMPACT OBJECTS** |", + "| UV completion | **CONDITIONAL 24-LINK SKELETON** |", + "", + "The correct next frontier calculation is therefore a real, source-generated scalar/Yukawa 2PI evolution followed by the hard-cut completion—not an eight-GPU run of a nonexistent solver.", + "", + ] + return "\n".join(lines) + + +def run_all(repo_root: Path, package_root: Path, full_lpm: bool = True) -> dict[str, Any]: + output_dir = package_root / "results" + docs_dir = package_root / "docs" + output_dir.mkdir(parents=True, exist_ok=True) + docs_dir.mkdir(parents=True, exist_ok=True) + + results: dict[str, Any] = {} + results["formal_core"] = formal_core.write_results(output_dir) + results["qcd_threshold"] = qcd_threshold.write_results(output_dir) + results["rg_audit"] = rg_audit.write_results(output_dir) + results["scalar_two_time"] = scalar_two_time.write_results(output_dir) + results["threepi_combinatorics"] = threepi_combinatorics.write_results(output_dir) + results["nu0_fate"] = nu0_fate.write_results(output_dir) + results["compact_objects"] = compact_objects.write_results(output_dir) + results["uv_quality"] = uv_quality.write_results(output_dir) + results["lpm_repair"] = lpm_repair.write_results(repo_root, output_dir, full=full_lpm) + results["kernel_uncertainty"] = kernel_uncertainty.write_results(repo_root, output_dir) + results["portability"] = portability.write_results(repo_root, package_root, output_dir) + + software_gates = { + "scalar_two_time": results["scalar_two_time"]["all_gates_pass"], + "threepi_magnitudes": results["threepi_combinatorics"]["all_magnitudes_match"], + "nu0_repair": results["nu0_fate"]["all_repair_gates_pass"], + "lpm_repair": results["lpm_repair"]["all_gates_pass"], + "portability": results["portability"]["all_active_portability_gates_pass"], + "kernel_audit": all(results["kernel_uncertainty"]["gates"].values()), + } + results["frontier_status"] = { + "software_evidence_gates": software_gates, + "all_software_evidence_gates_pass": bool(all(software_gates.values())), + "formal_frontier": "CONDITIONAL_EARNED", + "scalar_unit_frontier": "EARNED", + "nonabelian_3pi_frontier": "NOT_AUTHORIZED", + "cosmology_frontier": "BLOCKED", + "publication_frontier": "NARROW_NOTE_ONLY_AFTER_SPECIALIST_REVIEW", + } + + (output_dir / "frontier_status.json").write_text(json.dumps(results["frontier_status"], indent=2) + "\n", encoding="utf-8") + _write_claim_matrix(output_dir / "claim_matrix_v2.csv") + (docs_dir / "FRONTIER_EVIDENCE_REPORT.md").write_text(_render_report(results), encoding="utf-8") + return results + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--repo-root", type=Path, required=True) + parser.add_argument("--package-root", type=Path) + parser.add_argument("--fast-lpm", action="store_true") + args = parser.parse_args() + package_root = args.package_root or Path(__file__).resolve().parents[2] + results = run_all(args.repo_root.resolve(), package_root.resolve(), full_lpm=not args.fast_lpm) + print(json.dumps(results["frontier_status"], indent=2)) + raise SystemExit(0 if results["frontier_status"]["all_software_evidence_gates_pass"] else 2) + + +if __name__ == "__main__": + main() From 446bc4a8bf560f06e7da775de6e6b07c662e47a7 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:41:26 +1000 Subject: [PATCH 22/23] Add adversarial frontier regression and convergence tests --- .../tests/test_frontier.py | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 chronometric-emergence/frontier-evidence-v2/tests/test_frontier.py diff --git a/chronometric-emergence/frontier-evidence-v2/tests/test_frontier.py b/chronometric-emergence/frontier-evidence-v2/tests/test_frontier.py new file mode 100644 index 0000000..57cc444 --- /dev/null +++ b/chronometric-emergence/frontier-evidence-v2/tests/test_frontier.py @@ -0,0 +1,69 @@ +from pathlib import Path +import os + +from frontier_evidence.formal_core import run as run_formal +from frontier_evidence.qcd_threshold import run as run_qcd +from frontier_evidence.rg_audit import run as run_rg +from frontier_evidence.scalar_two_time import run as run_scalar +from frontier_evidence.threepi_combinatorics import run as run_threepi +from frontier_evidence.nu0_fate import run as run_nu +from frontier_evidence.compact_objects import run as run_compact +from frontier_evidence.uv_quality import run as run_uv +from frontier_evidence.kernel_uncertainty import run as run_kernel +from frontier_evidence.lpm_repair import run as run_lpm +from frontier_evidence.portability import run as run_portability + + +REPO_ROOT = Path(os.environ.get("CHRONOMETRIC_REPO_ROOT", Path(__file__).resolve().parents[3])) +PACKAGE_ROOT = Path(__file__).resolve().parents[1] + + +def test_formal_and_rg_scope(): + formal = run_formal() + assert formal["universal_clock_factorisation"]["status"] == "EXACT_ELEMENTARY_THEOREM" + assert formal["v0_2_relations"]["status"] == "RETIRED_AS_UNIVERSAL_CLAIMS" + qcd = run_qcd() + assert abs(qcd["one_loop_exact"] - 2 / 27) < 1e-15 + assert 0.02 < qcd["relative_NLO_shift"] < 0.06 + rg = run_rg() + assert rg["cancellation_is_exact"] + assert rg["scientific_verdict"] == "RETRACTED" + assert rg["fixed_order_scale_derivative"] != "0" + + +def test_scalar_two_time_is_fallible_and_converged(): + summary, arrays = run_scalar() + assert summary["all_gates_pass"], summary + assert arrays["rho_exact_bath"].shape == arrays["F_exact_bath"].shape + assert min(summary["observed_orders"]) > 2.8 + assert summary["memory_window_relative_l2_changes"]["12"] < 0.002 + + +def test_threepi_magnitudes_are_independently_reproduced(): + result = run_threepi() + assert result["all_magnitudes_match"], result + assert len(result["rows"]) == 11 + assert {row["automorphism_order"] for row in result["rows"]} >= {1, 2, 3, 4, 6, 8, 12, 24, 48} + + +def test_cosmology_repairs_and_blockers_are_explicit(): + nu = run_nu() + assert nu["sterile_cascade"]["DeltaNeff_total"] > 0.1 + assert nu["all_repair_gates_pass"], nu + compact = run_compact() + assert compact["neutron_star_blocker"] + assert compact["scientific_status"] == "BLOCKED" + uv = run_uv() + row = next(item for item in uv["deconstructed_scan"] if item["links"] == 24) + assert row["quality_pass"] + assert uv["log10_elementary_c6_bound"] < -70 + + +def test_repo_dependent_evidence_layers(): + kernel = run_kernel(REPO_ROOT) + assert kernel["coverage_audit"]["requested_exceeds_table"] + assert all(kernel["gates"].values()) + lpm = run_lpm(REPO_ROOT, full=False) + assert lpm["all_gates_pass"], lpm + portable = run_portability(REPO_ROOT, PACKAGE_ROOT) + assert portable["all_active_portability_gates_pass"], portable From 5d23ce5cd20e20b3e9a9dd4a08b30b35f43b0416 Mon Sep 17 00:00:00 2001 From: Dirtman <130276587+terrorproforma@users.noreply.github.com> Date: Wed, 26 Aug 2026 03:41:54 +1000 Subject: [PATCH 23/23] Add full frontier evidence CI --- .../chronometric-frontier-evidence-v2.yml | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 .github/workflows/chronometric-frontier-evidence-v2.yml diff --git a/.github/workflows/chronometric-frontier-evidence-v2.yml b/.github/workflows/chronometric-frontier-evidence-v2.yml new file mode 100644 index 0000000..aa43d36 --- /dev/null +++ b/.github/workflows/chronometric-frontier-evidence-v2.yml @@ -0,0 +1,68 @@ +name: Chronometric frontier evidence v2 + +on: + push: + branches: + - chronometric-frontier-evidence-v2 + paths: + - .github/workflows/chronometric-frontier-evidence-v2.yml + - chronometric-emergence/frontier-evidence-v2/src/** + - chronometric-emergence/frontier-evidence-v2/tests/** + - chronometric-emergence/frontier-evidence-v2/pyproject.toml + - chronometric-emergence/frontier-evidence-v2/Makefile + +permissions: + contents: write + +jobs: + evidence-repair: + runs-on: ubuntu-latest + timeout-minutes: 120 + steps: + - name: Check out repair branch + uses: actions/checkout@v4 + with: + ref: chronometric-frontier-evidence-v2 + fetch-depth: 0 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.12' + cache: pip + cache-dependency-path: chronometric-emergence/frontier-evidence-v2/pyproject.toml + + - name: Install evidence package + working-directory: chronometric-emergence/frontier-evidence-v2 + run: python -m pip install -e '.[test]' + + - name: Run full independent evidence suite + working-directory: chronometric-emergence/frontier-evidence-v2 + env: + CHRONOMETRIC_REPO_ROOT: ${{ github.workspace }} + run: python -m frontier_evidence.run_all --repo-root "${GITHUB_WORKSPACE}" + + - name: Run tests from a clean checkout layout + working-directory: chronometric-emergence/frontier-evidence-v2 + env: + CHRONOMETRIC_REPO_ROOT: ${{ github.workspace }} + run: pytest -q + + - name: Commit generated evidence + run: | + git config user.name "Angus Muffatti" + git config user.email "130276587+terrorproforma@users.noreply.github.com" + git add chronometric-emergence/frontier-evidence-v2/results \ + chronometric-emergence/frontier-evidence-v2/docs/FRONTIER_EVIDENCE_REPORT.md + if ! git diff --cached --quiet; then + git commit -m "Generate adversarial frontier evidence v2 [frontier-generated]" + git push origin HEAD:chronometric-frontier-evidence-v2 + fi + + - name: Upload evidence bundle + uses: actions/upload-artifact@v4 + with: + name: chronometric-frontier-evidence-v2 + path: | + chronometric-emergence/frontier-evidence-v2/results + chronometric-emergence/frontier-evidence-v2/docs/FRONTIER_EVIDENCE_REPORT.md