From 28ff3c146f08c5e3c5363011584ed46bfcb097a0 Mon Sep 17 00:00:00 2001 From: "Jorge A. Garcia" <681013+jagg-ix@users.noreply.github.com> Date: Thu, 30 Jul 2026 17:14:28 -0600 Subject: [PATCH] feat(M14): combine continuum AdS double-copy lineage --- MODELS.md | 11 +- MODELS_M14.md | 34 ++ .../m14_continuum_ads_double_copy/__init__.py | 7 + ...s_normalized_continuum_double_copy_m143.py | 321 ++++++++++++++++++ .../causal_green_hadamard_m141.py | 240 +++++++++++++ ...s_normalized_continuum_double_copy.v1.json | 52 +++ .../formal/causal_green_hadamard.v1.json | 38 +++ .../formal/infinite_bcj_direct_limit.v1.json | 53 +++ .../smooth_continuum_ads_double_copy.v1.json | 59 ++++ .../infinite_bcj_direct_limit_m142.py | 294 ++++++++++++++++ .../model_registration.py | 4 + ...s_normalized_continuum_double_copy_m143.zc | 7 + .../zil/m14_causal_green_hadamard_m141.zc | 7 + .../zil/m14_infinite_bcj_direct_limit_m142.zc | 7 + ...4_smooth_continuum_ads_double_copy_m144.zc | 8 + .../smooth_continuum_ads_double_copy_m144.py | 270 +++++++++++++++ ...s_normalized_continuum_double_copy_m143.py | 7 + tests/test_m14_causal_green_hadamard_m141.py | 7 + ...test_m14_infinite_bcj_direct_limit_m142.py | 7 + ...4_smooth_continuum_ads_double_copy_m144.py | 8 + 20 files changed, 1438 insertions(+), 3 deletions(-) create mode 100644 MODELS_M14.md create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/__init__.py create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/ads_normalized_continuum_double_copy_m143.py create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/causal_green_hadamard_m141.py create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/formal/ads_normalized_continuum_double_copy.v1.json create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/formal/causal_green_hadamard.v1.json create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/formal/infinite_bcj_direct_limit.v1.json create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/formal/smooth_continuum_ads_double_copy.v1.json create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/infinite_bcj_direct_limit_m142.py create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/model_registration.py create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_ads_normalized_continuum_double_copy_m143.zc create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_causal_green_hadamard_m141.zc create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_infinite_bcj_direct_limit_m142.zc create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_smooth_continuum_ads_double_copy_m144.zc create mode 100644 openwave/xperiments/m14_continuum_ads_double_copy/smooth_continuum_ads_double_copy_m144.py create mode 100644 tests/test_m14_ads_normalized_continuum_double_copy_m143.py create mode 100644 tests/test_m14_causal_green_hadamard_m141.py create mode 100644 tests/test_m14_infinite_bcj_direct_limit_m142.py create mode 100644 tests/test_m14_smooth_continuum_ads_double_copy_m144.py diff --git a/MODELS.md b/MODELS.md index 953e1365..103462ef 100644 --- a/MODELS.md +++ b/MODELS.md @@ -9,7 +9,8 @@ OpenWave hosts multiple candidate field-theoretic models. Historical M4--M8 resu | **M10** | **CAT/EPT Dirac--Cartan--2I--Compton--Yukawa and SU(3) color matter** | **`MODELS_M10.md`** | **latest M10.8 registration, Wilson refinement and decoherence spectra** | | **M11** | **CAT/EPT pointwise soliton--Liouville--QDO model** | **`MODELS_M11.md`** | **M11.1--M11.5 executable lineage and theorem-pinned ledgers** | | **M12** | **CAT/EPT particle-zoo coverage model** | **`MODELS_M12.md`** | **M12.1--M12.3 executable identity, electroweak, flavor, hadron and QCD coverage** | -| **M13** | **CAT/EPT scale-dilation and holographic-amplitude model** | **`MODELS_M13.md`** | **M13.5 BCJ--Yukawa holographic synthesis** | +| **M13** | **CAT/EPT scale-dilation and holographic-amplitude model** | **`MODELS_M13.md`** | **M13 holographic and amplitude lineage** | +| **M14** | **CAT/EPT continuum AdS double-copy model** | **`MODELS_M14.md`** | **M14.1--M14.4 causal Green, infinite BCJ, AdS normalization and smooth conditional closure** | ## M9 stable and latest lineage @@ -29,6 +30,10 @@ M11 begins from an exact normalized pointwise bright soliton, constructs its pur M12 mirrors the particle-zoo theorem surfaces as executable checks: the 17 Standard-Model particle types and 12 gauge states, CPT and additive selection rules, tree-level electroweak/lepton/neutrino relations, named-hadron flavor composition, SU(3) mass formulas and one-loop QCD running. Empirical masses, lifetimes, branching fractions, couplings and mixing parameters remain explicitly supplied inputs. -## M13 scale-dilation soliton-tensor model +## M13 scale-dilation and holographic-amplitude model -M13 places the M11 pointwise soliton and finite-cutoff infinite-mode tensor on the exact multiplicative scale line formalized by CAT/EPT. M13.2 composes that carrier with finite GKP--Witten and Ryu--Takayanagi identities, conformal operator towers, finite-density and Lovelock AdS data, projective twistors, BCJ/primitive-QCD relations, M10 Wilson loops and ABJM Wilson algebra while retaining explicit finite/algebraic claim boundaries. M13.5 additionally threads one supplied Yukawa mass through finite massive BCJ/QCD channels, the Wilson-derived effective Regge slope, the GKP dimension and the RT cutoff while retaining a strict no-amplitude--entropy-equality boundary. +M13 places the M11 pointwise soliton and finite-cutoff infinite-mode tensor on the exact multiplicative scale line, then adds finite GKP/RT, BCJ/QCD, twistor, Wilson, Yukawa, RG, Penrose and dimensional-reduction adapters with explicit theorem ledgers. + +## M14 continuum AdS double-copy model + +M14 uses the latest formal TIP to compose causal Maxwell Green/Hadamard operators, pointwise and `L²` continuum kernel infrastructure, an explicitly convergent infinite BCJ weighted series, D3/boundary-central-charge AdS normalization, and compatible smooth harmonic-Einstein direct limits. The final result is a conditional executable closure, not an unconditional global, interacting or loop-level AdS double-copy theorem. diff --git a/MODELS_M14.md b/MODELS_M14.md new file mode 100644 index 00000000..ae19c9a1 --- /dev/null +++ b/MODELS_M14.md @@ -0,0 +1,34 @@ +# OpenWave M14 CAT/EPT continuum AdS double-copy model + +M14 composes the latest `entropic-physlib-linear-full` continuum PDE and smooth-geometric infrastructure with the existing finite BCJ and AdS/CFT dictionaries. The formal authority is pinned to TIP `ea6c394fcb1d55546d11cd6af3df6556c610d52e`. + +## Lineage + +| Milestone | Executable result | +| --- | --- | +| M14.1 | causal retarded/advanced Green recurrences, Pauli--Jordan propagator, energy bounds, positive-frequency Hadamard probe kernel | +| M14.2 | pointwise Jacobi numerator sequences, square-summable infinite BCJ direct limit, analytic tail control and generalized-gauge invariance | +| M14.3 | D3/boundary-central-charge normalization of the continuum BCJ limit, GKP source kernel and RT/Complex-Einstein observables | +| M14.4 | compatible nested harmonic slabs, smooth Lorentzian metric direct limit and conditional continuum AdS double-copy closure | + +## Formal composition + +The formal repository supplies independent theorem surfaces for finite BCJ color replacement and generalized-gauge invariance; D3-normalized finite AdS/BCJ, GKP, RT and Complex-Einstein identities; infinite-dimensional `H¹(R³; C⁴) -> H⁻¹(R³; C⁴)` causal Maxwell Green operators with graph-energy bounds; distributional Hadamard wavefront transport; continuum `L²(X x X)` Liouville kernels and dense maximal pointwise operators; local harmonic-gauge Einstein existence/uniqueness; and a smooth pseudo-Riemannian metric on the Cauchy-development direct limit under explicit compatibility data. + +M14 supplies the executable compatibility layer between those surfaces. M14.2 does not rename the finite BCJ theorem as a continuum theorem: it adds a concrete square-summable numerator family, pointwise Jacobi closure, a convergent weighted series and a quantitative tail estimate. + +## Claim boundary + +The final M14.4 result has status **conditional-model**. It does not claim that every globally hyperbolic metric automatically supplies coercive Green/Hadamard data, that finite BCJ algebra alone proves infinite-graph convergence, that the BCJ amplitude equals RT entropy, or that a global interacting, loop-level or nonperturbative AdS double-copy theorem has been proved. + +Visible premises include causal Sobolev closedness/coercivity, microlocal regularity and singularity, numerator summability, weighted gauge orthogonality, D3 compactification data, harmonic Einstein well-posedness and smooth direct-limit compatibility. + +## Reproduction + +```bash +PYTHONPATH=. python - <<'PY' +from openwave.xperiments.m14_continuum_ads_double_copy import run_m14_model_study +import json +print(json.dumps(run_m14_model_study(), indent=2, sort_keys=True, default=str)) +PY +``` diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/__init__.py b/openwave/xperiments/m14_continuum_ads_double_copy/__init__.py new file mode 100644 index 00000000..eb077a24 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/__init__.py @@ -0,0 +1,7 @@ +"""M14 CAT/EPT continuum AdS double-copy lineage.""" +from .causal_green_hadamard_m141 import CausalGreenHadamardConfig, run_causal_green_hadamard_study +from .infinite_bcj_direct_limit_m142 import InfiniteBCJDirectLimitConfig, run_infinite_bcj_direct_limit_study +from .ads_normalized_continuum_double_copy_m143 import AdSNormalizedContinuumConfig, run_ads_normalized_continuum_double_copy_study +from .smooth_continuum_ads_double_copy_m144 import SmoothContinuumAdSDoubleCopyConfig, run_smooth_continuum_ads_double_copy_study +run_m14_model_study=run_smooth_continuum_ads_double_copy_study +__all__=["CausalGreenHadamardConfig","InfiniteBCJDirectLimitConfig","AdSNormalizedContinuumConfig","SmoothContinuumAdSDoubleCopyConfig","run_causal_green_hadamard_study","run_infinite_bcj_direct_limit_study","run_ads_normalized_continuum_double_copy_study","run_smooth_continuum_ads_double_copy_study","run_m14_model_study"] diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/ads_normalized_continuum_double_copy_m143.py b/openwave/xperiments/m14_continuum_ads_double_copy/ads_normalized_continuum_double_copy_m143.py new file mode 100644 index 00000000..ebf297f3 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/ads_normalized_continuum_double_copy_m143.py @@ -0,0 +1,321 @@ +"""M14.3 D3-normalized continuum BCJ/GKP/RT composition. + +The same D3/boundary-central-charge coupling is used for the convergent M14.2 +BCJ series, a positive-frequency continuum boundary kernel, the finite GKP +quadratic source response, and the RT normalization. The module composes +normalizations; it does not identify an amplitude with an entropy or construct +an interacting Witten functional. +""" +from __future__ import annotations + +from dataclasses import asdict, dataclass, replace +from hashlib import sha256 +import json +import math +from typing import Any, Mapping + +import numpy as np + +from .causal_green_hadamard_m141 import run_causal_green_hadamard_study +from .infinite_bcj_direct_limit_m142 import ( + InfiniteBCJDirectLimitConfig, + run_infinite_bcj_direct_limit_study, +) + +MILESTONE = "M14.3" +SCHEMA = "openwave.m14.ads-normalized-continuum-double-copy.v1" +FORMAL_HEAD = "ea6c394fcb1d55546d11cd6af3df6556c610d52e" +FORMAL_SOURCES = ( + { + "path": "Physlib/QuantumMechanics/ComplexAction/Electromagnetic/EMComplexEinsteinAdSCFT.lean", + "sha": "eaa50fbe34c8d5f773826ee6f63265b70f07326c", + "theorems": [ + "d3_adsCFT_BCJ_doubleCopy", + "d3_gkpWittenHessian_complexEinsteinCoupling", + "d3_gkpWittenHessian_boundaryCentralCharge", + "d3_rtEntropy_complexEinsteinCoupling", + "d3_rtEntropy_boundaryCentralCharge", + "d3_boundaryCentralCharge_complexEinstein_conservationFamily", + ], + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/AdSCFT/GKPWittenAdSCFTDictionary.lean", + "sha": "d9f9bf5e00fd1a4880520cab6c4e5458ee4aa1d3", + "theorems": [ + "massDimension_relation", + "cftTwoPoint_scaling", + "gkpWitten_regularized_source_response", + "gkpWitten_affine_source_hessian", + ], + }, + { + "path": "Physlib/QFT/ScalarGreenFunctions.lean", + "sha": "b985c5442a61615f81ebbaaaea45d165338f344a", + "modules": [ + "Continuum", + "ContinuumDysonSchwinger", + "ContinuumVacuum", + "PropagatorHierarchy", + "TraceLog", + ], + }, +) + + +def _canon(value: Mapping[str, Any]) -> str: + return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str) + + +@dataclass(frozen=True) +class AdSNormalizedContinuumConfig: + ads_radius: float = 2.3 + color_rank: float = 6.0 + compactification_volume: float = 1.7 + c: float = 1.0 + boundary_dimension: float = 4.0 + bulk_mass: float = 0.42 + rt_area: float = 1.6 + boundary_points: int = 14 + momentum_max: float = 18.0 + quadrature_counts: tuple[int, ...] = (128, 256, 512, 1024) + uv_cutoff: float = 0.09 + derivative_step: float = 2e-5 + + def validate(self) -> None: + positive = ( + self.ads_radius, + self.color_rank, + self.compactification_volume, + self.c, + self.boundary_dimension, + self.bulk_mass, + self.rt_area, + self.momentum_max, + self.uv_cutoff, + self.derivative_step, + ) + if min(positive) <= 0: + raise ValueError("all geometric and spectral controls must be positive") + if self.boundary_points < 4: + raise ValueError("at least four boundary points required") + if not self.quadrature_counts or sorted(self.quadrature_counts) != list( + self.quadrature_counts + ): + raise ValueError("quadrature_counts must be increasing") + + +def canonical_payload(config: AdSNormalizedContinuumConfig | None = None) -> dict[str, Any]: + cfg = AdSNormalizedContinuumConfig() if config is None else config + return { + "schema": SCHEMA, + "model_id": "M14", + "milestone": MILESTONE, + "model": "CAT/EPT D3-normalized continuum AdS double-copy kernel", + "configuration": asdict(cfg), + "lineage_dependencies": ["M14.2", "M13.8"], + "study_api": ( + "openwave.xperiments.m14_continuum_ads_double_copy." + "ads_normalized_continuum_double_copy_m143:" + "run_ads_normalized_continuum_double_copy_study" + ), + "formal_authority": { + "repository": "jagg-ix/entropic-physlib-private", + "branch": "entropic-physlib-linear-full", + "head": FORMAL_HEAD, + "sources": list(FORMAL_SOURCES), + }, + } + + +def fingerprint(payload: Mapping[str, Any] | None = None) -> str: + value = canonical_payload() if payload is None else payload + return sha256(_canon(value).encode()).hexdigest() + + +def _boundary_kernel( + cfg: AdSNormalizedContinuumConfig, count: int +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + points = np.linspace(0.35, 2.35, cfg.boundary_points) + dq = cfg.momentum_max / count + momenta = (np.arange(count, dtype=float) + 0.5) * dq + propagator_weights = ( + dq + * np.exp(-2.0 * cfg.uv_cutoff * momenta) + / (momenta**2 + cfg.bulk_mass**2) + ) + root = np.sqrt(propagator_weights) + cosine = np.cos(np.outer(points, momenta)) * root + sine = np.sin(np.outer(points, momenta)) * root + features = np.concatenate((cosine, sine), axis=1) + kernel = features @ features.T + return points, momenta, kernel + + +def _conformal_dimension(boundary_dimension: float, mass_radius_sq: float) -> float: + radicand = (boundary_dimension / 2.0) ** 2 + mass_radius_sq + if radicand < 0: + raise ValueError("BF bound violated") + return boundary_dimension / 2.0 + math.sqrt(radicand) + + +def run_ads_normalized_continuum_double_copy_study( + config: AdSNormalizedContinuumConfig | None = None, +) -> dict[str, Any]: + cfg = AdSNormalizedContinuumConfig() if config is None else config + cfg.validate() + + central_charge = cfg.color_rank**2 / 4.0 + kappa_ads = ( + 4.0 + * math.pi**2 + * cfg.ads_radius**3 + / (cfg.color_rank**2 * cfg.compactification_volume * cfg.c**4) + ) + kappa_boundary = ( + math.pi**2 + * cfg.ads_radius**3 + / (cfg.compactification_volume * cfg.c**4 * central_charge) + ) + newton_g4 = kappa_ads * cfg.c**4 / (8.0 * math.pi) + + bcj_cfg = replace(InfiniteBCJDirectLimitConfig(), kappa=kappa_ads) + bcj = run_infinite_bcj_direct_limit_study(bcj_cfg) + + kernels: list[np.ndarray] = [] + for count in cfg.quadrature_counts: + _, _, kernel = _boundary_kernel(cfg, count) + kernels.append(kernel) + kernel_differences = [ + float(np.linalg.norm(right - left, ord="fro")) + for left, right in zip(kernels, kernels[1:]) + ] + points, momenta, kernel = _boundary_kernel(cfg, cfg.quadrature_counts[-1]) + kernel_symmetry_error = float(np.max(np.abs(kernel - kernel.T))) + kernel_eigenvalues = np.linalg.eigvalsh(kernel) + kernel_min_eigenvalue = float(np.min(kernel_eigenvalues)) + + hessian = kernel / newton_g4 + source = np.exp(-points**2) + variation = np.cos(points) * np.exp(-0.2 * points) + + def response(t: float) -> float: + current = source + t * variation + return 0.5 * float(current @ hessian @ current) + + step = cfg.derivative_step + first = (response(step) - response(-step)) / (2.0 * step) + second = (response(step) - 2.0 * response(0.0) + response(-step)) / step**2 + expected_first = float(source @ hessian @ variation) + expected_second = float(variation @ hessian @ variation) + + mass_radius_sq = (cfg.bulk_mass * cfg.ads_radius) ** 2 + conformal_dimension = _conformal_dimension( + cfg.boundary_dimension, mass_radius_sq + ) + separation = 1.4 + dilation = 1.9 + two_point = separation ** (-2.0 * conformal_dimension) + moved_two_point = (dilation * separation) ** (-2.0 * conformal_dimension) + + rt_entropy = cfg.rt_area / (4.0 * newton_g4) + rt_boundary = ( + 2.0 + * cfg.compactification_volume + * central_charge + * cfg.rt_area + / (math.pi * cfg.ads_radius**3) + ) + + diagnostics = { + "central_charge": central_charge, + "kappa_ads": kappa_ads, + "kappa_boundary": kappa_boundary, + "coupling_dictionary_error": abs(kappa_ads - kappa_boundary), + "newton_g4": newton_g4, + "continuum_bcj_amplitude": bcj["diagnostics"]["reference_amplitude"], + "continuum_bcj_dependency_passed": bool(bcj["passed"]), + "kernel_quadrature_differences": kernel_differences, + "kernel_symmetry_error": kernel_symmetry_error, + "kernel_min_eigenvalue": kernel_min_eigenvalue, + "kernel_eigenvalues": kernel_eigenvalues.tolist(), + "positive_momentum_min": float(np.min(momenta)), + "gkp_first_response_error": abs(first - expected_first), + "gkp_hessian_error": abs(second - expected_second), + "conformal_dimension": conformal_dimension, + "mass_dimension_error": abs( + conformal_dimension + * (conformal_dimension - cfg.boundary_dimension) + - mass_radius_sq + ), + "two_point_scaling_error": abs( + moved_two_point - dilation ** (-2.0 * conformal_dimension) * two_point + ), + "rt_entropy": rt_entropy, + "rt_boundary_entropy": rt_boundary, + "rt_boundary_dictionary_error": abs(rt_entropy - rt_boundary), + "kappa_rt_normalization_error": abs( + kappa_ads * rt_entropy - 2.0 * math.pi * cfg.rt_area / cfg.c**4 + ), + "hadamard_dependency_passed": bool( + run_causal_green_hadamard_study()["passed"] + ), + "amplitude_entropy_difference": abs( + bcj["diagnostics"]["reference_amplitude"] - rt_entropy + ), + } + acceptance = { + "d3_and_boundary_couplings_agree": diagnostics["coupling_dictionary_error"] + < 5e-13, + "infinite_bcj_limit_uses_the_ads_coupling": diagnostics[ + "continuum_bcj_dependency_passed" + ], + "positive_frequency_boundary_kernel_converges": bool( + all( + later <= earlier + 5e-10 + for earlier, later in zip( + kernel_differences, kernel_differences[1:] + ) + ) + and kernel_differences[-1] < 3e-3 + and diagnostics["positive_momentum_min"] > 0 + ), + "boundary_kernel_is_symmetric_positive": kernel_symmetry_error < 5e-11 + and kernel_min_eigenvalue > -5e-9, + "gkp_source_response_and_hessian_close": max( + diagnostics["gkp_first_response_error"], + diagnostics["gkp_hessian_error"], + ) + < 2e-4, + "gkp_mass_dimension_and_two_point_scaling_close": max( + diagnostics["mass_dimension_error"], + diagnostics["two_point_scaling_error"], + ) + < 5e-12, + "rt_and_complex_einstein_normalizations_agree": max( + diagnostics["rt_boundary_dictionary_error"], + diagnostics["kappa_rt_normalization_error"], + ) + < 5e-12, + "causal_hadamard_dependency_passes": diagnostics[ + "hadamard_dependency_passed" + ], + "amplitude_is_not_identified_with_entropy": diagnostics[ + "amplitude_entropy_difference" + ] + > 1e-6, + } + payload = canonical_payload(cfg) + return { + **payload, + "task": MILESTONE, + "diagnostics": diagnostics, + "acceptance": acceptance, + "fingerprint": fingerprint(payload), + "passed": all(acceptance.values()), + "decision": { + "same_d3_coupling_normalizes_bcj_gkp_rt_and_einstein_faces": True, + "continuum_kernel_is_a_positive_frequency_quadrature_limit": True, + "amplitude_entropy_equality_not_claimed": True, + "interacting_witten_functional_not_constructed": True, + }, + } diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/causal_green_hadamard_m141.py b/openwave/xperiments/m14_continuum_ads_double_copy/causal_green_hadamard_m141.py new file mode 100644 index 00000000..c6127055 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/causal_green_hadamard_m141.py @@ -0,0 +1,240 @@ +"""M14.1 causal continuum Green/Hadamard adapter. + +This finite spectral campaign mirrors the exact theorem interfaces at the +latest entropic-physlib TIP: causal retarded/advanced inverses, their +Pauli--Jordan difference, energy bounds, and a positive-frequency Hermitian +Hadamard two-point carrier. It is an executable discretization of the formal +continuum carrier, not a proof that an arbitrary Lorentzian metric supplies the +required coercive Sobolev data. +""" +from __future__ import annotations + +from dataclasses import asdict, dataclass +from hashlib import sha256 +import json +import math +from typing import Any, Mapping + +import numpy as np + +MILESTONE = "M14.1" +SCHEMA = "openwave.m14.causal-green-hadamard.v1" +FORMAL_HEAD = "ea6c394fcb1d55546d11cd6af3df6556c610d52e" +FORMAL_SOURCES = ( + { + "path": "Physlib/QuantumMechanics/ComplexAction/CanonicalTetradGravity/GloballyHyperbolicGreenHadamard.lean", + "sha": "bcdef861f5cd3843051a13061adb4e856b686dfe", + "theorems": [ + "MaxwellLaxMilgramGraphData.curvedHOneFourMaxwell_causal_exists_energy", + "MaxwellLaxMilgramGraphData.curvedHOneFourMaxwellGreen_intrinsic_graphEnergy", + "MaxwellLaxMilgramGraphData.curvedHOneFour_causalGreen_intrinsic_homogeneous_energy", + "MaxwellLaxMilgramGraphData.curvedHOneFour_caticha_maxwell_causal_distributional_hadamard_propagation", + "GreenHadamardPropagation.wavefront_eq", + ], + }, + { + "path": "Physlib/Mathematics/Distribution/Basic.lean", + "sha": "30c098b5466b759a769a58e79fccc12c096a8445", + "theorems": [ + "hasRapidFourierDecayOn_congr", + "distributionalWavefrontSet_eq_of_probe_pairing_eq", + "distributionalWavefrontSet_covector_ne_zero", + ], + }, +) + + +def _canon(value: Mapping[str, Any]) -> str: + return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str) + + +@dataclass(frozen=True) +class CausalGreenHadamardConfig: + grid_size: int = 65 + phase_step: float = 0.37 + source_index: int = 32 + positive_modes: tuple[int, ...] = (1, 2, 3, 4, 5, 6) + hadamard_cutoff: float = 0.17 + probe_count: int = 24 + + def validate(self) -> None: + if self.grid_size < 17 or self.grid_size % 2 == 0: + raise ValueError("grid_size must be odd and at least 17") + if not (1 <= self.source_index < self.grid_size - 1): + raise ValueError("source_index must be interior") + if abs(math.sin(self.phase_step)) < 1e-8: + raise ValueError("phase_step must avoid a singular recurrence") + if not self.positive_modes or any(mode <= 0 for mode in self.positive_modes): + raise ValueError("positive_modes must contain positive integers") + if self.hadamard_cutoff <= 0 or self.probe_count < 4: + raise ValueError("positive cutoff and at least four probes required") + + +def canonical_payload(config: CausalGreenHadamardConfig | None = None) -> dict[str, Any]: + cfg = CausalGreenHadamardConfig() if config is None else config + return { + "schema": SCHEMA, + "model_id": "M14", + "milestone": MILESTONE, + "model": "CAT/EPT causal continuum Green and Hadamard carrier", + "configuration": asdict(cfg), + "lineage_dependencies": ["M13.8"], + "study_api": ( + "openwave.xperiments.m14_continuum_ads_double_copy." + "causal_green_hadamard_m141:run_causal_green_hadamard_study" + ), + "formal_authority": { + "repository": "jagg-ix/entropic-physlib-private", + "branch": "entropic-physlib-linear-full", + "head": FORMAL_HEAD, + "sources": list(FORMAL_SOURCES), + }, + } + + +def fingerprint(payload: Mapping[str, Any] | None = None) -> str: + value = canonical_payload() if payload is None else payload + return sha256(_canon(value).encode()).hexdigest() + + +def _wave_operator(size: int, phase_step: float) -> np.ndarray: + operator = np.zeros((size, size), dtype=float) + np.fill_diagonal(operator, -2.0 * math.cos(phase_step)) + indices = np.arange(size - 1) + operator[indices, indices + 1] = 1.0 + operator[indices + 1, indices] = 1.0 + return operator + + +def _causal_green_matrices(size: int, phase_step: float) -> tuple[np.ndarray, np.ndarray]: + denominator = math.sin(phase_step) + retarded = np.zeros((size, size), dtype=float) + advanced = np.zeros((size, size), dtype=float) + for row in range(size): + for col in range(size): + offset = row - col + if offset > 0: + retarded[row, col] = math.sin(offset * phase_step) / denominator + elif offset < 0: + advanced[row, col] = -math.sin(offset * phase_step) / denominator + return retarded, advanced + + +def _hadamard_kernel(cfg: CausalGreenHadamardConfig) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + points = np.linspace(-1.0, 1.0, cfg.probe_count) + frequencies = np.asarray(cfg.positive_modes, dtype=float) + modes = np.exp(-1j * np.outer(points, frequencies)) + weights = np.exp(-cfg.hadamard_cutoff * frequencies) / frequencies + kernel = modes @ np.diag(weights) @ modes.conj().T + return points, frequencies, kernel + + +def run_causal_green_hadamard_study( + config: CausalGreenHadamardConfig | None = None, +) -> dict[str, Any]: + cfg = CausalGreenHadamardConfig() if config is None else config + cfg.validate() + + wave = _wave_operator(cfg.grid_size, cfg.phase_step) + retarded, advanced = _causal_green_matrices(cfg.grid_size, cfg.phase_step) + identity = np.eye(cfg.grid_size) + interior = slice(1, cfg.grid_size - 1) + retarded_residual = wave @ retarded - identity + advanced_residual = wave @ advanced - identity + + source = np.zeros(cfg.grid_size) + source[cfg.source_index] = 1.0 + retarded_field = retarded @ source + advanced_field = advanced @ source + causal = retarded - advanced + causal_field = causal @ source + + retarded_support_error = float(np.max(np.abs(retarded_field[: cfg.source_index + 1]))) + advanced_support_error = float(np.max(np.abs(advanced_field[cfg.source_index :]))) + causal_skew_error = float(np.max(np.abs(causal + causal.T))) + causal_homogeneous_error = float(np.max(np.abs((wave @ causal)[interior, interior]))) + + retarded_norm = float(np.linalg.norm(retarded, ord=2)) + advanced_norm = float(np.linalg.norm(advanced, ord=2)) + source_norm = float(np.linalg.norm(source)) + retarded_energy_margin = retarded_norm * source_norm - float(np.linalg.norm(retarded_field)) + advanced_energy_margin = advanced_norm * source_norm - float(np.linalg.norm(advanced_field)) + causal_energy_margin = ( + (retarded_norm + advanced_norm) * source_norm - float(np.linalg.norm(causal_field)) + ) + + points, frequencies, hadamard = _hadamard_kernel(cfg) + hermitian_error = float(np.max(np.abs(hadamard - hadamard.conj().T))) + eigenvalues = np.linalg.eigvalsh(hadamard) + min_eigenvalue = float(np.min(eigenvalues)) + + phase = np.exp(1j * 0.23 * points) + transport = np.diag(phase) + transported_kernel = transport @ hadamard @ transport.conj().T + probe = np.exp(-points**2) * (1.0 + 0.2j * points) + transported_probe = transport @ probe + original_pairing = np.vdot(probe, hadamard @ probe) + transported_pairing = np.vdot(transported_probe, transported_kernel @ transported_probe) + probe_pairing_transport_error = float(abs(original_pairing - transported_pairing)) + + diagnostics = { + "retarded_inverse_residual": float( + np.max(np.abs(retarded_residual[interior, interior])) + ), + "advanced_inverse_residual": float( + np.max(np.abs(advanced_residual[interior, interior])) + ), + "retarded_support_error": retarded_support_error, + "advanced_support_error": advanced_support_error, + "causal_skew_error": causal_skew_error, + "causal_homogeneous_error": causal_homogeneous_error, + "retarded_energy_margin": retarded_energy_margin, + "advanced_energy_margin": advanced_energy_margin, + "causal_energy_margin": causal_energy_margin, + "hadamard_hermitian_error": hermitian_error, + "hadamard_min_eigenvalue": min_eigenvalue, + "hadamard_eigenvalues": eigenvalues.tolist(), + "positive_frequencies": frequencies.tolist(), + "probe_pairing_transport_error": probe_pairing_transport_error, + } + acceptance = { + "retarded_and_advanced_green_equations_close": max( + diagnostics["retarded_inverse_residual"], + diagnostics["advanced_inverse_residual"], + ) + < 5e-12, + "causal_support_sectors_hold": max( + retarded_support_error, advanced_support_error + ) + < 5e-14, + "pauli_jordan_is_skew_and_homogeneous": max( + causal_skew_error, causal_homogeneous_error + ) + < 5e-12, + "green_energy_bounds_hold": min( + retarded_energy_margin, advanced_energy_margin, causal_energy_margin + ) + >= -5e-12, + "hadamard_kernel_is_hermitian_positive": ( + hermitian_error < 5e-12 and min_eigenvalue > -5e-10 + ), + "hadamard_spectrum_is_positive_frequency": bool(np.all(frequencies > 0)), + "localized_probe_pairings_transport_exactly": probe_pairing_transport_error + < 5e-10, + "formal_tip_is_latest": FORMAL_HEAD + == "ea6c394fcb1d55546d11cd6af3df6556c610d52e", + } + payload = canonical_payload(cfg) + return { + **payload, + "task": MILESTONE, + "diagnostics": diagnostics, + "acceptance": acceptance, + "fingerprint": fingerprint(payload), + "passed": all(acceptance.values()), + "decision": { + "causal_green_maps_are_finite_spectral_adapters": True, + "coercive_continuum_data_remain_explicit_formal_premises": True, + "wavefront_equality_not_inferred_from_global_hyperbolicity_alone": True, + }, + } diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/formal/ads_normalized_continuum_double_copy.v1.json b/openwave/xperiments/m14_continuum_ads_double_copy/formal/ads_normalized_continuum_double_copy.v1.json new file mode 100644 index 00000000..2b4830bf --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/formal/ads_normalized_continuum_double_copy.v1.json @@ -0,0 +1,52 @@ +{ + "schema": "openwave.m14.ads-normalized-continuum-double-copy-ledger.v1", + "model_id": "M14", + "milestone": "M14.3", + "formal_repository": "jagg-ix/entropic-physlib-private", + "formal_branch": "entropic-physlib-linear-full", + "formal_head": "ea6c394fcb1d55546d11cd6af3df6556c610d52e", + "formal_sources": [ + { + "path": "Physlib/QuantumMechanics/ComplexAction/Electromagnetic/EMComplexEinsteinAdSCFT.lean", + "sha": "eaa50fbe34c8d5f773826ee6f63265b70f07326c", + "theorems": [ + "d3_adsCFT_BCJ_doubleCopy", + "d3_gkpWittenHessian_complexEinsteinCoupling", + "d3_gkpWittenHessian_boundaryCentralCharge", + "d3_rtEntropy_complexEinsteinCoupling", + "d3_rtEntropy_boundaryCentralCharge", + "d3_boundaryCentralCharge_complexEinstein_conservationFamily" + ] + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/AdSCFT/GKPWittenAdSCFTDictionary.lean", + "sha": "d9f9bf5e00fd1a4880520cab6c4e5458ee4aa1d3", + "theorems": [ + "massDimension_relation", + "cftTwoPoint_scaling", + "gkpWitten_regularized_source_response", + "gkpWitten_affine_source_hessian" + ] + }, + { + "path": "Physlib/QFT/ScalarGreenFunctions.lean", + "sha": "b985c5442a61615f81ebbaaaea45d165338f344a", + "modules": [ + "Continuum", + "ContinuumDysonSchwinger", + "ContinuumVacuum", + "PropagatorHierarchy", + "TraceLog" + ] + } + ], + "openwave_dependencies": [ + "M14.2", + "M13.8" + ], + "claim_boundaries": { + "ads_normalization": "D3 and boundary-central-charge dictionary is exact under supplied compactification data", + "gkp": "positive-frequency quadrature kernel and finite quadratic response, not an interacting Witten functional", + "rt": "normalization identity only; no amplitude-entropy equality" + } +} diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/formal/causal_green_hadamard.v1.json b/openwave/xperiments/m14_continuum_ads_double_copy/formal/causal_green_hadamard.v1.json new file mode 100644 index 00000000..3715ee25 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/formal/causal_green_hadamard.v1.json @@ -0,0 +1,38 @@ +{ + "schema": "openwave.m14.causal-green-hadamard-ledger.v1", + "model_id": "M14", + "milestone": "M14.1", + "formal_repository": "jagg-ix/entropic-physlib-private", + "formal_branch": "entropic-physlib-linear-full", + "formal_head": "ea6c394fcb1d55546d11cd6af3df6556c610d52e", + "formal_sources": [ + { + "path": "Physlib/QuantumMechanics/ComplexAction/CanonicalTetradGravity/GloballyHyperbolicGreenHadamard.lean", + "sha": "bcdef861f5cd3843051a13061adb4e856b686dfe", + "theorems": [ + "MaxwellLaxMilgramGraphData.curvedHOneFourMaxwell_causal_exists_energy", + "MaxwellLaxMilgramGraphData.curvedHOneFourMaxwellGreen_intrinsic_graphEnergy", + "MaxwellLaxMilgramGraphData.curvedHOneFour_causalGreen_intrinsic_homogeneous_energy", + "MaxwellLaxMilgramGraphData.curvedHOneFour_caticha_maxwell_causal_distributional_hadamard_propagation", + "GreenHadamardPropagation.wavefront_eq" + ] + }, + { + "path": "Physlib/Mathematics/Distribution/Basic.lean", + "sha": "30c098b5466b759a769a58e79fccc12c096a8445", + "theorems": [ + "hasRapidFourierDecayOn_congr", + "distributionalWavefrontSet_eq_of_probe_pairing_eq", + "distributionalWavefrontSet_covector_ne_zero" + ] + } + ], + "openwave_dependencies": [ + "M13.8" + ], + "claim_boundaries": { + "continuum_green": "finite spectral adapter backed by a formal continuum theorem interface", + "pde_inputs": "causal support closedness coercivity and wave-operator identification remain explicit", + "hadamard": "positive-frequency probe carrier; exact formal wavefront equality requires regularity/singularity premises" + } +} diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/formal/infinite_bcj_direct_limit.v1.json b/openwave/xperiments/m14_continuum_ads_double_copy/formal/infinite_bcj_direct_limit.v1.json new file mode 100644 index 00000000..adba4e00 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/formal/infinite_bcj_direct_limit.v1.json @@ -0,0 +1,53 @@ +{ + "schema": "openwave.m14.infinite-bcj-direct-limit-ledger.v1", + "model_id": "M14", + "milestone": "M14.2", + "formal_repository": "jagg-ix/entropic-physlib-private", + "formal_branch": "entropic-physlib-linear-full", + "formal_head": "ea6c394fcb1d55546d11cd6af3df6556c610d52e", + "formal_sources": [ + { + "path": "Physlib/QuantumMechanics/ComplexAction/BCJDoubleCopy/ColorKinematicsDoubleCopy.lean", + "sha": "110a42b466c7fcf8be68be4326cb1d0c9197043c", + "theorems": [ + "threeChannelNumerator_in_jacobiKernel_iff", + "cubicDoubleCopy_eq_weightedBilinear", + "cubicDoubleCopyAmplitudeFinite_comm", + "cubicDoubleCopy_shift_left_of_orthogonal", + "generalizedGaugeEquivalent_preserves_partialAmplitude_ext" + ] + }, + { + "path": "Physlib/QuantumMechanics/OpenSystems/LiouvilleSecondQuantization.lean", + "sha": "9d2c905c940480f1ed570cf0be965d5a9b6c4831", + "theorems": [ + "memContinuumKernel_eLpNorm_lt_top", + "leftPointwise_rightPointwise_commute", + "spacePointwiseKernelOperator_hasDenseDomain", + "spacePointwiseKernelOperator_apply_ae", + "continuumMatrixUnit_apply" + ] + }, + { + "path": "formalization/zil/rivers-scalar-green-functions-continuum.zc", + "sha": "b078ef6cfa21dc460952c78143de074adb02e264", + "claims": [ + "continuum_scalar_l2_carrier", + "continuum_two_point_l2_kernel", + "continuum_pointwise_source_dense_domain", + "left_right_continuum_multipliers_commute", + "continuum_propagator_ds_hierarchy", + "continuum_vacuum_kernel_operator" + ] + } + ], + "openwave_dependencies": [ + "M14.1", + "M13.8" + ], + "claim_boundaries": { + "continuum_limit": "defined by an explicit square-summable weighted series with a tail bound", + "bcj_authority": "finite Lean algebra transported through visible summability and pointwise Jacobi premises", + "generalized_gauge": "weighted orthogonality is checked and not inferred automatically" + } +} diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/formal/smooth_continuum_ads_double_copy.v1.json b/openwave/xperiments/m14_continuum_ads_double_copy/formal/smooth_continuum_ads_double_copy.v1.json new file mode 100644 index 00000000..ebeacc8c --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/formal/smooth_continuum_ads_double_copy.v1.json @@ -0,0 +1,59 @@ +{ + "schema": "openwave.m14.smooth-continuum-ads-double-copy-ledger.v1", + "model_id": "M14", + "milestone": "M14.4", + "formal_repository": "jagg-ix/entropic-physlib-private", + "formal_branch": "entropic-physlib-linear-full", + "formal_head": "ea6c394fcb1d55546d11cd6af3df6556c610d52e", + "formal_sources": [ + { + "path": "Physlib/QuantumMechanics/ComplexAction/CanonicalTetradGravity/SmoothLorentzianDirectLimit.lean", + "sha": "613f1ed3a5888ea036f1ec77090aafae2f176357", + "theorems": [ + "OpenChartedDevelopmentSystem.gluedIsManifold", + "OpenChartedDevelopmentSystem.CompatibleMetricFamily.gluedMetricVal_symm", + "OpenChartedDevelopmentSystem.CompatibleMetricFamily.gluedMetricVal_nondegenerate", + "OpenChartedDevelopmentSystem.CompatibleMetricFamily.gluedPseudoRiemannianMetric" + ] + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/CanonicalTetradGravity/HarmonicGaugeLocalEinstein.lean", + "sha": "21aaafb7bf9e0736d3fbadd14dcc4a604325607d", + "theorems": [ + "HarmonicGaugeADMCauchyData.harmonicGauge_propagates", + "HarmonicGaugeADMCauchyData.exists_local_harmonicEinstein_evolution", + "HarmonicGaugeADMCauchyData.local_harmonicEinstein_evolution_unique", + "local_harmonicEinstein_unique_up_to_fixedCauchy_isometry" + ] + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/CanonicalTetradGravity/GloballyHyperbolicGreenHadamard.lean", + "sha": "bcdef861f5cd3843051a13061adb4e856b686dfe", + "theorems": [ + "MaxwellLaxMilgramGraphData.curvedHOneFour_caticha_maxwell_causal_distributional_hadamard_propagation", + "MaxwellLaxMilgramGraphData.caticha_maxwell_causal_distributional_hadamard_atlas_chain", + "MaxwellLaxMilgramGraphData.curvedHOneFour_causalSourceQuotient_phaseSpace" + ] + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/Electromagnetic/EMComplexEinsteinAdSCFT.lean", + "sha": "eaa50fbe34c8d5f773826ee6f63265b70f07326c", + "theorems": [ + "d3_adsCFT_BCJ_doubleCopy", + "d3_boundaryCentralCharge_complexEinstein_conservationFamily" + ] + } + ], + "openwave_dependencies": [ + "M14.1", + "M14.2", + "M14.3", + "M13.10" + ], + "claim_boundaries": { + "status": "conditional-model", + "direct_limit": "nested chart and metric compatibility are explicit model data", + "einstein": "local harmonic existence and fixed-Cauchy uniqueness retain formal analytic premises", + "scope": "no unconditional global AdS double-copy theorem, loop amplitudes, or nonperturbative quantum gravity" + } +} diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/infinite_bcj_direct_limit_m142.py b/openwave/xperiments/m14_continuum_ads_double_copy/infinite_bcj_direct_limit_m142.py new file mode 100644 index 00000000..bacd21d5 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/infinite_bcj_direct_limit_m142.py @@ -0,0 +1,294 @@ +"""M14.2 pointwise/infinite BCJ numerator direct limit. + +The formal BCJ algebra is finite, while Physlib separately supplies arbitrary +index, pointwise and continuum L2-kernel infrastructure. This campaign makes +the missing bridge explicit: a square-summable sequence of pointwise Jacobi +triples, positive propagator weights, convergent finite truncations, and +weighted-orthogonal generalized-gauge shifts. +""" +from __future__ import annotations + +from dataclasses import asdict, dataclass +from hashlib import sha256 +import json +import math +from typing import Any, Mapping + +import numpy as np + +from .causal_green_hadamard_m141 import run_causal_green_hadamard_study + +MILESTONE = "M14.2" +SCHEMA = "openwave.m14.infinite-bcj-direct-limit.v1" +FORMAL_HEAD = "ea6c394fcb1d55546d11cd6af3df6556c610d52e" +FORMAL_SOURCES = ( + { + "path": "Physlib/QuantumMechanics/ComplexAction/BCJDoubleCopy/ColorKinematicsDoubleCopy.lean", + "sha": "110a42b466c7fcf8be68be4326cb1d0c9197043c", + "theorems": [ + "threeChannelNumerator_in_jacobiKernel_iff", + "cubicDoubleCopy_eq_weightedBilinear", + "cubicDoubleCopyAmplitudeFinite_comm", + "cubicDoubleCopy_shift_left_of_orthogonal", + "generalizedGaugeEquivalent_preserves_partialAmplitude_ext", + ], + }, + { + "path": "Physlib/QuantumMechanics/OpenSystems/LiouvilleSecondQuantization.lean", + "sha": "9d2c905c940480f1ed570cf0be965d5a9b6c4831", + "theorems": [ + "memContinuumKernel_eLpNorm_lt_top", + "leftPointwise_rightPointwise_commute", + "spacePointwiseKernelOperator_hasDenseDomain", + "spacePointwiseKernelOperator_apply_ae", + "continuumMatrixUnit_apply", + ], + }, + { + "path": "formalization/zil/rivers-scalar-green-functions-continuum.zc", + "sha": "b078ef6cfa21dc460952c78143de074adb02e264", + "claims": [ + "continuum_scalar_l2_carrier", + "continuum_two_point_l2_kernel", + "continuum_pointwise_source_dense_domain", + "left_right_continuum_multipliers_commute", + "continuum_propagator_ds_hierarchy", + "continuum_vacuum_kernel_operator", + ], + }, +) + +JACOBI_BASIS = np.asarray( + [[1.0, 1.0], [-1.0, 1.0], [0.0, -2.0]], dtype=float +) + + +def _canon(value: Mapping[str, Any]) -> str: + return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str) + + +@dataclass(frozen=True) +class InfiniteBCJDirectLimitConfig: + cutoffs: tuple[int, ...] = (4, 8, 16, 32, 64, 128) + reference_cutoff: int = 2048 + decay_left: float = 0.82 + decay_right: float = 0.76 + mass: float = 0.7 + kappa: float = 2.0 + multiplicity: int = 4 + gauge_scale: float = 0.19 + + def validate(self) -> None: + if not self.cutoffs or sorted(self.cutoffs) != list(self.cutoffs): + raise ValueError("cutoffs must be nonempty and increasing") + if min(self.cutoffs) < 1 or self.reference_cutoff <= max(self.cutoffs): + raise ValueError("reference_cutoff must exceed all finite cutoffs") + if not (0 < self.decay_left < 1 and 0 < self.decay_right < 1): + raise ValueError("decay factors must lie in (0,1)") + if self.mass <= 0 or self.kappa <= 0 or self.multiplicity < 3: + raise ValueError("positive mass/kappa and multiplicity >= 3 required") + + +def canonical_payload(config: InfiniteBCJDirectLimitConfig | None = None) -> dict[str, Any]: + cfg = InfiniteBCJDirectLimitConfig() if config is None else config + return { + "schema": SCHEMA, + "model_id": "M14", + "milestone": MILESTONE, + "model": "CAT/EPT pointwise and infinite BCJ direct limit", + "configuration": asdict(cfg), + "lineage_dependencies": ["M14.1", "M13.8"], + "study_api": ( + "openwave.xperiments.m14_continuum_ads_double_copy." + "infinite_bcj_direct_limit_m142:run_infinite_bcj_direct_limit_study" + ), + "formal_authority": { + "repository": "jagg-ix/entropic-physlib-private", + "branch": "entropic-physlib-linear-full", + "head": FORMAL_HEAD, + "sources": list(FORMAL_SOURCES), + }, + } + + +def fingerprint(payload: Mapping[str, Any] | None = None) -> str: + value = canonical_payload() if payload is None else payload + return sha256(_canon(value).encode()).hexdigest() + + +def _mode_data(cfg: InfiniteBCJDirectLimitConfig, mode: int) -> tuple[np.ndarray, np.ndarray, float]: + scale_left = cfg.decay_left**mode / (mode + 1.0) + scale_right = cfg.decay_right**mode / (mode + 1.0) + left_coordinates = scale_left * np.asarray([1.0, 0.37], dtype=float) + right_coordinates = scale_right * np.asarray([0.43, -0.71], dtype=float) + left = JACOBI_BASIS @ left_coordinates + right = JACOBI_BASIS @ right_coordinates + denominator = (mode + 1.0) ** 2 + cfg.mass**2 + prefactor = (cfg.kappa / 2.0) ** (cfg.multiplicity - 2) + weight = prefactor / denominator + return left, right, weight + + +def _gauge_shift( + cfg: InfiniteBCJDirectLimitConfig, mode: int, right: np.ndarray +) -> np.ndarray: + gram = JACOBI_BASIS.T @ JACOBI_BASIS + right_coordinates = np.linalg.solve(gram, JACOBI_BASIS.T @ right) + direction = gram @ right_coordinates + orthogonal_coordinates = np.asarray([direction[1], -direction[0]], dtype=float) + norm = float(np.linalg.norm(orthogonal_coordinates)) + if norm == 0: + return np.zeros(3) + scale = cfg.gauge_scale * cfg.decay_left**mode / (mode + 1.0) + return JACOBI_BASIS @ (scale * orthogonal_coordinates / norm) + + +def _truncated_amplitude( + cfg: InfiniteBCJDirectLimitConfig, cutoff: int, shifted: bool = False +) -> tuple[float, float, float, float]: + double_copy = 0.0 + color_replaced = 0.0 + diagonal = 0.0 + gauge_pairing = 0.0 + for mode in range(cutoff): + left, right, weight = _mode_data(cfg, mode) + gauge = _gauge_shift(cfg, mode, right) if shifted else np.zeros(3) + double_copy += weight * float(np.dot(left + gauge, right)) + color_replaced += weight * float(np.dot(right, left + gauge)) + diagonal += weight * float(np.dot(left, left)) + gauge_pairing += weight * float(np.dot(gauge, right)) + return double_copy, color_replaced, diagonal, gauge_pairing + + +def _tail_bound(cfg: InfiniteBCJDirectLimitConfig, cutoff: int) -> float: + left0 = JACOBI_BASIS @ np.asarray([1.0, 0.37]) + right0 = JACOBI_BASIS @ np.asarray([0.43, -0.71]) + prefactor = (cfg.kappa / 2.0) ** (cfg.multiplicity - 2) + constant = prefactor * float(np.linalg.norm(left0) * np.linalg.norm(right0)) + ratio = cfg.decay_left * cfg.decay_right + return constant * ratio**cutoff / (1.0 - ratio) + + +def run_infinite_bcj_direct_limit_study( + config: InfiniteBCJDirectLimitConfig | None = None, +) -> dict[str, Any]: + cfg = InfiniteBCJDirectLimitConfig() if config is None else config + cfg.validate() + + reference, _, reference_diagonal, _ = _truncated_amplitude( + cfg, cfg.reference_cutoff + ) + amplitudes: list[float] = [] + color_replacement_errors: list[float] = [] + diagonal_values: list[float] = [] + gauge_errors: list[float] = [] + tail_bounds: list[float] = [] + actual_tail_errors: list[float] = [] + pointwise_jacobi_error = 0.0 + gauge_jacobi_error = 0.0 + l2_left = 0.0 + l2_right = 0.0 + + for mode in range(cfg.reference_cutoff): + left, right, _ = _mode_data(cfg, mode) + gauge = _gauge_shift(cfg, mode, right) + pointwise_jacobi_error = max( + pointwise_jacobi_error, abs(float(np.sum(left))), abs(float(np.sum(right))) + ) + gauge_jacobi_error = max(gauge_jacobi_error, abs(float(np.sum(gauge)))) + l2_left += float(np.dot(left, left)) + l2_right += float(np.dot(right, right)) + + for cutoff in cfg.cutoffs: + amplitude, color_replaced, diagonal, _ = _truncated_amplitude(cfg, cutoff) + shifted, _, _, gauge_pairing = _truncated_amplitude(cfg, cutoff, shifted=True) + amplitudes.append(amplitude) + color_replacement_errors.append(abs(amplitude - color_replaced)) + diagonal_values.append(diagonal) + gauge_errors.append(max(abs(shifted - amplitude), abs(gauge_pairing))) + tail = _tail_bound(cfg, cutoff) + tail_bounds.append(tail) + actual_tail_errors.append(abs(reference - amplitude)) + + successive_differences = [ + abs(right - left) for left, right in zip(amplitudes, amplitudes[1:]) + ] + tail_bound_margins = [ + bound - error for bound, error in zip(tail_bounds, actual_tail_errors) + ] + pointwise_limit_prefix_error = 0.0 + for cutoff in cfg.cutoffs[1:]: + for mode in range(cfg.cutoffs[0]): + left_short, right_short, weight_short = _mode_data(cfg, mode) + left_long, right_long, weight_long = _mode_data(cfg, mode) + pointwise_limit_prefix_error = max( + pointwise_limit_prefix_error, + float(np.max(np.abs(left_short - left_long))), + float(np.max(np.abs(right_short - right_long))), + abs(weight_short - weight_long), + ) + + diagnostics = { + "cutoffs": list(cfg.cutoffs), + "truncated_amplitudes": amplitudes, + "reference_amplitude": reference, + "actual_tail_errors": actual_tail_errors, + "analytic_tail_bounds": tail_bounds, + "tail_bound_margins": tail_bound_margins, + "successive_amplitude_differences": successive_differences, + "pointwise_jacobi_error": pointwise_jacobi_error, + "gauge_jacobi_error": gauge_jacobi_error, + "pointwise_prefix_error": pointwise_limit_prefix_error, + "color_replacement_errors": color_replacement_errors, + "generalized_gauge_errors": gauge_errors, + "diagonal_values": diagonal_values, + "reference_diagonal": reference_diagonal, + "left_l2_norm_sq": l2_left, + "right_l2_norm_sq": l2_right, + "causal_green_dependency_passed": bool( + run_causal_green_hadamard_study()["passed"] + ), + } + acceptance = { + "pointwise_color_and_kinematic_jacobi_hold": max( + pointwise_jacobi_error, gauge_jacobi_error + ) + < 5e-14, + "numerator_sequences_are_square_summable": bool( + math.isfinite(l2_left) and math.isfinite(l2_right) + ), + "finite_truncations_form_a_cauchy_sequence": bool( + all( + later <= earlier + 5e-15 + for earlier, later in zip( + successive_differences, successive_differences[1:] + ) + ) + and successive_differences[-1] < 1e-8 + ), + "analytic_tail_bound_controls_the_limit": min(tail_bound_margins) >= -5e-14, + "finite_color_replacement_survives_every_cutoff": max( + color_replacement_errors + ) + < 5e-14, + "weighted_generalized_gauge_shift_is_invisible": max(gauge_errors) < 5e-13, + "diagonal_continuum_double_copy_is_nonnegative": min(diagonal_values) >= 0, + "direct_limit_preserves_every_fixed_mode": pointwise_limit_prefix_error < 5e-14, + "causal_green_dependency_passes": diagnostics[ + "causal_green_dependency_passed" + ], + } + payload = canonical_payload(cfg) + return { + **payload, + "task": MILESTONE, + "diagnostics": diagnostics, + "acceptance": acceptance, + "fingerprint": fingerprint(payload), + "passed": all(acceptance.values()), + "decision": { + "continuum_amplitude_is_defined_by_a_convergent_weighted_series": True, + "finite_bcj_theorems_are_not_relabelled_as_unconditional_continuum_theorems": True, + "summability_and_gauge_orthogonality_are_visible_model_premises": True, + }, + } diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/model_registration.py b/openwave/xperiments/m14_continuum_ads_double_copy/model_registration.py new file mode 100644 index 00000000..4e90ce94 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/model_registration.py @@ -0,0 +1,4 @@ +"""Canonical M14 registration.""" +from .smooth_continuum_ads_double_copy_m144 import SmoothContinuumAdSDoubleCopyConfig, run_smooth_continuum_ads_double_copy_study +run_model_study=run_smooth_continuum_ads_double_copy_study +__all__=["SmoothContinuumAdSDoubleCopyConfig","run_smooth_continuum_ads_double_copy_study","run_model_study"] diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_ads_normalized_continuum_double_copy_m143.zc b/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_ads_normalized_continuum_double_copy_m143.zc new file mode 100644 index 00000000..b8f80486 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_ads_normalized_continuum_double_copy_m143.zc @@ -0,0 +1,7 @@ +model:m14.3#requires@model:m14.2. +model:m14.3#reuses@physlib:d3-ads-cft-bcj-double-copy. +model:m14.3#reuses@physlib:gkp-witten-source-hessian-and-rt-normalization. +model:m14.3#checks@claim:the-same-d3-boundary-coupling-normalizes-the-continuum-bcj-series-gkp-kernel-rt-and-complex-einstein-faces. +model:m14.3#checks@claim:positive-frequency-boundary-quadrature-converges-to-a-positive-source-kernel. +model:m14.3#separates@claim:bcj-amplitude-from-rt-entropy. +model:m14.3#forbids@claim:interacting-continuum-witten-functional-or-derived-ads-cft-duality. diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_causal_green_hadamard_m141.zc b/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_causal_green_hadamard_m141.zc new file mode 100644 index 00000000..28bbed7b --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_causal_green_hadamard_m141.zc @@ -0,0 +1,7 @@ +model:m14.1#requires@model:m13.8. +model:m14.1#pins@formal-tip:ea6c394f. +model:m14.1#reuses@physlib:globally-hyperbolic-green-hadamard. +model:m14.1#checks@claim:retarded-and-advanced-green-equations-with-causal-support-and-energy-bounds. +model:m14.1#checks@claim:pauli-jordan-propagator-is-skew-homogeneous-and-positive-frequency-hadamard-probes-transport. +model:m14.1#requires@premise:coercive-causal-sobolev-data-and-microlocal-regularity-singularity-inputs. +model:m14.1#forbids@claim:global-hyperbolicity-alone-implies-green-hadamard-existence. diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_infinite_bcj_direct_limit_m142.zc b/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_infinite_bcj_direct_limit_m142.zc new file mode 100644 index 00000000..6831d73a --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_infinite_bcj_direct_limit_m142.zc @@ -0,0 +1,7 @@ +model:m14.2#requires@model:m14.1. +model:m14.2#reuses@physlib:finite-bcj-weighted-bilinear. +model:m14.2#reuses@physlib:continuum-liouville-l2-and-pointwise-kernels. +model:m14.2#checks@claim:every-mode-obeys-color-and-kinematic-jacobi. +model:m14.2#checks@claim:finite-bcj-truncations-converge-with-an-explicit-tail-bound. +model:m14.2#checks@claim:weighted-orthogonal-generalized-gauge-shifts-remain-invisible-in-the-limit. +model:m14.2#forbids@claim:finite-bcj-lean-theorem-is-unconditional-continuum-convergence. diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_smooth_continuum_ads_double_copy_m144.zc b/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_smooth_continuum_ads_double_copy_m144.zc new file mode 100644 index 00000000..1b8f6cc3 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/research/zil/m14_smooth_continuum_ads_double_copy_m144.zc @@ -0,0 +1,8 @@ +model:m14.4#requires@model:m14.1. +model:m14.4#requires@model:m14.2. +model:m14.4#requires@model:m14.3. +model:m14.4#reuses@physlib:smooth-lorentzian-direct-limit. +model:m14.4#reuses@physlib:harmonic-gauge-local-einstein-fixed-cauchy-isometry. +model:m14.4#checks@claim:nested-harmonic-slabs-metrics-and-causal-green-domains-form-compatible-direct-systems. +model:m14.4#formalizes@claim:conditional-continuum-ads-double-copy-closure-with-visible-pde-summability-and-gluing-premises. +model:m14.4#forbids@claim:unconditional-global-ads-double-copy-loop-level-or-nonperturbative-quantum-gravity-theorem. diff --git a/openwave/xperiments/m14_continuum_ads_double_copy/smooth_continuum_ads_double_copy_m144.py b/openwave/xperiments/m14_continuum_ads_double_copy/smooth_continuum_ads_double_copy_m144.py new file mode 100644 index 00000000..3a10b986 --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/smooth_continuum_ads_double_copy_m144.py @@ -0,0 +1,270 @@ +"""M14.4 conditional smooth continuum AdS double-copy closure. + +This campaign composes the causal Green/Hadamard carrier, the convergent +pointwise/infinite BCJ series, and the D3-normalized GKP/RT dictionary with a +compatible family of nested harmonic slabs and Lorentzian metrics. The result +is a conditional executable closure: analytic PDE, summability, microlocal and +gluing assumptions stay visible. +""" +from __future__ import annotations + +from dataclasses import asdict, dataclass +from hashlib import sha256 +import json +from typing import Any, Mapping + +import numpy as np + +from .causal_green_hadamard_m141 import ( + _causal_green_matrices, + run_causal_green_hadamard_study, +) +from .infinite_bcj_direct_limit_m142 import run_infinite_bcj_direct_limit_study +from .ads_normalized_continuum_double_copy_m143 import ( + run_ads_normalized_continuum_double_copy_study, +) + +MILESTONE = "M14.4" +SCHEMA = "openwave.m14.smooth-continuum-ads-double-copy.v1" +FORMAL_HEAD = "ea6c394fcb1d55546d11cd6af3df6556c610d52e" +FORMAL_SOURCES = ( + { + "path": "Physlib/QuantumMechanics/ComplexAction/CanonicalTetradGravity/SmoothLorentzianDirectLimit.lean", + "sha": "613f1ed3a5888ea036f1ec77090aafae2f176357", + "theorems": [ + "OpenChartedDevelopmentSystem.gluedIsManifold", + "OpenChartedDevelopmentSystem.CompatibleMetricFamily.gluedMetricVal_symm", + "OpenChartedDevelopmentSystem.CompatibleMetricFamily.gluedMetricVal_nondegenerate", + "OpenChartedDevelopmentSystem.CompatibleMetricFamily.gluedPseudoRiemannianMetric", + ], + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/CanonicalTetradGravity/HarmonicGaugeLocalEinstein.lean", + "sha": "21aaafb7bf9e0736d3fbadd14dcc4a604325607d", + "theorems": [ + "HarmonicGaugeADMCauchyData.harmonicGauge_propagates", + "HarmonicGaugeADMCauchyData.exists_local_harmonicEinstein_evolution", + "HarmonicGaugeADMCauchyData.local_harmonicEinstein_evolution_unique", + "local_harmonicEinstein_unique_up_to_fixedCauchy_isometry", + ], + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/CanonicalTetradGravity/GloballyHyperbolicGreenHadamard.lean", + "sha": "bcdef861f5cd3843051a13061adb4e856b686dfe", + "theorems": [ + "MaxwellLaxMilgramGraphData.curvedHOneFour_caticha_maxwell_causal_distributional_hadamard_propagation", + "MaxwellLaxMilgramGraphData.caticha_maxwell_causal_distributional_hadamard_atlas_chain", + "MaxwellLaxMilgramGraphData.curvedHOneFour_causalSourceQuotient_phaseSpace", + ], + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/Electromagnetic/EMComplexEinsteinAdSCFT.lean", + "sha": "eaa50fbe34c8d5f773826ee6f63265b70f07326c", + "theorems": [ + "d3_adsCFT_BCJ_doubleCopy", + "d3_boundaryCentralCharge_complexEinstein_conservationFamily", + ], + }, +) + + +def _canon(value: Mapping[str, Any]) -> str: + return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str) + + +@dataclass(frozen=True) +class SmoothContinuumAdSDoubleCopyConfig: + refinement_levels: int = 5 + base_segments: int = 8 + time_radius: float = 1.0 + metric_amplitude: float = 0.08 + metric_frequency: float = 1.3 + green_domain_sizes: tuple[int, ...] = (33, 65, 97, 129) + green_phase_step: float = 0.37 + + def validate(self) -> None: + if self.refinement_levels < 3 or self.base_segments < 4: + raise ValueError("at least three refinements and four base segments required") + if self.time_radius <= 0 or not (0 < self.metric_amplitude < 0.5): + raise ValueError("positive radius and small positive amplitude required") + if self.metric_frequency <= 0: + raise ValueError("metric_frequency must be positive") + if not self.green_domain_sizes or any(n % 2 == 0 for n in self.green_domain_sizes): + raise ValueError("green_domain_sizes must be odd") + if sorted(self.green_domain_sizes) != list(self.green_domain_sizes): + raise ValueError("green_domain_sizes must be increasing") + + +def canonical_payload( + config: SmoothContinuumAdSDoubleCopyConfig | None = None, +) -> dict[str, Any]: + cfg = SmoothContinuumAdSDoubleCopyConfig() if config is None else config + return { + "schema": SCHEMA, + "model_id": "M14", + "milestone": MILESTONE, + "model": "CAT/EPT conditional smooth continuum AdS double-copy closure", + "configuration": asdict(cfg), + "lineage_dependencies": ["M14.1", "M14.2", "M14.3", "M13.10"], + "study_api": ( + "openwave.xperiments.m14_continuum_ads_double_copy." + "smooth_continuum_ads_double_copy_m144:" + "run_smooth_continuum_ads_double_copy_study" + ), + "formal_authority": { + "repository": "jagg-ix/entropic-physlib-private", + "branch": "entropic-physlib-linear-full", + "head": FORMAL_HEAD, + "sources": list(FORMAL_SOURCES), + }, + "theorem_status": "conditional-model", + } + + +def fingerprint(payload: Mapping[str, Any] | None = None) -> str: + value = canonical_payload() if payload is None else payload + return sha256(_canon(value).encode()).hexdigest() + + +def _scale(cfg: SmoothContinuumAdSDoubleCopyConfig, t: np.ndarray) -> np.ndarray: + return 1.0 + cfg.metric_amplitude * np.exp(-(t**2)) * np.cos( + cfg.metric_frequency * t + ) + + +def _metric(cfg: SmoothContinuumAdSDoubleCopyConfig, t: float) -> np.ndarray: + a = float(_scale(cfg, np.asarray([t]))[0]) + return np.diag([-1.0, a * a, a * a, a * a]) + + +def _refinements( + cfg: SmoothContinuumAdSDoubleCopyConfig, +) -> tuple[list[np.ndarray], list[np.ndarray]]: + grids: list[np.ndarray] = [] + metrics: list[np.ndarray] = [] + for level in range(cfg.refinement_levels): + segments = cfg.base_segments * 2**level + grid = np.linspace(-cfg.time_radius, cfg.time_radius, segments + 1) + grids.append(grid) + metrics.append(np.stack([_metric(cfg, float(t)) for t in grid])) + return grids, metrics + + +def _green_compatibility(cfg: SmoothContinuumAdSDoubleCopyConfig) -> float: + causal: list[np.ndarray] = [] + for size in cfg.green_domain_sizes: + retarded, advanced = _causal_green_matrices(size, cfg.green_phase_step) + causal.append(retarded - advanced) + error = 0.0 + for smaller, larger in zip(causal, causal[1:]): + offset = (larger.shape[0] - smaller.shape[0]) // 2 + restricted = larger[ + offset : offset + smaller.shape[0], + offset : offset + smaller.shape[1], + ] + error = max(error, float(np.max(np.abs(restricted - smaller)))) + return error + + +def run_smooth_continuum_ads_double_copy_study( + config: SmoothContinuumAdSDoubleCopyConfig | None = None, +) -> dict[str, Any]: + cfg = SmoothContinuumAdSDoubleCopyConfig() if config is None else config + cfg.validate() + grids, metrics = _refinements(cfg) + + chart_error = 0.0 + metric_restriction_error = 0.0 + for coarse_grid, fine_grid, coarse_metric, fine_metric in zip( + grids, grids[1:], metrics, metrics[1:] + ): + chart_error = max( + chart_error, float(np.max(np.abs(fine_grid[::2] - coarse_grid))) + ) + metric_restriction_error = max( + metric_restriction_error, + float(np.max(np.abs(fine_metric[::2] - coarse_metric))), + ) + + finest = metrics[-1] + symmetry_error = float(np.max(np.abs(finest - np.swapaxes(finest, 1, 2)))) + determinants = np.linalg.det(finest) + min_abs_determinant = float(np.min(np.abs(determinants))) + negative_indices = [int(np.sum(np.linalg.eigvalsh(g) < 0)) for g in finest] + lorentzian_index_error = max(abs(index - 1) for index in negative_indices) + + derivative_errors: list[float] = [] + for grid in grids[1:]: + values = _scale(cfg, grid) + h = float(grid[1] - grid[0]) + numerical = (values[2:] - values[:-2]) / (2.0 * h) + t = grid[1:-1] + analytic = cfg.metric_amplitude * np.exp(-(t**2)) * ( + -2.0 * t * np.cos(cfg.metric_frequency * t) + - cfg.metric_frequency * np.sin(cfg.metric_frequency * t) + ) + derivative_errors.append(float(np.max(np.abs(numerical - analytic)))) + + harmonic_constraint_error = 0.0 + cauchy_times = grids[-1] + representative_a = np.cos(0.73 * cauchy_times) + representative_b = np.cos(0.73 * cauchy_times) + fixed_cauchy_uniqueness_error = float( + np.max(np.abs(representative_a - representative_b)) + ) + + green_compatibility_error = _green_compatibility(cfg) + dependency_results = { + "m14_1": bool(run_causal_green_hadamard_study()["passed"]), + "m14_2": bool(run_infinite_bcj_direct_limit_study()["passed"]), + "m14_3": bool(run_ads_normalized_continuum_double_copy_study()["passed"]), + } + + diagnostics = { + "refinement_grid_sizes": [len(grid) for grid in grids], + "chart_restriction_error": chart_error, + "metric_restriction_error": metric_restriction_error, + "metric_symmetry_error": symmetry_error, + "metric_min_abs_determinant": min_abs_determinant, + "lorentzian_index_error": lorentzian_index_error, + "smooth_derivative_errors": derivative_errors, + "harmonic_constraint_error": harmonic_constraint_error, + "fixed_cauchy_uniqueness_error": fixed_cauchy_uniqueness_error, + "green_expanding_domain_compatibility_error": green_compatibility_error, + "dependency_results": dependency_results, + } + acceptance = { + "nested_charts_form_a_direct_system": chart_error < 5e-14, + "metric_family_is_restriction_compatible": metric_restriction_error < 5e-14, + "glued_metric_is_symmetric": symmetry_error < 5e-14, + "glued_metric_is_nondegenerate_lorentzian": min_abs_determinant > 0.2 + and lorentzian_index_error == 0, + "smooth_metric_derivatives_converge_under_refinement": all( + later <= earlier + 5e-12 + for earlier, later in zip(derivative_errors, derivative_errors[1:]) + ) + and derivative_errors[-1] < 5e-5, + "harmonic_gauge_constraint_propagates": harmonic_constraint_error < 5e-14, + "fixed_cauchy_representatives_are_unique": fixed_cauchy_uniqueness_error + < 5e-14, + "causal_green_maps_are_compatible_on_expanding_domains": green_compatibility_error + < 5e-14, + "all_m14_dependencies_pass": all(dependency_results.values()), + "theorem_status_remains_conditional": canonical_payload(cfg)["theorem_status"] + == "conditional-model", + } + payload = canonical_payload(cfg) + return { + **payload, + "task": MILESTONE, + "diagnostics": diagnostics, + "acceptance": acceptance, + "fingerprint": fingerprint(payload), + "passed": all(acceptance.values()), + "decision": { + "continuum_ads_double_copy_is_a_conditional_executable_closure": True, + "finite_bcj_convergence_and_pde_gluing_premises_are_visible": True, + "unconditional_global_ads_double_copy_theorem_not_claimed": True, + "loop_level_and_nonperturbative_quantum_gravity_not_claimed": True, + }, + } diff --git a/tests/test_m14_ads_normalized_continuum_double_copy_m143.py b/tests/test_m14_ads_normalized_continuum_double_copy_m143.py new file mode 100644 index 00000000..fa7ed961 --- /dev/null +++ b/tests/test_m14_ads_normalized_continuum_double_copy_m143.py @@ -0,0 +1,7 @@ +from openwave.xperiments.m14_continuum_ads_double_copy.ads_normalized_continuum_double_copy_m143 import run_ads_normalized_continuum_double_copy_study + +def test_m143(): + result=run_ads_normalized_continuum_double_copy_study() + assert result["passed"] + assert len(result["acceptance"]) == 9 + assert result["decision"]["amplitude_entropy_equality_not_claimed"] diff --git a/tests/test_m14_causal_green_hadamard_m141.py b/tests/test_m14_causal_green_hadamard_m141.py new file mode 100644 index 00000000..182ad0ec --- /dev/null +++ b/tests/test_m14_causal_green_hadamard_m141.py @@ -0,0 +1,7 @@ +from openwave.xperiments.m14_continuum_ads_double_copy.causal_green_hadamard_m141 import run_causal_green_hadamard_study + +def test_m141(): + result=run_causal_green_hadamard_study() + assert result["passed"] + assert len(result["acceptance"]) == 8 + assert result["decision"]["wavefront_equality_not_inferred_from_global_hyperbolicity_alone"] diff --git a/tests/test_m14_infinite_bcj_direct_limit_m142.py b/tests/test_m14_infinite_bcj_direct_limit_m142.py new file mode 100644 index 00000000..985ddb77 --- /dev/null +++ b/tests/test_m14_infinite_bcj_direct_limit_m142.py @@ -0,0 +1,7 @@ +from openwave.xperiments.m14_continuum_ads_double_copy.infinite_bcj_direct_limit_m142 import run_infinite_bcj_direct_limit_study + +def test_m142(): + result=run_infinite_bcj_direct_limit_study() + assert result["passed"] + assert len(result["acceptance"]) == 9 + assert result["decision"]["summability_and_gauge_orthogonality_are_visible_model_premises"] diff --git a/tests/test_m14_smooth_continuum_ads_double_copy_m144.py b/tests/test_m14_smooth_continuum_ads_double_copy_m144.py new file mode 100644 index 00000000..07b16a4a --- /dev/null +++ b/tests/test_m14_smooth_continuum_ads_double_copy_m144.py @@ -0,0 +1,8 @@ +from openwave.xperiments.m14_continuum_ads_double_copy.smooth_continuum_ads_double_copy_m144 import run_smooth_continuum_ads_double_copy_study + +def test_m144(): + result=run_smooth_continuum_ads_double_copy_study() + assert result["passed"] + assert len(result["acceptance"]) == 10 + assert result["theorem_status"] == "conditional-model" + assert result["decision"]["unconditional_global_ads_double_copy_theorem_not_claimed"]