mtft 0.3.0__py3-none-any.whl

mtft/__init__.py

@@ -0,0 +1,44 @@
+"""
+MTFT — Modular Time Field Theory  (v0.3.0)
+============================================
+
+16 modules covering the complete MTFT framework from arithmetic
+weights through lattice gauge theory and experimental verification.
+"""
+
+__version__ = "0.3.0"
+
+# ── Tier 0: Constants & Arithmetic ───────────────────────────
+from mtft.constants import (
+    SM, GAUGE, HIGGS, PDG, PhysicalConstants, CriticalDepths, MassRatios,
+    FEIGENBAUM_DELTA, FEIGENBAUM_ALPHA, T_INF, LAMBERT_OMEGA, EULER_GAMMA,
+    QUARKS, LEPTONS, ZETA_2, XI,
+)
+from mtft.arithmetic import (
+    weight, weight_array, damped_weights,
+    S1, stiffness_S, center_stiffness, mass_gap_stiffness,
+    su3_hessian_eigenvalues, find_confinement_depth,
+)
+
+# ── Tier 1: Modular Geometry & Forms ─────────────────────────
+from mtft.modular import TauField, sl2z_transform
+from mtft.forms import dedekind_eta, jacobi_theta3, eisenstein_E2k, verify_spectral_identity
+
+# ── Tier 2: Gauge-Higgs ──────────────────────────────────────
+from mtft.hosotani import HosotaniPotential
+from mtft.particles import Particle, StandardModel
+
+# ── Tier 3: Phenomenology ────────────────────────────────────
+from mtft.dark_sector import TauVortexHalo, rotation_curve, tully_fisher
+from mtft.info_geometry import fisher_rao_metric, ricci_scalar_logistic
+from mtft.cosmology import FriedmannMTFT
+
+# ── Tier 4: Lattice & Fermions ───────────────────────────────
+from mtft.lattice import LatticeConfig, MTFTAction, metropolis_sweep, avg_plaquette, avg_polyakov
+from mtft.x0_143 import tano_mass_predictions, koide_angle_tano, generation_count, JACOBIAN
+from mtft.koide import koide_ratio, koide_leptons, predict_tau_mass, koide_manifold_point
+from mtft.burning_ship import burning_ship_iterate, ANISOTROPIC
+
+# ── Tier 5: Dimensional Bridge & Decay ───────────────────────
+from mtft.dimensional_bridge import electron_mass_from_eta, charge_from_feigenbaum
+from mtft.decay import ModularDecay

mtft/arithmetic.py

