coordinate-system 7.0.0__cp313-cp313-win_amd64.whl → 7.0.2__cp313-cp313-win_amd64.whl

coordinate_system/complex_geometric_physics.py

@@ -1,41 +1,56 @@
-"""
-Complex Geometric Physics - Unified Framework
-================================================================================
-
-Implementation of the "Christmas Equation" and Complex Frame Unified Theory (CFUT)
-
-The Christmas Equation (Complete complex form):
-    M_P²/2 Ĝ_μν[U] + λ/(32π²) ∇̂_(μ K̄_ν)[U] = T̂_μν^(top)[U] + T̂_μν^(mat)
-
-Where:
-    - Ĝ_μν: Einstein tensor from complex frame U(x)
-    - K̄_μ: Chern-Simons current (topological)
-    - T̂_μν^(top): Topological energy-momentum tensor
-    - T̂_μν^(mat): Matter energy-momentum tensor
-
-Core Theory:
-    - Universe as U(3) complex frame field: U(x) ∈ U(3)
-    - Real-imaginary decomposition: U = U^(R) + iU^(I)
-    - Real part: geometric properties (metric, curvature, spacetime)
-    - Imaginary part: topological properties (phase winding, gauge symmetry)
-
-Physical Interpretation:
-    - Geometry + Topology = Complex Matter + Topological Force
-    - Unifies gravity, gauge fields, dark matter, and topology
-
-Author: Enhanced by AI following theoretical framework
-Date: 2025-01-14
-Version: 7.0.0-alpha
-"""
-
-__version__ = '7.0.0-alpha'
+"""
+Complex Geometric Physics - Unified Framework
+================================================================================
+
+Implementation of the "Christmas Equation" and Complex Frame Unified Theory (CFUT).
+
+The Christmas Equation (complete complex form):
+    (M_P^2 / 2) Ĝ_{μν}[U] + (λ / (32π^2)) ∇̂_{(μ} K̄_{ν)}[U]
+        = T̂_{μν}^{(top)}[U] + T̂_{μν}^{(mat)}
+
+Where:
+    - Ĝ_{μν}: Einstein tensor from complex frame U(x)
+    - K̄_μ: Chern-Simons current (topological)
+    - T̂_{μν}^{(top)}: Topological energy-momentum tensor
+    - T̂_{μν}^{(mat)}: Matter energy-momentum tensor
+
+Core Theory:
+    - Universe as U(3) complex frame field: U(x) ∈ U(3)
+    - Real-imaginary decomposition: U = U^(R) + i U^(I)
+    - Real part: geometric properties (metric, curvature, spacetime)
+    - Imaginary part: topological properties (phase winding, gauge symmetry)
+
+Physical Interpretation:
+    - Geometry + Topology = Complex Matter + Topological Force
+    - Unifies gravity, gauge fields, dark matter, and topology
+
+**Authors:** Pan Guojun
+Date: 2025-01-14
+Version: 7.0.1
+**DOI:** https://doi.org/10.5281/zenodo.14435613
+"""
+
+__version__ = '7.0.1'
 
 import numpy as np
 from typing import Tuple, Optional, Callable, Dict, Any
 from dataclasses import dataclass
 import warnings
 
-# Physical constants (natural units: ℏ = c = 1)
+# Physical constants (SI units for precision calculations)
+HBAR_SI = 1.054571817e-34  # Reduced Planck constant [J·s]
+H_PLANCK_SI = 6.62607015e-34  # Planck constant [J·s]
+C_LIGHT_SI = 2.99792458e8  # Speed of light [m/s]
+E_CHARGE_SI = 1.602176634e-19  # Elementary charge [C]
+EPSILON_0_SI = 8.8541878128e-12  # Vacuum permittivity [F/m]
+M_ELECTRON_SI = 9.1093837015e-31  # Electron mass [kg]
+
+# Derived constants
+ALPHA_FS = E_CHARGE_SI**2 / (4 * np.pi * EPSILON_0_SI * HBAR_SI * C_LIGHT_SI)  # Fine structure constant ≈ 1/137
+LAMBDA_C = H_PLANCK_SI / (M_ELECTRON_SI * C_LIGHT_SI)  # Compton wavelength [m]
+ALPHA_PROJECTION = ALPHA_FS * LAMBDA_C  # Projection factor α ≈ 1.77×10⁻¹⁴ m
+
+# Physical constants (natural units: ℏ = c = 1)
 M_PLANCK = 2.435e18  # Planck mass [GeV]
 LAMBDA_TOPO = 0.1008  # Topological coupling constant (from theory)
 HBAR = 1.0  # Reduced Planck constant (natural units)
