feat(M14): combine continuum AdS double-copy lineage

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.

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
+```

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"]

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,
+        },
+    }