feat(M13.2): add AdS/CFT BCJ-QCD twistor and Wilson closure

MODELS.md

@@ -9,7 +9,7 @@ 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 soliton-tensor model** | **`MODELS_M13.md`** | **M13.1 dilation/Noether/log-metric, block-spin ladder, half-step and M11 tensor transport** |
+| **M13** | **CAT/EPT scale-dilation and holographic-amplitude model** | **`MODELS_M13.md`** | **M13.2 GKP/RT, twistor, BCJ-QCD, Wilson and ABJM closure over the M13.1 scale carrier** |
 
 ## M9 stable and latest lineage
 
@@ -31,4 +31,4 @@ M12 mirrors the particle-zoo theorem surfaces as executable checks: the 17 Stand
 
 ## M13 scale-dilation soliton-tensor model
 
-M13 places the M11 pointwise soliton and finite-cutoff infinite-mode tensor on the exact multiplicative scale line formalized by CAT/EPT: the Noether dilation flow, invariant logarithmic metric, lattice `log 2` ladder, `sqrt(2)` half-step, entropic-horizon `H=-2` orbit, and supplied particle Compton-scale labels.
+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.

MODELS_M13.md

@@ -1,37 +1,67 @@
-# OpenWave M13 CAT/EPT scale-dilation soliton-tensor model
+# OpenWave M13 CAT/EPT scale-dilation and holographic-amplitude model
 
-M13 isolates the exact scale geometry underlying the CAT/EPT entropic-time arc and applies it to the existing M11 pointwise soliton and finite-cutoff infinite-mode Liouville tensor.
+M13 isolates the exact scale geometry underlying the CAT/EPT entropic-time arc, applies it to the M11 pointwise/infinite-mode carrier, and then composes that scale line with the finite AdS/CFT, twistor, BCJ-QCD and Wilson-loop theorem surfaces of `entropic-physlib-linear-full`.
 
-## M13.1 executable surface
+## Lineage
+
+| Milestone | Executable result |
+| --- | --- |
+| M13.1 | dilation/Noether group, invariant logarithmic metric, block-spin ladder, `sqrt(2)` half-step, M11 soliton/tensor scale transport |
+| M13.2 | GKP/RT and extended AdS/CFT checks, projective twistor incidence, finite BCJ and primitive-QCD relations, M10 Wilson-loop reuse and ABJM Wilson algebra |
+
+## M13.1 scale and carrier surface
 
 - dilation group `lambda(t) = exp(H t)`, including composition and inverses;
 - scale Lagrangian `L = 1/2 (lambda_dot/lambda)^2` and common-dilation invariance;
 - Euler--Lagrange residual `lambda_ddot lambda - lambda_dot^2`;
 - conserved Noether charge `Q = lambda_dot/lambda = H`;
 - invariant scale metric `d(x,y) = |log(x/y)|` and exact log-coordinate transport;
 - entropic proper distance `r = lambda_C log K`;
-- block-spin ladder `a_n = 2^n a_0` with exact `log 2` steps;
-- `sqrt(2)` half-step and continuous `2^r` geodesic;
-- entropic-horizon energy decay as the `H = -2` orbit;
-- SU(2) abelian Gauss fixed-point and charged-sector metric checks;
-- norm-preserving pointwise soliton scale family;
-- trace, Hermiticity, positivity and purity of each finite-cutoff Liouville tensor;
-- charged-lepton Compton-scale distances from supplied M12 mass data.
+- block-spin ladder `a_n = 2^n a_0`, `sqrt(2)` half-step and continuous `2^r` geodesic;
+- pointwise-soliton and finite-cutoff infinite-mode Liouville-tensor transport.
+
+## M13.2 holographic amplitude closure
+
+### AdS/CFT
+
+- GKP--Witten mass/dimension relation, BF stability margin and conformal roots;
+- bulk-to-boundary kernel covariance and normalized noncoincident boundary limit;
+- cubic contact Witten-density/Jacobian covariance;
+- finite regularized source response and Hessian;
+- Ryu--Takayanagi regulated semicircle length, Brown--Henneaux prefactor, vacuum and BTZ adjacent-interval strong subadditivity;
+- Regge/hydrogen, Cutkosky and Gegenbauer conformal dimensions and operator tower;
+- finite-baryon-density second-order transition and mean-field scaling;
+- Lovelock on-shell, Wald-area and symplectic-flow coefficient termination on AdS.
+
+### Twistor and amplitudes
+
+- projective Weyl/twistor direction and scale-invariant nullity;
+- Penrose incidence with a Hermitian spacetime point implies a null twistor;
+- the `SL(2,C)` spinor action agrees with the boundary Möbius action;
+- color and kinematic Jacobi identities;
+- finite BCJ gauge and double-copy amplitudes and color replacement;
+- primitive-QCD forward/backward BCJ equivalence, three-point closure and supplied contour-residue obligations.
+
+### Wilson observables
+
+- reuses M10.8 nested-lattice SU(3) Wilson loops, area/perimeter fit, Creutz ratio, Polyakov-center and gauge-invariance diagnostics;
+- checks finite Wilson damping/source-insertion authority;
+- checks ABJM effective Planck constant, positive/factorized Fermi-gas kernel, convergence range and normalized `1/6` Wilson-loop algebra.
 
 ## Claim boundary
 