@@ -0,0 +1,234 @@
+"""
+MTFT Arithmetic Weights and Holonomy Stiffness
+================================================
+
+The arithmetic weights wₙ = Σ_{d|n} (log d)/d are the atoms of MTFT.
+Their Dirichlet series satisfies W(s) = −ζ(s)ζ′(s+1).
+
+Key series at modular depth y:
+    aₙ(y)  = wₙ e^{−2πyn}      (damped weights)
+    S₁(y)  = Σ aₙ(y)           (partition function / stiffness action)
+    S(y)   = Σ n² aₙ(y)        (holonomy stiffness)
+    C_N(y) = Σ n² aₙ(y) cos(2πn/N)  (center-projected stiffness)
+    μ_N(y) = min_m Σ n² aₙ(y) (1 − cos(2πnm/N))  (mass gap)
+
+The fine-structure constant is α⁻¹ = 2/S₁(y_spec).
+The confinement lock is C_3(y_conf) = 0  (Hessian isotropy).
+
+Reference: Papers 5, 7, 9, 13, 24; Dictionary IV–V.
+"""
+
+from __future__ import annotations
+
+import math
+from functools import lru_cache
+
+import numpy as np
+
+
+# ── Arithmetic weight function ───────────────────────────────
+
+def weight(n: int) -> float:
+    """
+    Compute wₙ = Σ_{d|n} (log d)/d.
+
+    These are rigid number-theoretic objects — not fitted.
+    w₁ = 0, w₂ = (log 2)/2, w₃ = (log 3)/3, w₆ = w₂ + w₃ + (log 6)/6, ...
+    """
+    if n < 1:
+        raise ValueError("n must be ≥ 1")
+    total = 0.0
+    for d in range(1, n + 1):
+        if n % d == 0:
+            if d > 1:
+                total += math.log(d) / d
+    return total
+
+
+@lru_cache(maxsize=8192)
+def _weight_cached(n: int) -> float:
+    return weight(n)
+
+
+def weight_array(n_max: int) -> np.ndarray:
+    """Compute wₙ for n = 1, ..., n_max as a NumPy array."""
+    return np.array([_weight_cached(n) for n in range(1, n_max + 1)])
+
+
+# ── Euler-shifted weights (Paper 20) ─────────────────────────
+
+def weight_euler(n: int) -> float:
+    """
+    Euler-shifted weight: w_n^(e) = w_n + σ_{-1}(n).
+
+    The substitution log k → log(ek) activates w₁ = 0 → w₁^(e) = 1,
+    creating the electron as the vacuum's first excitation.
+    """
+    sigma_minus1 = sum(1.0 / d for d in range(1, n + 1) if n % d == 0)
+    return weight(n) + sigma_minus1
+
+
+# ── Damped coefficients ──────────────────────────────────────
+
+def damped_weight(n: int, y: float) -> float:
+    """aₙ(y) = wₙ exp(−2πyn)."""
+    return _weight_cached(n) * math.exp(-2.0 * math.pi * y * n)
+
+
+def damped_weights(y: float, n_max: int = 500) -> np.ndarray:
+    """Array of aₙ(y) for n = 1..n_max."""
+    ns = np.arange(1, n_max + 1)
+    ws = weight_array(n_max)
+    return ws * np.exp(-2.0 * math.pi * y * ns)
+
+
+# ── Stiffness series ─────────────────────────────────────────
+
+def S1(y: float, n_max: int = 500) -> float:
+    """
+    Partition function / stiffness action:
+        S₁(y) = Σ wₙ e^{−2πyn}
+
+    The fine-structure constant is α⁻¹ = 2/S₁(y_spec).
+    """
+    return float(np.sum(damped_weights(y, n_max)))
+
+
+def stiffness_S(y: float, n_max: int = 500) -> float:
+    """
+    Holonomy stiffness:
+        S(y) = Σ n² wₙ e^{−2πyn}
+    """
+    ns = np.arange(1, n_max + 1)
+    ws = weight_array(n_max)
+    return float(np.sum(ns**2 * ws * np.exp(-2 * math.pi * y * ns)))
+
+
+def center_stiffness(y: float, N: int = 3, n_max: int = 500) -> float:
+    """
+    Z_N center-projected stiffness:
+        C_N(y) = Σ n² wₙ e^{−2πyn} cos(2πn/N)
+
+    C_3(y_conf) = 0 is the confinement lock.
+    """
+    ns = np.arange(1, n_max + 1)
+    ws = weight_array(n_max)
+    cos_terms = np.cos(2.0 * math.pi * ns / N)
+    return float(np.sum(ns**2 * ws * np.exp(-2 * math.pi * y * ns) * cos_terms))
+
+
+def mass_gap_stiffness(y: float, N: int = 3, n_max: int = 500) -> float:
+    """
+    SU(N) mass gap stiffness (minimum over modes m):
+        μ_N(y) = min_{m=1..N-1} Σ n² wₙ e^{−2πyn} (1 − cos(2πnm/N))
+
+    Theorem: μ_N(y) > 0 unconditionally for all N≥2, y>0.
+    """
+    ns = np.arange(1, n_max + 1)
+    ws = weight_array(n_max)
+    damped = ns**2 * ws * np.exp(-2 * math.pi * y * ns)
+
+    mu_min = float("inf")
+    for m in range(1, N):
+        gap_terms = 1.0 - np.cos(2 * math.pi * ns * m / N)
+        mu_m = float(np.sum(damped * gap_terms))
+        mu_min = min(mu_min, mu_m)
+    return mu_min
+
+
+# ── SU(3) Hessian eigenvalues (Paper 5 §24.4, Bridge §4.3) ──
+
+def su3_hessian_eigenvalues(y: float, n_max: int = 500) -> tuple[float, float]:
+    """
+    SU(3) holonomy Hessian eigenvalues:
+        λ₁ = (S_N + 2C_N) / 3
+        λ₂ = (S_N − C_N) / 3
+
+    At y_conf ≈ 0.18174:  λ₁/λ₂ = 1.000001 (the spectral lock).
+    """
+    S = stiffness_S(y, n_max)
+    C = center_stiffness(y, N=3, n_max=n_max)
+    lam1 = (S + 2 * C) / 3.0
+    lam2 = (S - C) / 3.0
+    return lam1, lam2
+
+
+def find_confinement_depth(
+    y_min: float = 0.10, y_max: float = 0.25, tol: float = 1e-8, n_max: int = 500
+) -> float:
+    """
+    Find y_conf where C_3(y) = 0 (SU(3) Hessian isotropy).
+
+    Uses bisection on C_3(y).
+    """
+    # C_3 starts positive and crosses zero
+    c_lo = center_stiffness(y_min, N=3, n_max=n_max)
+    c_hi = center_stiffness(y_max, N=3, n_max=n_max)
+
+    if c_lo * c_hi > 0:
+        # Try a wider scan
+        for y_test in np.linspace(y_min, y_max, 200):
+            c_test = center_stiffness(y_test, N=3, n_max=n_max)
+            if c_test * c_lo < 0:
+                y_max = y_test
+                c_hi = c_test
+                break
+
+    lo, hi = y_min, y_max
+    for _ in range(100):
+        mid = (lo + hi) / 2.0
+        c_mid = center_stiffness(mid, N=3, n_max=n_max)
+        if abs(c_mid) < tol:
+            return mid
+        if c_mid * c_lo > 0:
+            lo = mid
+            c_lo = c_mid
+        else:
+            hi = mid
+    return (lo + hi) / 2.0
+
+
+# ── Lambert series ───────────────────────────────────────────
+
+def lambert_series(q: complex, n_max: int = 200) -> complex:
+    """
+    MTFT Lambert series: W(q) = Σ_{d≥1} (log d)/d · q^d/(1−q^d).
+
+    This is the q-series feeding the modular holonomy potential.
+    """
+    total = 0.0 + 0j
+    for d in range(2, n_max + 1):
+        qd = q ** d
+        if abs(1.0 - qd) < 1e-30:
+            continue
+        total += (math.log(d) / d) * qd / (1.0 - qd)
+    return total
+
+
+# ── Torque flux convergence (Paper 7, §9) ────────────────────
+
+def torque_partial_sum(N: int) -> float:
+    """
+    Partial sum of the normalised torque: (1/N²) Σ_{n=1}^{N} n·wₙ.
+
+    Converges to T∞ = −ζ′(2)/2 ≈ 0.4688.
+    """
+    total = 0.0
+    for n in range(1, N + 1):
+        total += n * _weight_cached(n)
+    return total / (N ** 2)
+
+
+# ── Dirichlet series identity check ──────────────────────────
+
+def dirichlet_F(s: complex, n_max: int = 500) -> complex:
+    """
+    Compute F(s) = Σ f(n)/n^s where f = σ * Λ.
+
+    Should equal −ζ(s−1)ζ′(s) (the master Dirichlet identity).
+    """
+    total = 0.0 + 0j
+    for n in range(1, n_max + 1):
+        f_n = sum(math.log(d) for d in range(1, n + 1) if n % d == 0)
+        total += f_n / n ** s
+    return total

