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..7c84a77f --- /dev/null +++ b/openwave/xperiments/m14_continuum_ads_double_copy/__init__.py @@ -0,0 +1,4 @@ +"""M14 CAT/EPT continuum AdS double-copy lineage.""" +from .causal_green_hadamard_m141 import CausalGreenHadamardConfig, run_causal_green_hadamard_study +run_m14_model_study=run_causal_green_hadamard_study +__all__=["CausalGreenHadamardConfig","run_causal_green_hadamard_study","run_m14_model_study"] 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/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/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/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"]