@@ -53,77 +68,33 @@ except ImportError:
         FieldStrength = None
         warnings.warn("U3Frame not available. Some features will be limited.")
 
+# Compatibility alias for older APIs.
+ComplexFrame = U3Frame
+
 
 # ============================================================
 # Core Data Structures
 # ============================================================
 
 @dataclass
-class ComplexFrame:
-    """
-    Complex frame field U(x) = U^(R)(x) + iU^(I)(x)
-
-    Attributes:
-        real_part: Real part U^(R) - geometric properties
-        imag_part: Imaginary part U^(I) - topological properties
-        position: Spacetime position (x, y, z, t)
-    """
-    real_part: np.ndarray  # 3×3 real matrix
-    imag_part: np.ndarray  # 3×3 real matrix
-    position: Optional[np.ndarray] = None  # (x, y, z, t)
+class EnergyMomentumTensor:
+    """
+    Energy-momentum tensor T_{μν}
+
+    Decomposition:
+        T_{μν} = T_{μν}^{(R)} + i T_{μν}^{(I)}
+        - Real part: mass-energy density
+        - Imaginary part: charge current
+    """
+    real_part: np.ndarray  # 4×4 real symmetric tensor
+    imag_part: np.ndarray  # 4×4 real tensor
 
     def __post_init__(self):
-        """Validate complex frame structure"""
-        if self.real_part.shape != (3, 3):
-            raise ValueError(f"Real part must be 3×3, got {self.real_part.shape}")
-        if self.imag_part.shape != (3, 3):
-            raise ValueError(f"Imaginary part must be 3×3, got {self.imag_part.shape}")
-
-    @property
-    def complex_matrix(self) -> np.ndarray:
-        """Full complex matrix U = U^(R) + iU^(I)"""
-        return self.real_part + 1j * self.imag_part
-
-    @property
-    def metric_tensor(self) -> np.ndarray:
-        """
-        Metric tensor from real part: g_μν = U^(R)ᵀ U^(R)
-
-        Returns:
-            3×3 metric tensor
-        """
-        return self.real_part.T @ self.real_part
-
-    @property
-    def gauge_potential(self) -> np.ndarray:
-        """
-        Gauge potential from imaginary part: A_μ ∝ U^(I)
-
-        Returns:
-            3×3 anti-Hermitian matrix
-        """
-        return 1j * self.imag_part
-
-
-@dataclass
-class EnergyMomentumTensor:
-    """
-    Energy-momentum tensor T_μν
-
-    Decomposition:
-        T_μν = T_μν^(R) + iT_μν^(I)
-        - Real part: mass-energy density
-        - Imaginary part: charge current
-    """
-    real_part: np.ndarray  # 4×4 real symmetric tensor
-    imag_part: np.ndarray  # 4×4 real tensor
-
-    def __post_init__(self):
-        """Validate tensor structure"""
-        if self.real_part.shape != (4, 4):
-            raise ValueError(f"Real part must be 4×4, got {self.real_part.shape}")
-        if self.imag_part.shape != (4, 4):
-            raise ValueError(f"Imaginary part must be 4×4, got {self.imag_part.shape}")
+        """Validate tensor structure"""
+        if self.real_part.shape != (4, 4):
+            raise ValueError(f"Real part must be 4×4, got {self.real_part.shape}")
+        if self.imag_part.shape != (4, 4):
+            raise ValueError(f"Imaginary part must be 4×4, got {self.imag_part.shape}")
 
     @property
     def complex_tensor(self) -> np.ndarray:
@@ -143,43 +114,47 @@ class EnergyMomentumTensor:
 # Christmas Equation Implementation
 # ============================================================
 
