feat(M15.5-M15.7): add clock dynamics and entropic synthesis

MODELS.md

@@ -11,7 +11,7 @@ OpenWave hosts multiple candidate field-theoretic models. Historical M4--M8 resu
 | **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 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** |
-| **M15** | **CAT/EPT Kuchař relational-time and AdS double-copy model** | **`MODELS_M15.md`** | **M15.1--M15.4 clock consistency plus finite, pointwise, infinite and continuum BCJ/AdS coverage** |
+| **M15** | **CAT/EPT Kuchař relational-time, AdS double-copy, and clock-synthesis model** | **`MODELS_M15.md`** | **M15.1--M15.7 relational consistency, BCJ/AdS coverage, ordered clocks, functorial dynamics and entropic synthesis** |
 
 ## M9 stable and latest lineage
 
@@ -39,6 +39,6 @@ M13 places the M11 pointwise soliton and finite-cutoff infinite-mode tensor on t
 
 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.
 
-## M15 relational-time AdS double-copy model
+## M15 relational-time, AdS double-copy and clock-synthesis model
 
-M15 places the complete executable M13/M14 BCJ and AdS surface behind the Kuchař relational-time consistency gates. Its final status is conditional and keeps global-time, analytic PDE, summability, compactification and loop-level obligations explicit.
+M15 places the complete executable M13/M14 BCJ and AdS surface behind Kuchař relational-time consistency gates, then adds exact conditioned evolution, ordered four-clock calibration, functorial observable and dynamics transport, and the reversible clock/information/force/correlation synthesis. Its final status remains conditional and keeps calibration, global-time, analytic PDE, summability, compactification, and unified-action obligations explicit.

MODELS_M15.md

@@ -1,7 +1,9 @@
-# OpenWave M15 CAT/EPT Kuchař relational-time and AdS double-copy model
+# OpenWave M15 CAT/EPT Kuchař relational-time, AdS double-copy, and clock-synthesis model
 
 M15 begins with the Kuchař Sections 1--2 relational-time consistency contract,
-then composes every executable BCJ/AdS surface already present in M13 and M14.
+composes the executable BCJ/AdS surfaces already present in M13 and M14, and
+then adds the latest conditioned-dynamics, functorial-calibration, and
+information/force/correlation clock theorems.
 
 ## Lineage
 
@@ -11,26 +13,37 @@ then composes every executable BCJ/AdS surface already present in M13 and M14.
 | M15.2 | finite BCJ, primitive QCD, massive/Yukawa BCJ, weighted GKP source kernel, generalized gauge checks and explicit pointwise Jacobi modes |
 | M15.3 | square-summable infinite BCJ direct limit, quantitative tails, causal Green/Pauli--Jordan transport and Hadamard probe compatibility |
 | M15.4 | D3/central-charge normalization, continuum GKP kernel, RT/Complex-Einstein identities, smooth Lorentzian direct limit and harmonic-Einstein uniqueness |
+| M15.5 | exact conditioned evolution and ordered Page--Wootters/modular/entropic/proper-time calibration |
+| M15.6 | functorial conditioning, observable/predicate transport, and conjugated clock endomorphisms |
+| M15.7 | reversible KL clock, tick-conjugate force, classical CHSH ceiling, eight-clock quantum optimum, and damped clock phase |
 
-## Coverage boundary
-
-M15.4 registers finite, pointwise, infinite and continuum double-copy surfaces in
-one relational-time model. The status remains
-**conditional-relational-continuum-ads-double-copy-model**.
-
-It does not infer a global preferred time, automatic Green/Hadamard existence,
-convergence of arbitrary numerator families, loop-level color--kinematics
-duality, an interacting renormalized Witten functional, or equality between a
-BCJ amplitude and RT entropy.
-
-## Formal authority
+## Latest formal authority
 
 ```text
 jagg-ix/entropic-physlib-private
 entropic-physlib-linear-full
-1061988e0c356075562ced1bd88758ba4922375c
+b44d8ab215568d2239ab2ea20aca483df3b1076b
 ```
 
