Chronotopic Metric Theory

Chronotopic Metric Theory (CTMT) Non–ontological, information–geometric framework for kernel–generated forward maps across operating regimes Chronotopic Metric Theory (CTMT) is developed as a non–ontological, information–geometric framework for assessing the admissibility of kernel–generated forward maps across operating regimes. No spacetime, metric, dynamical law, or physical ontology is postulated. The only primitive object is an oscillatory transport kernel whose induced Jacobian defines a Fisher information geometry on the space of observables. CTMT identifies three operational invariants—Fisher rigidity, coherence density, and coherence proper time—which together determine when a forward map remains stable, composable, and causally admissible under parameter transport. Causality is not assumed; it emerges as the requirement that Fisher conditioning be preserved under forward extension. Dimensionality, null directions, and effective metric structure arise as rank–level properties of the Fisher spectrum rather than as background geometric assumptions. All quantities in CTMT are computable from data and Jacobians, and all claims are falsifiable through rank loss, divergence of coherence density, or breakdown of differentiability. CTMT therefore provides a minimal, assumption–free criterion for when coarse–grained kernel models admit stable prediction and parameter transport, independent of any specific physical interpretation. Fisher Fixed‑Point Calibration & Single‑Tuning Transport Fixed‑point calibration: CTMT defines admissible calibration geometrically (no heuristics). A parameter value $\theta^\ast$ is Fisher‑admissible if\[\theta^\ast=\arg\min_{\theta}\Big[\ \kappa\!\bigl(F(\theta)\bigr)\ +\ \Gamma(\theta)\ \Big]\quad\text{s.t.}\quad\operatorname{rank}F(\theta)=\text{const},\]where $\kappa(F)$ penalizes ill‑conditioning (e.g. spectral condition number), $\Gamma(\theta)$ is a hazard/decoherence surrogate, and the rank constraint enforces a coherence class. Single‑tuning transport: When the fixed‑point holds, the mapping $Y \approx k\,\chi(\theta)$ admits a globally meaningful calibration constant $k$ across the coherence class. Loss of transportability corresponds to violation of rank or conditioning constraints and is diagnosed by Fisher degeneracy, not empirical drift. Partial/malformed data: CTMT handles missing/uncertain channels via masking $(M)$ and relative/normalized observables (e.g., amplitude normalized to a reference), which turn redundant directions into null Fisher curvature (eigenvalues $\approx 0$) while preserving essential physics. Example Python (plug‑&‑play) What this does: Implements the original oscillatory kernel and a series‑RLC coil forward map. Computes Jacobians and the Fisher matrix. Verifies CTMT invariants: monotonicity (coarse‑graining), redundancy/null curvature (relative amplitudes), rank/conditioning, composability. Solves a toy fixed‑point calibration and demonstrates single‑tuning transport across regimes with masked/relative observables. pythonimport numpy as np # =====================================================# 1) Oscillatory transport kernel (original intro style)# =====================================================def kernel_T(t, theta, Xi_func, S_star=1.0, n_steps=200): """ T(t; theta) = ∫_0^t Xi(t') * exp(i * phi(t,t') / S_* - eps * (t - t')) dt' Simple phase: phi(t,t') = omega * (t - t'), theta = [omega, eps] """ omega, eps = theta ts = np.linspace(0.0, t, n_steps) dt = ts[1] - ts[0] phase = omega * (t - ts) Xi = Xi_func(ts) integrand = Xi * np.exp(1j * phase / S_star - eps * (t - ts)) return np.sum(integrand) * dt def observable_Y(theta, times, Xi_func): """Y(theta) = [Re T(t1), Im T(t1), Re T(t2), Im T(t2), ...]""" vals = [] for t in times: T_val = kernel_T(t, theta, Xi_func) vals.extend([np.real(T_val), np.imag(T_val)]) return np.array(vals) # shape (2 * len(times),) def Xi_constant(ts): return np.ones_like(ts) def Xi_hann(ts, T_final=1.0): return 0.5 * (1.0 - np.cos(2.0 * np.pi * ts / T_final)) # =====================================================# 2) Series-RLC coil forward map (AD5933-band abstraction)# =====================================================def coil_forward_factory(freq, mask=None, ref_index=0): """ theta = [R, L, C, G]; Z(ω) = R + iωL + 1/(iωC) obs_mode: "complex" -> stack Re/Im; "amplitude" -> |GZ|; "relative" -> normalized amplitude (kills gain) mask simulates missing/malformed channels. """ omega = 2*np.pi*freq if mask is None: mask = np.ones_like(freq, dtype=bool) def fwd(theta, obs_mode="complex"): R, L, C, G = np.array(theta, dtype=float) Z = R + 1j*omega*L + 1/(1j*omega*C) Z = G * Z Zm = Z[mask] if obs_mode == "complex": return np.concatenate([Zm.real, Zm.imag]) amp = np.abs(Zm) if obs_mode == "amplitude": return amp if obs_mode == "relative": denom = max(amp[min(ref_index, len(amp)-1)], 1e-12) return amp / denom raise ValueError("obs_mode ∈ {'complex','amplitude','relative'}") return fwd # =====================================================# 3) Generic finite-difference Jacobian & Fisher# =====================================================def jacobian_fd(fwd, theta, obs_mode="complex", delta=1e-3): theta = np.array(theta, dtype=float) y0 = fwd(theta, obs_mode=obs_mode) d, m = len(theta), len(y0) J = np.zeros((m, d)) for j in range(d): e = np.zeros_like(theta); e[j] = 1.0 y_plus = fwd(theta + delta*e, obs_mode=obs_mode) y_minus = fwd(theta - delta*e, obs_mode=obs_mode) J[:, j] = (y_plus - y_minus) / (2.0*delta) return J def fisher_from_jacobian(J, sigma2=1e-6): return (J.T @ J) / sigma2 # C^{-1} = (1/sigma^2) I def condition_number(F): w = np.linalg.eigvalsh(F) w = np.clip(w, 0.0, None) return float(np.max(w) / (np.min(w[w>0]) if np.any(w>0) else np.inf)) # =====================================================# 4) CTMT checks: monotonicity, redundancy, rank/κ, composability# =====================================================def ctmt_checks(fwd, theta, obs_mode="complex", sigma2=1e-6): J = jacobian_fd(fwd, theta, obs_mode=obs_mode) F = fisher_from_jacobian(J, sigma2=sigma2) # Coarse-graining monotonicity (subsample measurement rows) J_cg = J[::2, :] F_cg = fisher_from_jacobian(J_cg, sigma2=sigma2 * 2.0) rng = np.random.default_rng(0) violations, max_diff = 0, -np.inf for _ in range(500): v = rng.standard_normal(F.shape[0]); v /= np.linalg.norm(v) q_full = float(v @ F @ v) q_cg = float(v @ F_cg @ v) if q_cg > q_full + 1e-10: violations += 1 max_diff = max(max_diff, q_cg - q_full) w = np.linalg.eigvalsh(F) return { "F": F, "eigvals": w, "rank": int(np.sum(w > 1e-10)), "kappa": condition_number(F), "monotonicity_violations": violations, "monotonicity_max_diff": None if max_diff == -np.inf else float(max_diff) } # =====================================================# 5) Fixed-point (toy grid search) & hazard (||F - F_cg||_2)# =====================================================def fixed_point_grid(fwd, theta_bounds, obs_mode="relative", steps=7, sigma2=1e-6, target_rank=None): grids = [np.linspace(lo, hi, steps) for (lo, hi) in theta_bounds] best = {"obj": np.inf, "theta": None, "report": None} for vals in np.stack(np.meshgrid(*grids), axis=-1).reshape(-1, len(theta_bounds)): theta = np.array(vals, dtype=float) J = jacobian_fd(fwd, theta, obs_mode=obs_mode) F = fisher_from_jacobian(J, sigma2=sigma2) J_cg = J[::2, :] F_cg = fisher_from_jacobian(J_cg, sigma2=sigma2*2.0) hazard = float(np.linalg.norm(F_cg - F, ord=2)) w = np.linalg.eigvalsh(F) rank = int(np.sum(w > 1e-10)) kappa = condition_number(F) if (target_rank is not None) and (rank != target_rank): continue obj = kappa + hazard if obj < best["obj"]: best = {"obj": obj, "theta": theta, "report": {"rank": rank, "kappa": kappa, "hazard": hazard}} return best # =====================================================# 6) Single-tuning transport (one k across regimes)# =====================================================def single_tuning_constant(y_ref, chi_ref): num = float(np.vdot(chi_ref, y_ref)) den = float(np.vdot(chi_ref, chi_ref)) + 1e-12 return num / den # =====================================================# 7) Sample experiment (oscillatory kernel + coil + shells)# =====================================================if __name__ == "__main__": # --- A) Original oscillatory kernel example --- theta_true = np.array([10.0, 2.0]) # omega, eps times = np.linspace(0.1, 1.0, 5) Xi = Xi_hann # Build Jacobian and Fisher Y0 = observable_Y(theta_true, times, Xi) J0 = np.zeros((Y0.size, theta_true.size)) for j in range(theta_true.size): e = np.zeros_like(theta_true); e[j] = 1.0 Yp = observable_Y(theta_true + 1e-3*e, times, Xi) Ym = observable_Y(theta_true - 1e-3*e, times, Xi) J0[:, j] = (Yp - Ym) / (2e-3) F0 = fisher_from_jacobian(J0, sigma2=1e-2) evals0, _ = np.linalg.eigh(F0) print("[Kernel] J shape:", J0.shape) print("[Kernel] eigenvalues:", evals0) # --- B) Coil demo (AD5933-band abstraction; masked + relative amplitude) --- freq = np.geomspace(5e2, 8e4, 801) mask = np.ones_like(freq, dtype=bool); mask[::5] = False # simulate malformed/missing channels fwd_coil = coil_forward_factory(freq, mask=mask, ref_index=0) theta_coil = np.array([12.0, 5.0e-3, 5.0e-7, 1.0]) # R, L, C, G rep_complex = ctmt_checks(fwd_coil, theta_coil, obs_mode="complex") print("[Coil/complex] rank=", rep_complex["rank"], " kappa=", rep_complex["kappa"],