-class ChristmasEquation:
-    """
-    The Christmas Equation - Unified field equation
-
-    Complete form:
-        M_P²/2 Ĝ_μν[U] + λ/(32π²) ∇̂_(μ K̄_ν)[U] = T̂_μν^(top)[U] + T̂_μν^(mat)
-
-    Components:
-        - Left side: Geometry + Topology
-        - Right side: Topological source + Matter source
-    """
-
-    def __init__(self,
-                 planck_mass: float = M_PLANCK,
-                 topo_coupling: float = LAMBDA_TOPO):
-        """
-        Initialize Christmas Equation solver
-
-        Args:
-            planck_mass: Planck mass M_P [GeV]
-            topo_coupling: Topological coupling constant λ
-        """
+class ChristmasEquation:
+    """
+    The Christmas Equation - unified field equation
+
+    Complete form:
+        (M_P^2 / 2) Ĝ_{μν}[U] + (λ / (32π^2)) ∇̂_{(μ} K̄_{ν)}[U]
+            = T̂_{μν}^{(top)}[U] + T̂_{μν}^{(mat)}
+
+    Components:
+        - Left side: Geometry + Topology
+        - Right side: Topological source + Matter source
+    """
+
+    def __init__(self,
+                 planck_mass: float = M_PLANCK,
+                 topo_coupling: float = LAMBDA_TOPO,
+                 projection_factor: float = ALPHA_PROJECTION):
+        """
+        Initialize Christmas Equation solver.
+
+        Args:
+            planck_mass: Planck mass M_P [GeV]
+            topo_coupling: Topological coupling constant λ
+            projection_factor: Projection factor α = α_fs × λ_c [m]
+        """
         self.M_P = planck_mass
         self.lambda_topo = topo_coupling
-
-    def einstein_tensor(self, frame: ComplexFrame) -> np.ndarray:
-        """
-        Compute Einstein tensor Ĝ_μν from complex frame
-
-        Ĝ_μν = R_μν - (1/2)g_μν R
-
-        Args:
-            frame: Complex frame field U(x)
-
-        Returns:
-            3×3 Einstein tensor (spatial part)
-        """
+        self.alpha_proj = projection_factor
+
+    def einstein_tensor(self, frame: U3Frame) -> np.ndarray:
+        """
+        Compute Einstein tensor Ĝ_{μν} from complex frame.
+
+        Ĝ_{μν} = R_{μν} - (1/2) g_{μν} R
+
+        Args:
+            frame: Complex frame field U(x)
+
+        Returns:
+            3×3 Einstein tensor (spatial part)
+        """
         # Extract metric from real part
         g = frame.metric_tensor
 
@@ -196,14 +171,14 @@ class ChristmasEquation:
 
         return G_tensor
 
-    def chern_simons_current(self, frame: ComplexFrame) -> np.ndarray:
-        """
-        Compute Chern-Simons current K̄_μ from imaginary part
-
-        K̄_μ = ε_μνρσ Tr(A^ν F^ρσ - (2/3)A^ν A^ρ A^σ)
-
-        Args:
-            frame: Complex frame field U(x)
+    def chern_simons_current(self, frame: U3Frame) -> np.ndarray:
+        """
+        Compute Chern-Simons current K̄_μ from imaginary part.
+
+        K̄_μ = ε_{μνρσ} Tr(A^ν F^{ρσ} - (2/3) A^ν A^ρ A^σ)
+
+        Args:
+            frame: Complex frame field U(x)
 
         Returns:
             4-vector Chern-Simons current
@@ -223,9 +198,9 @@ class ChristmasEquation:
 
         return K_current
 
-    def topological_energy_momentum(self, frame: ComplexFrame) -> EnergyMomentumTensor:
-        """
-        Compute topological energy-momentum tensor T̂_μν^(top)
+    def topological_energy_momentum(self, frame: U3Frame) -> EnergyMomentumTensor:
+        """
+        Compute topological energy-momentum tensor T̂_{μν}^{(top)}.
 
         From topological defects (instantons, vortices)
 
@@ -252,13 +227,14 @@ class ChristmasEquation:
 
         return EnergyMomentumTensor(T_real, T_imag)
 