mtft/burning_ship.py

@@ -0,0 +1,202 @@
+"""
+Burning Ship Fractal: The Fermion Vacuum
+=========================================
+
+The Burning Ship iteration:
+    z_{n+1} = (|Re(z_n)| + i|Im(z_n)|)² + c
+
+Unlike the Mandelbrot z² + c (analytic), the absolute values create
+fold lines where the map is non-analytic. This governs the fermion
+sector of MTFT:
+
+    Mandelbrot (analytic)      → gauge sector  → Yang-Mills mass gap
+    Burning Ship (non-analytic) → fermion sector → Koide formula
+
+Phase space has four sectors from sgn(x), sgn(y):
+    S₊₊, S₋₊, S₊₋, S₋₋
+
+with Jacobian:
+    J = [[2x, −2y], [2 sgn(x)sgn(y)|y|, 2 sgn(x)sgn(y)|x|]]
+    det(J) = 4|z|²  (continuous)
+    tr(J)  = 2x + 2 sgn(x)sgn(y)|x|  (discontinuous at x=0)
+
+Anisotropic Feigenbaum constants:
+    δₓ ≈ 7.30 (attractor fold, quark direction)
+    δᵧ ≈ 3.38 (barrier fold, lepton direction)
+    β_x = +0.29, β_y = −0.21, |β_x| + |β_y| = 1/2
+
+Reference: Paper 4, Paper 6, Chapter 10–11.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import numpy as np
+
+from mtft.constants import FEIGENBAUM_DELTA, DELTA_X, DELTA_Y, BETA_X, BETA_Y
+
+
+# ═══════════════════════════════════════════════════════════════
+#  Burning Ship Iteration
+# ═══════════════════════════════════════════════════════════════
+
+def burning_ship_iterate(c: complex, max_iter: int = 200, escape: float = 100.0) -> int:
+    """
+    Iterate z_{n+1} = (|Re z| + i|Im z|)² + c.
+
+    Returns escape time (max_iter if bounded).
+    """
+    z = 0.0 + 0.0j
+    for n in range(max_iter):
+        x, y = abs(z.real), abs(z.imag)
+        z = complex(x, y) ** 2 + c
+        if abs(z) > escape:
+            return n
+    return max_iter
+
+
+def burning_ship_array(
+    re_range: tuple = (-2.5, 1.5),
+    im_range: tuple = (-2.0, 1.0),
+    resolution: int = 500,
+    max_iter: int = 200,
+) -> np.ndarray:
+    """
+    Compute escape-time array for the Burning Ship fractal.
+
+    Returns (resolution × resolution) integer array.
+    """
+    re = np.linspace(re_range[0], re_range[1], resolution)
+    im = np.linspace(im_range[0], im_range[1], resolution)
+    result = np.zeros((resolution, resolution), dtype=int)
+    for i, y in enumerate(im):
+        for j, x in enumerate(re):
+            result[i, j] = burning_ship_iterate(complex(x, y), max_iter)
+    return result
+
+
+# ═══════════════════════════════════════════════════════════════
+#  Phase Space Sectors and Jacobian
+# ═══════════════════════════════════════════════════════════════
+
+def sector(z: complex) -> str:
+    """Identify the phase-space sector of z."""
+    sx = "+" if z.real >= 0 else "-"
+    sy = "+" if z.imag >= 0 else "-"
+    return f"S_{sx}{sy}"
+
+
+def jacobian(z: complex) -> np.ndarray:
+    """
+    Jacobian of the Burning Ship map at z = x + iy:
+
+        J = [[2x, −2y],
+             [2 sgn(x)sgn(y)|y|, 2 sgn(x)sgn(y)|x|]]
+
+    det(J) = 4|z|² (continuous across folds)
+    tr(J) = 2x + 2 sgn(x)sgn(y)|x| (discontinuous at x=0)
+    """
+    x, y = z.real, z.imag
+    sx = 1.0 if x >= 0 else -1.0
+    sy = 1.0 if y >= 0 else -1.0
+    return np.array([
+        [2 * x, -2 * y],
+        [2 * sx * sy * abs(y), 2 * sx * sy * abs(x)],
+    ])
+
+
+def jacobian_determinant(z: complex) -> float:
+    """det(J) = 4|z|² — continuous across all folds."""
+    return 4.0 * abs(z) ** 2
+
+
+def jacobian_trace(z: complex) -> float:
+    """tr(J) = 2x + 2 sgn(x)sgn(y)|x| — discontinuous at x=0."""
+    x, y = z.real, z.imag
+    sx = 1.0 if x >= 0 else -1.0
+    sy = 1.0 if y >= 0 else -1.0
+    return 2.0 * x + 2.0 * sx * sy * abs(x)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  Anisotropic Feigenbaum Constants
+# ═══════════════════════════════════════════════════════════════
+
+@dataclass(frozen=True)
+class AnisotropicScaling:
+    """
+    Anisotropic universality of the Burning Ship (Paper 4).
+
+    The standard Feigenbaum δ splits into direction-dependent constants:
+        δₓ ≈ δ^1.29 ≈ 7.30  (attractor fold / quark direction)
+        δᵧ ≈ δ^0.79 ≈ 3.38  (barrier fold / lepton direction)
+
+    Fold approach exponents:
+        β_x = +0.29  (attractor approach rate)
+        β_y = −0.21  (barrier approach rate)
+        |β_x| + |β_y| = 1/2  (fold budget constraint)
+
+    Power laws:
+        δ ∝ ρ_x^{+0.29}  (x-fold)
+        δ ∝ ρ_y^{−0.21}  (y-fold)
+    """
+    delta: float = FEIGENBAUM_DELTA
+    delta_x: float = DELTA_X
+    delta_y: float = DELTA_Y
+    beta_x: float = BETA_X
+    beta_y: float = BETA_Y
+
+    @property
+    def fold_budget(self) -> float:
+        """Should be ≈ 0.5."""
+        return abs(self.beta_x) + abs(self.beta_y)
+
+    def generation_mass_ratio(self, direction: str = "lepton") -> float:
+        """
+        Mass ratio between adjacent generations:
+            m_{n+1}/m_n ~ δ_eff²
+
+        For leptons: δ_y² ≈ 11.4
+        For quarks:  δ_x² ≈ 53.3
+        """
+        d = self.delta_y if direction == "lepton" else self.delta_x
+        return d ** 2
+
+
+ANISOTROPIC = AnisotropicScaling()
+
+
+# ═══════════════════════════════════════════════════════════════
+#  Fold Proximity Data (Paper 4, Table 2)
+# ═══════════════════════════════════════════════════════════════
+
+FOLD_PROXIMITY = {
+    # period: (min_|x|, min_|y|, x_crossings, y_crossings)
+    3:   (2.51e-1, 4.31e-1, 0, 0),
+    6:   (4.37e-2, 1.32e-1, 3, 0),
+    12:  (2.82e-2, 4.72e-2, 3, 0),
+    24:  (2.22e-2, 8.35e-4, 7, 4),
+    48:  (7.02e-3, 1.92e-3, 15, 4),
+    384: (9.02e-4, 2.60e-6, 255, 128),
+    768: (1.11e-5, 3.70e-6, 511, 255),
+}
+
+
+# ═══════════════════════════════════════════════════════════════
+#  Three Generations from Self-Similar Satellites (Paper 6 §5)
+# ═══════════════════════════════════════════════════════════════
+
+def satellite_mass_scale(n: int, delta_eff: float = None) -> float:
+    """
+    Mass scale of the n-th generation satellite relative to 1st:
+
+        m_n / m_1 ~ δ_eff^{−2(n−1)}
+
+    Higher-order satellites (n ≥ 4) fall below the EW scale
+    and are not realised as stable particles.
+    """
+    if delta_eff is None:
+        delta_eff = DELTA_Y
+    return delta_eff ** (-2 * (n - 1))