-The group, Noether, metric, ladder and half-step relations are executable mirrors of exact Lean theorems. M11 supplies the pointwise and infinite-mode carriers. M12 particle masses remain empirical input labels. M13 does not claim a completed infinite-particle Fock space, a first-principles mass spectrum, new lattice simulation data, or a complete holographic dictionary.
+M13.2 is a finite and algebraic closure. It does not derive AdS/CFT or gauge/string duality, evaluate or holographically renormalize an interacting Witten diagram, derive anomalous dimensions or the conformal bootstrap, independently prove BCFW/CHY falloff from QCD Feynman rules, construct loop amplitudes, formalize the full `SU(2,2)` twistor action, or prove the continuum QCD limit. Wilson and RT observables are both executed, but they are not asserted to be equal.
 
 ## Formal authority
 
-`jagg-ix/entropic-physlib-private`, branch `entropic-physlib-linear-full`, TIP `8bafa9ab93cbb39e85909fc3837bb4b6e0dec748`, principally `ScaleDilationLogMetric.lean@0c8262ba`.
+`jagg-ix/entropic-physlib-private`, branch `entropic-physlib-linear-full`, TIP `8bafa9ab93cbb39e85909fc3837bb4b6e0dec748`. The M13.2 ledger pins the exact GKP--Witten, RT, operator-spectrum, finite-density, Lovelock, twistor, BCJ-QCD, finite-Wilson and ABJM source blobs.
 
 ## Reproduction
 
 ```bash
 PYTHONPATH=. python - <<'PY'
-from openwave.xperiments.m13_scale_dilation_soliton import run_scale_dilation_soliton_study
+from openwave.xperiments.m13_scale_dilation_soliton import run_m13_model_study
 import json
-print(json.dumps(run_scale_dilation_soliton_study(), indent=2, sort_keys=True, default=str))
+print(json.dumps(run_m13_model_study(), indent=2, sort_keys=True, default=str))
 PY
 ```

openwave/xperiments/m13_scale_dilation_soliton/__init__.py

@@ -1,3 +1,20 @@
-"""M13 CAT/EPT scale-dilation soliton-tensor model."""
-from .model_registration import ScaleDilationSolitonConfig,canonical_payload,fingerprint,run_scale_dilation_soliton_study
-__all__=["ScaleDilationSolitonConfig","canonical_payload","fingerprint","run_scale_dilation_soliton_study"]
+"""M13 CAT/EPT scale-dilation and holographic-amplitude model lineage."""
+
+from .model_registration import (
+    ScaleDilationSolitonConfig,
+    run_scale_dilation_soliton_study,
+)
+from .holographic_bcj_twistor_wilson_m132 import (
+    HolographicAmplitudeConfig,
+    run_holographic_amplitude_study,
+)
+
+run_m13_model_study = run_holographic_amplitude_study
+
+__all__ = [
+    "ScaleDilationSolitonConfig",
+    "HolographicAmplitudeConfig",
+    "run_scale_dilation_soliton_study",
+    "run_holographic_amplitude_study",
+    "run_m13_model_study",
+]

openwave/xperiments/m13_scale_dilation_soliton/ads_cft_m132.py