-    def solve_christmas_equation(self,
-                                 frame: ComplexFrame,
-                                 matter_tensor: EnergyMomentumTensor) -> Dict[str, Any]:
-        """
-        Solve the Christmas Equation
-
-        M_P²/2 Ĝ_μν + λ/(32π²) ∇̂_(μ K̄_ν) = T̂_μν^(top) + T̂_μν^(mat)
+    def solve_christmas_equation(self,
+                                 frame: U3Frame,
+                                 matter_tensor: EnergyMomentumTensor) -> Dict[str, Any]:
+        """
+        Solve the Christmas Equation.
+
+        (M_P^2 / 2) Ĝ_{μν} + (λ / (32π^2)) ∇̂_{(μ} K̄_{ν)}
+            = T̂_{μν}^{(top)} + T̂_{μν}^{(mat)}
 
         Args:
             frame: Complex frame field U(x)
@@ -301,12 +277,12 @@ class ChristmasEquation:
 
     # -------------------- Internal Helper Methods --------------------
 
-    def _compute_ricci_tensor(self, frame: ComplexFrame) -> np.ndarray:
+    def _compute_ricci_tensor(self, frame: U3Frame) -> np.ndarray:
         """
         Compute Ricci tensor from frame (simplified)
 
-        In full implementation, use intrinsic gradient method:
-        R_μν = [G_μ, G_ν] where G_μ = ∂_μ log U
+        In full implementation, use intrinsic gradient method:
+        R_{μν} = [G_μ, G_ν] where G_μ = ∂_μ log U
 
         Args:
             frame: Complex frame field
@@ -323,9 +299,9 @@ class ChristmasEquation:
 
         return R
 
-    def _compute_field_strength(self, frame: ComplexFrame) -> np.ndarray:
+    def _compute_field_strength(self, frame: U3Frame) -> np.ndarray:
         """
-        Compute field strength tensor F_μν = ∂_μ A_ν - ∂_ν A_μ + [A_μ, A_ν]
+        Compute field strength tensor F_{μν} = ∂_μ A_ν - ∂_ν A_μ + [A_μ, A_ν]
 
         Args:
             frame: Complex frame field
@@ -335,14 +311,14 @@ class ChristmasEquation:
         """
         A = frame.gauge_potential
 
-        # Simplified: F ≈ [A, A]
+        # Simplified: F ~= [A, A]
         F = A @ A - A.T @ A.T
 
         return F
 
-    def _compute_topological_charge(self, frame: ComplexFrame) -> float:
+    def _compute_topological_charge(self, frame: U3Frame) -> float:
         """
-        Compute topological charge Q = (1/32π²) ∫ Tr(F ∧ F)
+        Compute topological charge Q = (1/(32π^2)) ∫ Tr(F ∧ F)
 
         Args:
             frame: Complex frame field
@@ -362,52 +338,64 @@ class ChristmasEquation:
 # Utility Functions
 # ============================================================
 
-def create_flat_spacetime_frame(position: Optional[np.ndarray] = None) -> ComplexFrame:
+def create_flat_spacetime_frame(position: Optional[np.ndarray] = None) -> U3Frame:
     """
-    Create a flat spacetime complex frame (Minkowski space)
+    Create a flat spacetime U(3) frame (Minkowski space)
 
     Args:
-        position: Spacetime position (x, y, z, t)
+        position: Spacetime position (x, y, z, t) [currently ignored]
 
     Returns:
-        ComplexFrame with flat metric
+        U3Frame with flat metric
     """
     real_part = np.eye(3)  # Flat spatial metric
     imag_part = np.zeros((3, 3))  # No gauge field
 
-    return ComplexFrame(real_part, imag_part, position)
+    # Convert to U3Frame: extract column vectors
+    complex_matrix = real_part + 1j * imag_part
+    e1 = complex_matrix[:, 0]
+    e2 = complex_matrix[:, 1]
+    e3 = complex_matrix[:, 2]
+
+    return U3Frame(e1, e2, e3, ensure_unitary=True)
 
 
 def create_curved_spacetime_frame(curvature: float = 0.1,
-                                  position: Optional[np.ndarray] = None) -> ComplexFrame:
+                                  position: Optional[np.ndarray] = None) -> U3Frame:
     """
-    Create a curved spacetime complex frame
+    Create a curved spacetime U(3) frame
 
     Args:
         curvature: Curvature parameter
-        position: Spacetime position (x, y, z, t)
+        position: Spacetime position (x, y, z, t) [currently ignored]
 
     Returns:
-        ComplexFrame with curved metric
+        U3Frame with curved metric
     """
     # Simple curved metric (spherical-like)
     real_part = np.diag([1.0 + curvature, 1.0 + curvature, 1.0])
     imag_part = np.zeros((3, 3))
 