+The new M15.5--M15.7 authority is concentrated in:
+
+- `ThreeClockClosure.lean`;
+- `ThreeClockDynamics.lean`;
+- `ThreeClockFunctoriality.lean`;
+- `EntropicClockSynthesis.lean`.
+
+## Coverage boundary
+
+M15.7 has status **conditional-relational-clock-synthesis-model**.
+
+The conditioned-state equality, clock equivalences, strict monotonicity of the
+physical calibration maps, and selected finite thermodynamic inputs remain
+explicit premises. The model does not infer a global preferred time, automatic
+equivalence of arbitrary clocks, a single action deriving all clock,
+information, force and correlation faces, a Pinsker-type quantitative
+information/correlation inequality, loop-level color--kinematics duality, or
+Einstein equations from a Bell certificate.
+
 ## Reproduction
 
 ```bash

openwave/xperiments/m15_kuchar_relational_time/__init__.py

@@ -15,10 +15,33 @@
     KucharFullAdSDoubleCopyConfig,
     run_kuchar_full_ads_double_copy_study,
 )
-run_m15_model_study = run_kuchar_full_ads_double_copy_study
+from .conditioned_four_clock_dynamics_m155 import (
+    ConditionedFourClockConfig,
+    run_conditioned_four_clock_study,
+)
+from .functorial_conditioning_m156 import (
+    FunctorialConditioningConfig,
+    run_functorial_conditioning_study,
+)
+from .entropic_clock_synthesis_m157 import (
+    EntropicClockSynthesisConfig,
+    run_entropic_clock_synthesis_study,
+)
+run_m15_model_study = run_entropic_clock_synthesis_study
 __all__ = [
-    "KucharRelationalTimeConfig", "KucharBCJPointwiseConfig", "KucharContinuumBCJConfig",
-    "KucharFullAdSDoubleCopyConfig", "run_kuchar_relational_time_study",
-    "run_kuchar_bcj_pointwise_coverage_study", "run_kuchar_continuum_bcj_causal_study",
-    "run_kuchar_full_ads_double_copy_study", "run_m15_model_study",
+    "KucharRelationalTimeConfig",
+    "KucharBCJPointwiseConfig",
+    "KucharContinuumBCJConfig",
+    "KucharFullAdSDoubleCopyConfig",
+    "ConditionedFourClockConfig",
+    "FunctorialConditioningConfig",
+    "EntropicClockSynthesisConfig",
+    "run_kuchar_relational_time_study",
+    "run_kuchar_bcj_pointwise_coverage_study",
+    "run_kuchar_continuum_bcj_causal_study",
+    "run_kuchar_full_ads_double_copy_study",
+    "run_conditioned_four_clock_study",
+    "run_functorial_conditioning_study",
+    "run_entropic_clock_synthesis_study",
+    "run_m15_model_study",
 ]

openwave/xperiments/m15_kuchar_relational_time/conditioned_four_clock_dynamics_m155.py

@@ -0,0 +1,211 @@
+"""M15.5 conditioned dynamics and ordered four-clock calibration."""
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from hashlib import sha256
+import json
+from typing import Any, Mapping
+
+MILESTONE = "M15.5"
+SCHEMA = "openwave.m15.conditioned-four-clock-dynamics.v1"
+FORMAL_HEAD = "b44d8ab215568d2239ab2ea20aca483df3b1076b"
+FORMAL_SOURCES = (
+    {
+        "path": "Physlib/QuantumMechanics/RelationalTime/ThreeClockClosure.lean",
+        "sha": "979aca0d9d011f7868391188871dbb06a200f1ac",
+        "theorems": [
+            "FiniteConditioningCertificate.all_conditioned_states_recovered",
+            "FiniteConditioningCertificate.history_satisfies_constraint",
+            "ThreeClockCalibration.pwToEntropic_injective",
+            "ThreeClockCalibration.pwToEntropic_surjective",
+        ],
+    },
+    {
+        "path": "Physlib/QuantumMechanics/RelationalTime/ThreeClockDynamics.lean",
+        "sha": "3fd7da756ce479c289b4a8dd0f0b8db1dbde3f25",
+        "theorems": [
+            "ConditionedEvolutionCertificate.conditioned_evolves",
+            "ConditionedEvolutionCertificate.conditioned_step_pair",
+            "FourClockCalibration.pw_modular_entropic_proper_commutes",
+            "FourClockCalibration.pwToProper_injective",
+            "FourClockCalibration.pwToProper_surjective",
+            "OrderedFourClockCalibration.pwToProper_strictMono",
+            "OrderedFourClockCalibration.pw_lt_implies_proper_lt",
+            "OrderedFourClockCalibration.proper_readings_ne_of_pw_lt",
+        ],
+    },
+)
+
+
+def _canonical_json(value: Mapping[str, Any]) -> str:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str)
+
+
+@dataclass(frozen=True)
+class ConditionedFourClockConfig:
+    initial_state: float = 0.75
+    system_increment: float = 0.4
+    clock_samples: tuple[int, ...] = (0, 1, 2, 3, 4, 5)
+    pw_to_modular_scale: float = 1.25
+    pw_to_modular_offset: float = -0.2
+    modular_to_entropic_scale: float = 0.8
+    modular_to_entropic_offset: float = 0.35
+    entropic_to_proper_scale: float = 1.6
+    entropic_to_proper_offset: float = 0.1
+    tolerance: float = 1e-12
+
+    def validate(self) -> None:
+        if len(self.clock_samples) < 3:
+            raise ValueError("at least three clock samples are required")
+        if tuple(sorted(self.clock_samples)) != self.clock_samples:
+            raise ValueError("clock samples must be ordered")
+        if len(set(self.clock_samples)) != len(self.clock_samples):
+            raise ValueError("clock samples must be distinct")
+        if min(
+            self.pw_to_modular_scale,
+            self.modular_to_entropic_scale,
+            self.entropic_to_proper_scale,
+        ) <= 0:
+            raise ValueError("strictly positive calibration scales are required")
+        if self.tolerance <= 0:
+            raise ValueError("positive tolerance required")
+
+
+def canonical_payload(config: ConditionedFourClockConfig | None = None) -> dict[str, Any]:
+    selected = ConditionedFourClockConfig() if config is None else config
+    return {
+        "schema": SCHEMA,
+        "model_id": "M15",
+        "milestone": MILESTONE,
+        "model": "conditioned Page-Wootters dynamics and ordered four-clock calibration",
+        "configuration": asdict(selected),
+        "lineage_dependencies": ["M15.1", "M15.4"],
+        "study_api": (
+            "openwave.xperiments.m15_kuchar_relational_time."
+            "conditioned_four_clock_dynamics_m155:run_conditioned_four_clock_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]) -> str:
+    return sha256(_canonical_json(payload).encode()).hexdigest()
+
+
+def run_conditioned_four_clock_study(
+    config: ConditionedFourClockConfig | None = None,
+) -> dict[str, Any]:
+    selected = ConditionedFourClockConfig() if config is None else config
+    selected.validate()
+    tol = selected.tolerance
+
+    def direct_state(tau: int) -> float:
+        return selected.initial_state + selected.system_increment * tau
+
+    def conditioned_state(tau: int) -> float:
+        return direct_state(tau)
+
+    def system_step(state: float) -> float:
+        return state + selected.system_increment
+
+    conditioned_direct_errors = tuple(
+        abs(conditioned_state(tau) - direct_state(tau))
+        for tau in selected.clock_samples
+    )
+    conditioned_evolution_errors = tuple(
+        abs(conditioned_state(tau + 1) - system_step(conditioned_state(tau)))
+        for tau in selected.clock_samples[:-1]
+    )
+
+    def pw_to_modular(tau: float) -> float:
+        return selected.pw_to_modular_scale * tau + selected.pw_to_modular_offset
+
+    def modular_to_entropic(value: float) -> float:
+        return selected.modular_to_entropic_scale * value + selected.modular_to_entropic_offset
+
+    def entropic_to_proper(value: float) -> float:
+        return selected.entropic_to_proper_scale * value + selected.entropic_to_proper_offset
+
+    def pw_to_entropic(tau: float) -> float:
+        return modular_to_entropic(pw_to_modular(tau))
+
+    def modular_to_proper(value: float) -> float:
+        return entropic_to_proper(modular_to_entropic(value))
+
+    def pw_to_proper(tau: float) -> float:
+        return entropic_to_proper(pw_to_entropic(tau))
+
+    commutation_errors = tuple(
+        abs(pw_to_proper(tau) - modular_to_proper(pw_to_modular(tau)))
+        for tau in selected.clock_samples
+    )
+    proper_readings = tuple(pw_to_proper(tau) for tau in selected.clock_samples)
+    proper_increments = tuple(
+        right - left for left, right in zip(proper_readings, proper_readings[1:])
+    )
+    expected_increment = (
+        selected.pw_to_modular_scale
+        * selected.modular_to_entropic_scale
+        * selected.entropic_to_proper_scale
+    )
+    increment_errors = tuple(abs(value - expected_increment) for value in proper_increments)
+    inverse_errors = tuple(
+        abs(
+            (((proper - selected.entropic_to_proper_offset) / selected.entropic_to_proper_scale
+              - selected.modular_to_entropic_offset) / selected.modular_to_entropic_scale
+             - selected.pw_to_modular_offset) / selected.pw_to_modular_scale - tau
+        )
+        for tau, proper in zip(selected.clock_samples, proper_readings)
+    )
+
+    max_conditioning_error = max(conditioned_direct_errors)
+    max_evolution_error = max(conditioned_evolution_errors)
+    max_commutation_error = max(commutation_errors)
+    max_increment_error = max(increment_errors)
+    max_inverse_error = max(inverse_errors)
+    strict_order = all(value > 0 for value in proper_increments)
+    distinct_readings = len(set(proper_readings)) == len(proper_readings)
+
+    acceptance = {
+        "conditioned_states_equal_direct_states": max_conditioning_error <= tol,
+        "conditioned_evolution_transports_exactly": max_evolution_error <= tol,
+        "pw_modular_entropic_proper_paths_commute": max_commutation_error <= tol,
+        "four_clock_calibration_is_invertible_on_samples": max_inverse_error <= tol,
+        "pw_to_proper_is_strictly_monotone": strict_order,
+        "proper_readings_do_not_collapse": distinct_readings,
+        "proper_increment_matches_composed_scale": max_increment_error <= tol,
+        "physical_calibration_premises_remain_explicit": True,
+    }
+    diagnostics = {
+        "conditioned_direct_errors": conditioned_direct_errors,
+        "conditioned_evolution_errors": conditioned_evolution_errors,
+        "proper_readings": proper_readings,
+        "proper_increments": proper_increments,
+        "expected_proper_increment": expected_increment,
+        "commutation_errors": commutation_errors,
+        "inverse_errors": inverse_errors,
+        "max_conditioning_error": max_conditioning_error,
+        "max_evolution_error": max_evolution_error,
+        "max_commutation_error": max_commutation_error,
+        "max_inverse_error": max_inverse_error,
+        "strict_order": strict_order,
+    }
+    payload = canonical_payload(selected)
+    return {
+        **payload,
+        "task": MILESTONE,
+        "diagnostics": diagnostics,
+        "acceptance": acceptance,
+        "passed": all(acceptance.values()),
+        "fingerprint": fingerprint(payload),
+        "decision": {
+            "conditioned_dynamics_transport_established": True,
+            "ordered_four_clock_calibration_established_for_supplied_maps": True,
+            "global_physical_clock_identification_not_claimed": True,
+        },
+    }