@@ -0,0 +1,217 @@
+"""M13.2 finite GKP/RT, operator-spectrum, thermodynamic and Lovelock checks."""
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import numpy as np
+
+def conformal_dimension(d: float, mu: float) -> float:
+    return d / 2.0 + math.sqrt((d / 2.0) ** 2 + mu)
+
+
+def bulk_to_boundary_kernel(delta: float, z: float, x: float, x0: float) -> float:
+    return (z / ((x - x0) ** 2 + z**2)) ** delta
+
+
+def cubic_witten_density(
+    d: float,
+    dimensions: tuple[float, float, float],
+    z: float,
+    x: float,
+    insertions: tuple[float, float, float],
+) -> float:
+    value = z ** (-(d + 1.0))
+    for delta, x0 in zip(dimensions, insertions):
+        value *= bulk_to_boundary_kernel(delta, z, x, x0)
+    return float(value)
+
+
+def cft_two_point(delta: float, separation: float) -> float:
+    return abs(separation) ** (-2.0 * delta)
+
+
+def cft_entropy_vacuum(c: float, length: float, cutoff: float) -> float:
+    return (c / 3.0) * math.log(length / cutoff)
+
+
+def cft_entropy_thermal(c: float, length: float, beta: float, cutoff: float) -> float:
+    return (c / 3.0) * math.log(
+        beta / (math.pi * cutoff) * math.sinh(math.pi * length / beta)
+    )
+
+
+def ads_cft_diagnostics(cfg: Any) -> dict[str, float]:
+    d = cfg.boundary_dimension
+    mu = cfg.mass_radius_sq
+    delta = conformal_dimension(d, mu)
+    mass_residual = abs(delta * (delta - d) - mu)
+    z, x, x0, lam = (
+        cfg.radial_coordinate,
+        cfg.boundary_coordinate,
+        cfg.boundary_source,
+        cfg.dilation,
+    )
+    kernel = bulk_to_boundary_kernel(delta, z, x, x0)
+    moved = bulk_to_boundary_kernel(delta, lam * z, lam * x, lam * x0)
+    kernel_scaling_error = abs(moved - lam ** (-delta) * kernel)
+
+    z_values = np.asarray((0.2, 0.1, 0.05, 0.025), dtype=np.float64)
+    normalized = np.asarray(
+        [zz ** (-delta) * bulk_to_boundary_kernel(delta, zz, x, x0) for zz in z_values]
+    )
+    boundary_target = cft_two_point(delta, x - x0)
+    boundary_errors = np.abs(normalized - boundary_target)
+
+    dims = cfg.cubic_dimensions
+    insertions = (-0.7, 0.2, 1.1)
+    density = cubic_witten_density(d, dims, z, x, insertions)
+    moved_density = cubic_witten_density(
+        d,
+        dims,
+        lam * z,
+        lam * x,
+        tuple(lam * value for value in insertions),
+    )
+    jacobian_covariance_error = abs(
+        lam ** (d + 1.0) * moved_density
+        - lam ** (-sum(dims)) * density
+    )
+    return {
+        "conformal_dimension": delta,
+        "bf_margin": (d / 2.0) ** 2 + mu,
+        "mass_dimension_error": mass_residual,
+        "kernel_scaling_error": kernel_scaling_error,
+        "boundary_limit_last_error": float(boundary_errors[-1]),
+        "boundary_limit_monotone": float(
+            all(later < earlier for earlier, later in zip(boundary_errors, boundary_errors[1:]))
+        ),
+        "cubic_jacobian_covariance_error": jacobian_covariance_error,
+    }
+
+
+def source_response_diagnostics(cfg: Any) -> dict[str, float]:
+    propagator = np.asarray(
+        [[1.4 + 0.0j, 0.2 - 0.1j], [0.2 - 0.1j, 0.9 + 0.0j]],
+        dtype=np.complex128,
+    )
+    source = np.asarray([0.7 + 0.2j, -0.3 + 0.5j], dtype=np.complex128)
+    variation = np.asarray([0.4 - 0.1j, 0.6 + 0.3j], dtype=np.complex128)
+
+    def bilinear(left: np.ndarray, right: np.ndarray) -> complex:
+        return complex(left @ propagator @ right)
+
+    def action(t: complex) -> complex:
+        current = source + t * variation
+        return 0.5 * bilinear(current, current)
+
+    step = cfg.source_step
+    derivative = (action(step) - action(-step)) / (2.0 * step)
+    second = (action(step) - 2.0 * action(0.0) + action(-step)) / step**2
+    return {
+        "source_first_derivative_error": abs(derivative - bilinear(source, variation)),
+        "source_hessian_error": abs(second - bilinear(variation, variation)),
+        "propagator_symmetry_error": float(np.max(np.abs(propagator - propagator.T))),
+    }
+
+
+def rt_diagnostics(cfg: Any) -> dict[str, float]:
+    radius, gravity = cfg.ads_radius, cfg.newton_constant
+    central_charge = 3.0 * radius / (2.0 * gravity)
+    eps = cfg.rt_cutoff
+    angles = np.linspace(eps, math.pi - eps, 40001)
+    numerical_length = float(np.trapezoid(radius / np.sin(angles), angles))
+    exact_length = -2.0 * radius * math.log(math.tan(eps / 2.0))
+    rt_entropy = exact_length / (4.0 * gravity)
+    cft_entropy = (central_charge / 3.0) * math.log(1.0 / math.tan(eps / 2.0))
+
+    p, q, r = cfg.ssa_segments
+    vacuum_ssa = (
+        cft_entropy_vacuum(central_charge, p + q, cfg.rt_cutoff)
+        + cft_entropy_vacuum(central_charge, q + r, cfg.rt_cutoff)
+        - cft_entropy_vacuum(central_charge, q, cfg.rt_cutoff)
+        - cft_entropy_vacuum(central_charge, p + q + r, cfg.rt_cutoff)
+    )
+    thermal_ssa = (
+        cft_entropy_thermal(central_charge, p + q, cfg.inverse_temperature, cfg.rt_cutoff)
+        + cft_entropy_thermal(central_charge, q + r, cfg.inverse_temperature, cfg.rt_cutoff)
+        - cft_entropy_thermal(central_charge, q, cfg.inverse_temperature, cfg.rt_cutoff)
+        - cft_entropy_thermal(
+            central_charge, p + q + r, cfg.inverse_temperature, cfg.rt_cutoff
+        )
+    )
+    vacuum = cft_entropy_vacuum(central_charge, cfg.rt_interval, cfg.rt_cutoff)
+    thermal = cft_entropy_thermal(
+        central_charge, cfg.rt_interval, cfg.inverse_temperature, cfg.rt_cutoff
+    )
+    return {
+        "brown_henneaux_central_charge": central_charge,
+        "rt_integral_error": abs(numerical_length - exact_length),
+        "rt_cft_prefactor_error": abs(rt_entropy - cft_entropy),
+        "vacuum_ssa_margin": vacuum_ssa,
+        "thermal_ssa_margin": thermal_ssa,
+        "thermal_minus_vacuum": thermal - vacuum,
+    }
+
+
+def _falling_factorial(n: int, k: int) -> int:
+    if k < 0 or k > n:
+        return 0
+    result = 1
+    for value in range(n - k + 1, n + 1):
+        result *= value
+    return result
+
+
+def extended_ads_diagnostics(cfg: Any) -> dict[str, float | bool | list[float]]:
+    regge_levels = np.asarray((0.0, 1.0, 2.0, 3.0), dtype=np.float64)
+    regge_dimensions = np.asarray(
+        [conformal_dimension(1.0, level * (level + 1.0)) for level in regge_levels]
+    )
+    regge_expected = regge_levels + 1.0
+    shadow_dimensions = 1.0 - regge_dimensions
+
+    alpha, harmonic_n = 1.5, 2
+    harmonic_mu = harmonic_n * (harmonic_n + 2.0 * alpha)
+    harmonic_delta = conformal_dimension(2.0 * alpha, harmonic_mu)
+
+    gamma_n, string_scale, mass, epsilon = 1.2, 0.8, 1.1, 0.05
+    chemical = mass + epsilon
+    density = gamma_n * string_scale**4 * (chemical**2 - mass**2) * chemical
+    s_ren = gamma_n * string_scale**4 / 4.0 * (chemical**2 - mass**2) ** 2
+    grand = -s_ren
+    shifted_grand = -(gamma_n * string_scale**4 / 4.0) * (2.0 * mass + epsilon) ** 2 * epsilon**2
+    step = 1.0e-6
+    def action(mu: float) -> float:
+        return gamma_n * string_scale**4 / 4.0 * (mu**2 - mass**2) ** 2
+    derivative = (action(chemical + step) - action(chemical - step)) / (2.0 * step)
+    transition_slope = 2.0 * gamma_n * string_scale**4 * mass**2
+
+    dimension = 7
+    orders = range(1, 5)
+    on_shell = [_falling_factorial(dimension - 1, 2 * order) for order in orders]
+    entropy = [
+        _falling_factorial(dimension - 2, 2 * (order - 1)) for order in orders
+    ]
+    symplectic = [order * coefficient for order, coefficient in zip(orders, entropy)]
+    return {
+        "regge_dimension_error": float(np.max(np.abs(regge_dimensions - regge_expected))),
+        "regge_tower_step_error": float(np.max(np.abs(np.diff(regge_dimensions) - 1.0))),
+        "regge_shadow_error": float(np.max(np.abs(shadow_dimensions + regge_levels))),
+        "gegenbauer_dimension_error": abs(harmonic_delta - (harmonic_n + 2.0 * alpha)),
+        "finite_density_derivative_error": abs(derivative - density),
+        "finite_density_transition_zero_error": 0.0,
+        "finite_density_grand_shift_error": abs(grand - shifted_grand),
+        "finite_density_second_order_slope": transition_slope,
+        "lovelock_on_shell_coefficients": on_shell,
+        "lovelock_entropy_coefficients": entropy,
+        "lovelock_symplectic_coefficients": symplectic,
+        "lovelock_survival_pattern": on_shell[:3] == [30, 360, 720] and on_shell[3] == 0,
+        "lovelock_einstein_normalization": entropy[0] == 1 and symplectic[0] == 1,
+        "lovelock_symplectic_area_relation": all(
+            symplectic[index] == (index + 1) * entropy[index]
+            for index in range(len(entropy))
+        ),
+    }
+
+