-    return ComplexFrame(real_part, imag_part, position)
+    # Convert to U3Frame: extract column vectors
+    complex_matrix = real_part + 1j * imag_part
+    e1 = complex_matrix[:, 0]
+    e2 = complex_matrix[:, 1]
+    e3 = complex_matrix[:, 2]
+
+    return U3Frame(e1, e2, e3, ensure_unitary=True)
 
 
 def create_gauge_field_frame(field_strength: float = 0.1,
-                             position: Optional[np.ndarray] = None) -> ComplexFrame:
+                             position: Optional[np.ndarray] = None) -> U3Frame:
     """
-    Create a complex frame with gauge field
+    Create a U(3) frame with gauge field
 
     Args:
         field_strength: Gauge field strength
-        position: Spacetime position (x, y, z, t)
+        position: Spacetime position (x, y, z, t) [currently ignored]
 
     Returns:
-        ComplexFrame with gauge field
+        U3Frame with gauge field
     """
     real_part = np.eye(3)  # Flat spatial metric
     imag_part = np.array([
@@ -416,7 +404,13 @@ def create_gauge_field_frame(field_strength: float = 0.1,
         [0, 0, 0]
     ])  # Non-trivial gauge field
 
-    return ComplexFrame(real_part, imag_part, position)
+    # Convert to U3Frame: extract column vectors
+    complex_matrix = real_part + 1j * imag_part
+    e1 = complex_matrix[:, 0]
+    e2 = complex_matrix[:, 1]
+    e3 = complex_matrix[:, 2]
+
+    return U3Frame(e1, e2, e3, ensure_unitary=True)
 
 
 # ============================================================
@@ -425,6 +419,7 @@ def create_gauge_field_frame(field_strength: float = 0.1,
 
 __all__ = [
     'ComplexFrame',
+    'U3Frame',
     'EnergyMomentumTensor',
     'ChristmasEquation',
     'create_flat_spacetime_frame',
@@ -432,6 +427,9 @@ __all__ = [
     'create_gauge_field_frame',
     'M_PLANCK',
     'LAMBDA_TOPO',
+    'ALPHA_FS',
+    'LAMBDA_C',
+    'ALPHA_PROJECTION',
 ]
 
 
@@ -467,7 +465,7 @@ def demonstrate():
 
     solver = ChristmasEquation()
     print(f"   Planck mass M_P: {solver.M_P:.3e} GeV")
-    print(f"   Topological coupling λ: {solver.lambda_topo:.4f}")
+    print(f"   Topological coupling λ: {solver.lambda_topo:.4f}")
 
     # 3. Compute geometric quantities
     print("\n3. Geometric Quantities")
@@ -506,12 +504,13 @@ def demonstrate():
 
     # 6. Theory summary
     print("\n" + "=" * 80)
-    print("Core Theory Summary:")
-    print("  • Christmas Equation: M_P²/2 Ĝ_μν + λ/(32π²) ∇̂_(μ K̄_ν) = T̂_μν^(top) + T̂_μν^(mat)")
-    print("  • U(x) = U^(R)(x) + iU^(I)(x)  [Complex frame decomposition]")
-    print("  • Real part: Geometry (metric, curvature, spacetime)")
-    print("  • Imaginary part: Topology (phase, gauge field, winding)")
-    print("  • Unifies: Gravity + Gauge fields + Dark matter + Topology")
+    print("Core Theory Summary:")
+    print("  - Christmas Equation: (M_P^2 / 2) Ĝ_{μν} + (λ / (32π^2)) ∇̂_{(μ} K̄_{ν)}"
+          " = T̂_{μν}^{(top)} + T̂_{μν}^{(mat)}")
+    print("  - U(x) = U^(R)(x) + iU^(I)(x)  [Complex frame decomposition]")
+    print("  - Real part: Geometry (metric, curvature, spacetime)")
+    print("  - Imaginary part: Topology (phase, gauge field, winding)")
+    print("  - Unifies: Gravity + Gauge fields + Dark matter + Topology")
     print("=" * 80)
 
 

coordinate_system/curve_interpolation.py

@@ -12,9 +12,10 @@ Main Features:
 - B-spline and frame field hybrid interpolation
 - Curvature distribution analysis
 
-Author: PanGuoJun
-Date: 2025-12-01
-"""
+**Authors:** Pan Guojun
+Date: 2025-12-01
+**DOI:** https://doi.org/10.5281/zenodo.14435613
+"""
 
 import math
 import numpy as np

coordinate_system/differential_geometry.py

@@ -12,8 +12,9 @@ Key Features:
 - Classical curvature methods with high-order finite differences
 - Gaussian, mean, principal, and Riemann curvatures
 
-Author: Coordinate System Package
+**Authors:** Pan Guojun
 Date: 2025-12-03
+**DOI:** https://doi.org/10.5281/zenodo.14435613
 """
 
 import math
@@ -910,6 +911,74 @@ def all_curvatures(
     return compute_all_curvatures(surface, u, v, step_size)
 
 
+# ============================================================
+# Legacy / Compatibility Aliases
+# ============================================================
+
+class LieGroupCurvatureCalculator(IntrinsicGradientCurvatureCalculator):
+    """Legacy alias for intrinsic gradient curvature calculator."""
+
+
+def compute_curvature_tensor(
+    surface: Surface,
+    u: float,
+    v: float,
+    step_size: float = 1e-3
+) -> float:
+    """Legacy alias for compute_riemann_curvature."""
+    return compute_riemann_curvature(surface, u, v, step_size)
+
+
+def gaussian_curvature_lie(
+    surface: Surface,
+    u: float,
+    v: float,
+    step_size: float = 1e-3
+) -> float:
+    """Legacy alias for intrinsic gradient Gaussian curvature."""
+    return compute_gaussian_curvature(surface, u, v, step_size)
+
+
+def intrinsic_gradient_gaussian_curvature(
+    surface: Surface,
+    u: float,
+    v: float,
+    step_size: float = 1e-3
+) -> float:
+    """Legacy alias for intrinsic gradient Gaussian curvature."""
+    return compute_gaussian_curvature(surface, u, v, step_size)
+
+
+def intrinsic_gradient_mean_curvature(
+    surface: Surface,
+    u: float,
+    v: float,
+    step_size: float = 1e-3
+) -> float:
+    """Legacy alias for intrinsic gradient mean curvature."""
+    return compute_mean_curvature(surface, u, v, step_size)
+
+
+def intrinsic_gradient_principal_curvatures(
+    surface: Surface,
+    u: float,
+    v: float,
+    step_size: float = 1e-3
+) -> Tuple[float, float]:
+    """Legacy alias for intrinsic gradient principal curvatures."""
+    return principal_curvatures(surface, u, v, step_size)
+
+
+def intrinsic_gradient_all_curvatures(
+    surface: Surface,
+    u: float,
+    v: float,
+    step_size: float = 1e-3
+) -> Dict[str, Union[float, Tuple[float, float]]]:
+    """Legacy alias for intrinsic gradient curvature set."""
+    return compute_all_curvatures(surface, u, v, step_size)
+
+
 # ============================================================
 # Method Comparison
 # ============================================================
@@ -955,15 +1024,23 @@ __all__ = [
     'GradientResult',
     'IntrinsicGradientOperator',
     'IntrinsicGradientCurvatureCalculator',
+    'LieGroupCurvatureCalculator',
     'CurvatureCalculator',
 
     # Intrinsic gradient method functions (default)
     'compute_gaussian_curvature',
     'compute_mean_curvature',
     'compute_riemann_curvature',
+    'compute_curvature_tensor',
     'compute_all_curvatures',
     'compute_intrinsic_gradient',
 
+    # Intrinsic gradient legacy aliases
+    'intrinsic_gradient_gaussian_curvature',
+    'intrinsic_gradient_mean_curvature',
+    'intrinsic_gradient_principal_curvatures',
+    'intrinsic_gradient_all_curvatures',
+
     # Classical method functions
     'gaussian_curvature_classical',
     'mean_curvature_classical',
@@ -976,6 +1053,9 @@ __all__ = [
     'principal_curvatures',
     'all_curvatures',
 
+    # Legacy Lie group naming
+    'gaussian_curvature_lie',
+
     # Method comparison
     'compare_methods',