diff --git a/MODELS.md b/MODELS.md index fc427c9c..66cf341e 100644 --- a/MODELS.md +++ b/MODELS.md @@ -6,7 +6,8 @@ OpenWave hosts multiple candidate field-theoretic models. Historical M4--M8 resu | --- | --- | --- | --- | | M4--M8 | historical OpenWave models | `MODELS_LEGACY.md` | legacy matrix | | **M9** | **CAT/EPT Pauli--Hartree--U(1) dynamics** | **`MODELS_M9.md`** | **stable M9.126 evidence aliases plus latest M9.141 integration aliases** | -| **M10** | **CAT/EPT Dirac--Cartan--2I--Compton--Yukawa** | **`MODELS_M10.md`** | **M10.1 executable relativistic carrier and formal equation ledger** | +| **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** | ## M9 stable and latest lineage @@ -14,17 +15,10 @@ The stable compatibility registration and conformance aliases remain at **M9.126 The latest integrated M9 contract is **M9.141**. It constructs one executable three-dimensional Pauli--Hartree--U(1) carrier on the shared odd-grid Fourier geometry. -## M10 relativistic comparison model +## M10 relativistic color-matter comparison model -M10.1 constructs a distinct four-spinor model rather than replacing M9. It executes the complete 120-element binary-icosahedral group, lifts it unitarily to the Dirac carrier, couples the field to periodic U(1) potentials, eliminates the algebraic Cartan axial source into a contact term, and uses one Yukawa-generated complex mass to determine the real mass, Compton clock, and CAT/EPT entropy rate. +M10 constructs a distinct four-spinor model rather than replacing M9. Its current lineage reaches matrix-valued and periodic Hamiltonian SU(3), fundamental color matter, sourced Gauss closure, Wilson-loop refinement, confinement diagnostics and positive decoherence spectra. -| Layer | M9 result | M10 result | -| --- | --- | --- | -| matter carrier | two-component Pauli spinor | four-component Dirac spinor | -| internal discrete symmetry | Pauli spin and winding | complete binary icosahedral `2I` action and `A5` bilinear descent | -| gravity interaction | Hartree/Newton potential | algebraic Einstein--Cartan axial contact term | -| mass/clock | effective mass map `D=1/(2m)` | `m_Y=yv/sqrt(2)=hbar omega_C/c^2` | -| irreversible sector | frozen-H squared-gradient functional | complex Yukawa mass with `Im(E_rest)=Sdot_I` | -| gauge sector | static periodic U(1) | static periodic U(1) in the Dirac operator | +## M11 pointwise soliton--Liouville--QDO comparison model -M10.2 is the stationary, refinement, perturbation, and covariance closure for this relativistic carrier. +M11 begins from an exact normalized pointwise bright soliton, constructs its pure Liouville density tensor in controlled finite cutoffs of an infinite mode set, and derives the Lennard--Jones `-C6/R6` and Axilrod--Teller `C9/R9` interactions from one QDO response model. Its optional QCD sector reuses M10's SU(3) engine. The final campaign adds conservative and entropic center dynamics plus tensor dephasing without claiming a completed infinite-particle Fock space or a calibrated physical particle identity. diff --git a/MODELS_M11.md b/MODELS_M11.md new file mode 100644 index 00000000..068820ad --- /dev/null +++ b/MODELS_M11.md @@ -0,0 +1,42 @@ +# OpenWave M11 CAT/EPT pointwise soliton--Liouville--QDO model + +M11 is a separate candidate particle model. It does not replace the M9 Pauli--Hartree carrier or the M10 relativistic SU(3) color-matter carrier. + +## Lineage + +| Milestone | Executable result | +| --- | --- | +| M11.1 | exact normalized pointwise bright soliton and standing-wave/BPS controls | +| M11.2 | pure Liouville density tensor, infinite-mode cutoff refinement and fixed-particle bookkeeping | +| M11.3 | QDO-calibrated Lennard--Jones `-C6/R6` tail and Axilrod--Teller `C9/R9` sector | +| M11.4 | optional SU(3) color coupling reusing M10 links, hopping, gauge covariance and Gauss diagnostics | +| M11.5 | conservative/dissipative center dynamics, monotone entropic time, tensor dephasing and registration | + +## Microscopic interaction closure + +The reference parameters obey + +```text +C6_LJ = epsilon n re^6/(n-6) + = C6_QDO + = 3/4 alpha1^2 hbar omega + +alpha1 C6 = 4 C9, +C9 = 3/16 alpha1^3 hbar omega. +``` + +Thus the LJ dispersion tail and ATM three-body coupling are generated from one QDO response model rather than calibrated independently. + +## Formal authority + +Lean authority is `jagg-ix/entropic-physlib-private`, branch `entropic-physlib-linear-full`, TIP `8bafa9ab93cbb39e85909fc3837bb4b6e0dec748`. OpenWave supplies executable numerical closure and does not promote the finite-cutoff Liouville implementation to an infinite-particle completed Fock space. + +## Reproduction + +```bash +PYTHONPATH=. python - <<'PY' +from openwave.xperiments.m11_cat_ept_soliton_qdo import run_m11_model_study +import json +print(json.dumps(run_m11_model_study(), indent=2, sort_keys=True, default=float)) +PY +``` diff --git a/openwave/xperiments/m11_cat_ept_soliton_qdo/__init__.py b/openwave/xperiments/m11_cat_ept_soliton_qdo/__init__.py index 966342d2..96cd167e 100644 --- a/openwave/xperiments/m11_cat_ept_soliton_qdo/__init__.py +++ b/openwave/xperiments/m11_cat_ept_soliton_qdo/__init__.py @@ -1,13 +1,40 @@ """M11 CAT/EPT pointwise soliton--Liouville--QDO particle model.""" -from .pointwise_soliton_carrier_m111 import PointwiseSolitonConfig, PointwiseSolitonState, construct_pointwise_soliton, run_pointwise_soliton_study -from .liouville_soliton_tensor_m112 import LiouvilleTensorConfig, LiouvilleTensorState, construct_liouville_tensor, run_liouville_tensor_study -from .qdo_lj_atm_interaction_m113 import QDOLJATMConfig, run_qdo_lj_atm_study + +from .pointwise_soliton_carrier_m111 import ( + PointwiseSolitonConfig, + PointwiseSolitonState, + construct_pointwise_soliton, + run_pointwise_soliton_study, +) +from .liouville_soliton_tensor_m112 import ( + LiouvilleTensorConfig, + LiouvilleTensorState, + construct_liouville_tensor, + run_liouville_tensor_study, +) +from .qdo_lj_atm_interaction_m113 import ( + QDOLJATMConfig, + run_qdo_lj_atm_study, +) from .optional_qcd_coupling_m114 import OptionalQCDConfig, run_optional_qcd_study +from .coupled_dynamics_registration_m115 import ( + CoupledDynamicsConfig, + run_m11_model_study, +) + __all__ = [ - "PointwiseSolitonConfig", "PointwiseSolitonState", - "LiouvilleTensorConfig", "LiouvilleTensorState", "QDOLJATMConfig", - "OptionalQCDConfig", "construct_pointwise_soliton", - "run_pointwise_soliton_study", "construct_liouville_tensor", - "run_liouville_tensor_study", "run_qdo_lj_atm_study", + "PointwiseSolitonConfig", + "PointwiseSolitonState", + "LiouvilleTensorConfig", + "LiouvilleTensorState", + "QDOLJATMConfig", + "OptionalQCDConfig", + "CoupledDynamicsConfig", + "construct_pointwise_soliton", + "construct_liouville_tensor", + "run_pointwise_soliton_study", + "run_liouville_tensor_study", + "run_qdo_lj_atm_study", "run_optional_qcd_study", + "run_m11_model_study", ] diff --git a/openwave/xperiments/m11_cat_ept_soliton_qdo/coupled_dynamics_registration_m115.py b/openwave/xperiments/m11_cat_ept_soliton_qdo/coupled_dynamics_registration_m115.py new file mode 100644 index 00000000..9be4178d --- /dev/null +++ b/openwave/xperiments/m11_cat_ept_soliton_qdo/coupled_dynamics_registration_m115.py @@ -0,0 +1,250 @@ +"""M11.5 coupled soliton-center dynamics, decoherence, and model registration.""" +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 .liouville_soliton_tensor_m112 import construct_liouville_tensor, run_liouville_tensor_study +from .optional_qcd_coupling_m114 import run_optional_qcd_study +from .pointwise_soliton_carrier_m111 import run_pointwise_soliton_study +from .qdo_lj_atm_interaction_m113 import ( + QDOLJATMConfig, + lj_potential, + qdo_c9, + run_qdo_lj_atm_study, + trimer_atm_energy, +) + +MILESTONE = "M11.5" +SCHEMA = "openwave.m11.coupled-dynamics-registration.v1" +FORMAL_HEAD = "8bafa9ab93cbb39e85909fc3837bb4b6e0dec748" +FORMAL_SOURCES = ( + { + "path": "Physlib/QuantumMechanics/ComplexAction/EntropicTime/CubicQuinticMildFlow.lean", + "sha": "82a89eabf1179eff2373b2f005317e63cbd62cba", + "theorem": "target_tendsto_and_normalized_of_minimizing_energySplit", + }, + { + "path": "Physlib/QuantumMechanics/ComplexAction/EntropicTime/CubicQuinticOrbitalStability.lean", + "sha": "fb47b98296a771eee44570ce42b5c2ab03d450a3", + "theorem": "exists_constrained_hOne_minimizer_of_bounded_minimizingSequence", + }, + { + "path": "Physlib/QuantumMechanics/OpenSystems/LiouvilleSecondQuantization.lean", + "sha": "9d2c905c940480f1ed570cf0be965d5a9b6c4831", + "theorem": "spacePointwiseKernelOperator_apply_ae", + }, +) + + +def _canonical_json(value: Mapping[str, Any]) -> str: + return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str) + + +@dataclass(frozen=True) +class CoupledDynamicsConfig: + steps: int = 160 + timestep: float = 2.0e-3 + mass: float = 1.0 + entropic_gamma: float = 0.035 + hbar: float = 1.0 + finite_difference_step: float = 2.0e-5 + decoherence_strength: float = 0.8 + + def validate(self) -> None: + if self.steps < 20 or self.timestep <= 0 or self.mass <= 0: + raise ValueError("positive integration settings required") + if self.entropic_gamma < 0 or self.hbar <= 0: + raise ValueError("nonnegative gamma and positive hbar required") + if self.finite_difference_step <= 0: + raise ValueError("positive finite-difference step required") + + +def initial_centers() -> np.ndarray: + return np.asarray( + [[-0.85, -0.32], [0.82, -0.28], [0.05, 1.04]], dtype=np.float64 + ) + + +def total_interaction_energy(points: np.ndarray, qdo: QDOLJATMConfig) -> float: + pair = 0.0 + for i in range(points.shape[0]): + for j in range(i + 1, points.shape[0]): + distance = float(np.linalg.norm(points[i] - points[j])) + pair += lj_potential( + qdo.epsilon, + qdo.equilibrium_distance, + distance, + qdo.repulsive_exponent, + ) + three = trimer_atm_energy(points, qdo_c9(qdo.alpha1, qdo.hbar_omega)) + return float(pair + three) + + +def numerical_forces(points: np.ndarray, qdo: QDOLJATMConfig, step: float) -> np.ndarray: + forces = np.zeros_like(points) + for particle in range(points.shape[0]): + for axis in range(points.shape[1]): + plus = points.copy() + minus = points.copy() + plus[particle, axis] += step + minus[particle, axis] -= step + derivative = ( + total_interaction_energy(plus, qdo) + - total_interaction_energy(minus, qdo) + ) / (2.0 * step) + forces[particle, axis] = -derivative + return forces + + +def velocity_verlet( + config: CoupledDynamicsConfig, + qdo: QDOLJATMConfig, + damping: float, +) -> dict[str, Any]: + points = initial_centers() + velocities = np.asarray([[0.0, 0.08], [-0.03, -0.04], [0.03, -0.04]], dtype=np.float64) + velocities -= velocities.mean(axis=0) + force = numerical_forces(points, qdo, config.finite_difference_step) + energies: list[float] = [] + entropic_times: list[float] = [0.0] + for _ in range(config.steps): + velocities += 0.5 * config.timestep * force / config.mass + points += config.timestep * velocities + new_force = numerical_forces(points, qdo, config.finite_difference_step) + velocities += 0.5 * config.timestep * new_force / config.mass + if damping > 0.0: + kinetic_before = 0.5 * config.mass * float(np.sum(velocities**2)) + velocities *= math.exp(-damping * config.timestep) + kinetic_after = 0.5 * config.mass * float(np.sum(velocities**2)) + entropic_times.append( + entropic_times[-1] + max(0.0, kinetic_before - kinetic_after) / config.hbar + ) + else: + entropic_times.append(entropic_times[-1]) + force = new_force + kinetic = 0.5 * config.mass * float(np.sum(velocities**2)) + energies.append(kinetic + total_interaction_energy(points, qdo)) + return { + "points": points, + "velocities": velocities, + "energies": np.asarray(energies), + "entropic_times": np.asarray(entropic_times), + } + + +def dephased_density(strength: float) -> tuple[np.ndarray, np.ndarray]: + state = construct_liouville_tensor() + rho = state.density_matrix + indices = np.arange(rho.shape[0], dtype=np.float64) + distance_sq = (indices[:, None] - indices[None, :]) ** 2 / rho.shape[0] ** 2 + dephased = rho * np.exp(-strength * distance_sq) + dephased /= np.trace(dephased) + return rho, np.asarray(dephased, dtype=np.complex128) + + +def offdiagonal_norm(matrix: np.ndarray) -> float: + return float(np.linalg.norm(matrix - np.diag(np.diag(matrix)))) + + +def canonical_payload(config: CoupledDynamicsConfig | None = None) -> dict[str, Any]: + cfg = CoupledDynamicsConfig() if config is None else config + return { + "schema": SCHEMA, + "model_id": "M11", + "milestone": MILESTONE, + "model": "CAT/EPT pointwise soliton--Liouville--QDO particle model", + "configuration": asdict(cfg), + "lineage": ["M11.1", "M11.2", "M11.3", "M11.4", "M11.5"], + "study_api": ( + "openwave.xperiments.m11_cat_ept_soliton_qdo." + "coupled_dynamics_registration_m115:run_m11_model_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: + selected = canonical_payload() if payload is None else dict(payload) + return sha256(_canonical_json(selected).encode()).hexdigest() + + +def run_m11_model_study(config: CoupledDynamicsConfig | None = None) -> dict[str, Any]: + cfg = CoupledDynamicsConfig() if config is None else config + cfg.validate() + qdo_cfg = QDOLJATMConfig() + conservative = velocity_verlet(cfg, qdo_cfg, damping=0.0) + dissipative = velocity_verlet(cfg, qdo_cfg, damping=cfg.entropic_gamma) + conservative_energies = conservative["energies"] + dissipative_energies = dissipative["energies"] + initial_energy_scale = max(abs(float(conservative_energies[0])), 1.0) + conservative_drift = float( + np.max(np.abs(conservative_energies - conservative_energies[0])) / initial_energy_scale + ) + entropic = dissipative["entropic_times"] + rho, dephased = dephased_density(cfg.decoherence_strength) + dephased_eigenvalues = np.linalg.eigvalsh(dephased) + substudies = { + "pointwise": run_pointwise_soliton_study(), + "liouville": run_liouville_tensor_study(), + "qdo_lj_atm": run_qdo_lj_atm_study(qdo_cfg), + "optional_qcd": run_optional_qcd_study(), + } + diagnostics = { + "conservative_relative_energy_drift": conservative_drift, + "dissipative_energy_change": float(dissipative_energies[-1] - dissipative_energies[0]), + "final_entropic_time": float(entropic[-1]), + "minimum_entropic_increment": float(np.min(np.diff(entropic))), + "dephased_trace_error": abs(np.trace(dephased) - 1.0), + "dephased_hermiticity_error": float(np.linalg.norm(dephased - dephased.conj().T)), + "dephased_minimum_eigenvalue": float(dephased_eigenvalues.min()), + "offdiagonal_reduction": offdiagonal_norm(rho) - offdiagonal_norm(dephased), + "minimum_final_pair_distance": float( + min( + np.linalg.norm(dissipative["points"][i] - dissipative["points"][j]) + for i in range(3) + for j in range(i + 1, 3) + ) + ), + "substudies_passed": {name: bool(result["passed"]) for name, result in substudies.items()}, + } + acceptance = { + "all_prior_layers_pass": all(diagnostics["substudies_passed"].values()), + "conservative_verlet_is_stable": diagnostics["conservative_relative_energy_drift"] < 2.0e-5, + "dissipation_lowers_energy": diagnostics["dissipative_energy_change"] < 0.0, + "entropic_time_is_monotone": diagnostics["minimum_entropic_increment"] >= -1.0e-15, + "entropic_time_advances": diagnostics["final_entropic_time"] > 0.0, + "dephased_tensor_trace_one": diagnostics["dephased_trace_error"] < 5.0e-13, + "dephased_tensor_hermitian": diagnostics["dephased_hermiticity_error"] < 5.0e-13, + "dephased_tensor_positive": diagnostics["dephased_minimum_eigenvalue"] > -5.0e-13, + "environment_reduces_interference": diagnostics["offdiagonal_reduction"] > 0.0, + "centers_avoid_collision": diagnostics["minimum_final_pair_distance"] > 0.5, + } + payload = canonical_payload(cfg) + return { + **payload, + "task": "M11.5", + "diagnostics": diagnostics, + "substudy_fingerprints": { + name: result["fingerprint"] for name, result in substudies.items() + }, + "acceptance": acceptance, + "fingerprint": fingerprint(payload), + "passed": all(acceptance.values()), + "decision": { + "m11_registered_as_separate_model": True, + "pointwise_and_infinite_mode_layers_are_distinct": True, + "qdo_coefficients_are_not_independently_floated": True, + "qcd_sector_is_optional": True, + }, + } diff --git a/openwave/xperiments/m11_cat_ept_soliton_qdo/formal/coupled_dynamics_registration.v1.json b/openwave/xperiments/m11_cat_ept_soliton_qdo/formal/coupled_dynamics_registration.v1.json new file mode 100644 index 00000000..264d066a --- /dev/null +++ b/openwave/xperiments/m11_cat_ept_soliton_qdo/formal/coupled_dynamics_registration.v1.json @@ -0,0 +1,18 @@ +{ + "schema": "openwave.m11.coupled-dynamics-registration-ledger.v1", + "model_id": "M11", + "milestone": "M11.5", + "formal_repository": "jagg-ix/entropic-physlib-private", + "formal_branch": "entropic-physlib-linear-full", + "formal_head": "8bafa9ab93cbb39e85909fc3837bb4b6e0dec748", + "equations": [ + {"id": "center-dynamics", "equation": "m Xddot=-grad(E_LJ+E_ATM)", "numerical_source": "velocity_verlet"}, + {"id": "entropic-time", "equation": "Delta tau_ent=Delta E_diss/hbar>=0", "numerical_source": "velocity_verlet"}, + {"id": "dephasing", "equation": "rho_ij -> rho_ij exp(-gamma(i-j)^2/N^2)", "numerical_source": "dephased_density"} + ], + "formal_sources": [ + {"path": "Physlib/QuantumMechanics/ComplexAction/EntropicTime/CubicQuinticMildFlow.lean", "sha": "82a89eabf1179eff2373b2f005317e63cbd62cba", "theorem": "target_tendsto_and_normalized_of_minimizing_energySplit"}, + {"path": "Physlib/QuantumMechanics/ComplexAction/EntropicTime/CubicQuinticOrbitalStability.lean", "sha": "fb47b98296a771eee44570ce42b5c2ab03d450a3", "theorem": "exists_constrained_hOne_minimizer_of_bounded_minimizingSequence"}, + {"path": "Physlib/QuantumMechanics/OpenSystems/LiouvilleSecondQuantization.lean", "sha": "9d2c905c940480f1ed570cf0be965d5a9b6c4831", "theorem": "spacePointwiseKernelOperator_apply_ae"} + ] +} diff --git a/openwave/xperiments/m11_cat_ept_soliton_qdo/model_registration.py b/openwave/xperiments/m11_cat_ept_soliton_qdo/model_registration.py new file mode 100644 index 00000000..6313596b --- /dev/null +++ b/openwave/xperiments/m11_cat_ept_soliton_qdo/model_registration.py @@ -0,0 +1,14 @@ +"""Canonical registration alias for the complete M11 lineage.""" +from .coupled_dynamics_registration_m115 import ( + CoupledDynamicsConfig, + canonical_payload, + fingerprint, + run_m11_model_study, +) + +__all__ = [ + "CoupledDynamicsConfig", + "canonical_payload", + "fingerprint", + "run_m11_model_study", +] diff --git a/openwave/xperiments/m11_cat_ept_soliton_qdo/research/zil/m11_coupled_dynamics_m115.zc b/openwave/xperiments/m11_cat_ept_soliton_qdo/research/zil/m11_coupled_dynamics_m115.zc new file mode 100644 index 00000000..26576a81 --- /dev/null +++ b/openwave/xperiments/m11_cat_ept_soliton_qdo/research/zil/m11_coupled_dynamics_m115.zc @@ -0,0 +1,7 @@ +model:m11.5#extends@model:m11.4. +model:m11.5#dynamics@integrator:velocity-verlet. +integrator:velocity-verlet#evolves@potential:lennard-jones-plus-atm. +model:m11.5#entropic-clock@clock:tau-ent. +clock:tau-ent#monotone-by@energy:dissipated. +model:m11.5#decoheres@liouville:rho-psi. +model:m11.5#registered-as@openwave:model-m11. diff --git a/tests/test_m11_coupled_registration_m115.py b/tests/test_m11_coupled_registration_m115.py new file mode 100644 index 00000000..0dda9f80 --- /dev/null +++ b/tests/test_m11_coupled_registration_m115.py @@ -0,0 +1,6 @@ +from openwave.xperiments.m11_cat_ept_soliton_qdo.coupled_dynamics_registration_m115 import run_m11_model_study + +def test_m11_complete_campaign(): + result=run_m11_model_study() + assert result['passed'], result + assert result['decision']['m11_registered_as_separate_model']