spacetime-paper/scripts/information-projection-theory.py

import numpy as np
import matplotlib.pyplot as plt
from scipy import constants as const

# Core concept: Mass is information projected from higher dimensions
# As velocity increases, projection angle changes, reducing observable mass

# Constants
c = const.c  # speed of light
hbar = const.hbar
e = const.e
k_e = 1/(4*np.pi*const.epsilon_0)
alpha = const.alpha

def classical_gamma(v):
    """Classical Lorentz factor - mass increases"""
    return 1/np.sqrt(1 - (v/c)**2)

def information_projection_factor(v, n_dims=4):
    """
    Information projection from n_dims to (n_dims-1)
    As v→c, the object rotates out of our dimensional slice
    """
    # Angle of rotation in higher-dimensional space
    theta = np.arcsin(v/c)  # rotation angle out of our 3D slice
    
    # Projection factor: how much of the higher-D object we see
    projection = np.cos(theta)**(n_dims-3)
    
    return projection

def observed_mass(m0, v, n_dims=4):
    """Mass as seen in our 3D slice of higher-D spacetime"""
    gamma = classical_gamma(v)
    projection = information_projection_factor(v, n_dims)
    
    # Key insight: observed mass is rest mass times projection
    # divided by gamma (not multiplied!)
    return m0 * projection / gamma

def information_density_2d(E, r):
    """
    Information density on a 2D surface (from our ℏ² analysis)
    E: energy (information content)
    r: radius (information spread)
    """
    # From our equation: γ = c²ℏ²/(ke²Er)
    # Information area = ℏ² (quantum of area-information)
    # Information density = E/(πr²) in natural units
    
    area = np.pi * r**2
    info_density = E / area
    
    # Relate to our gamma factor
    gamma = (c**2 * hbar**2) / (k_e * e**2 * E * r)
    
    return info_density, gamma

# Visualization
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 10))

# 1. Mass vs velocity comparison
velocities = np.linspace(0, 0.999*c, 1000)
m0 = 1  # normalized rest mass

classical_masses = m0 * classical_gamma(velocities)
info_masses_3d = observed_mass(m0, velocities, n_dims=3)
info_masses_4d = observed_mass(m0, velocities, n_dims=4)
info_masses_5d = observed_mass(m0, velocities, n_dims=5)

ax1.plot(velocities/c, classical_masses, 'r-', label='Classical (m₀γ)', linewidth=2)
ax1.plot(velocities/c, info_masses_3d, 'b--', label='Info projection (3D→2D)', linewidth=2)
ax1.plot(velocities/c, info_masses_4d, 'g--', label='Info projection (4D→3D)', linewidth=2)
ax1.plot(velocities/c, info_masses_5d, 'm--', label='Info projection (5D→4D)', linewidth=2)
ax1.set_xlabel('v/c')
ax1.set_ylabel('Observed mass / m₀')
ax1.set_title('Classical vs Information Projection Theory')
ax1.legend()
ax1.grid(True, alpha=0.3)
ax1.set_ylim(0, 5)

# 2. Projection factor visualization
projections_3d = information_projection_factor(velocities, n_dims=3)
projections_4d = information_projection_factor(velocities, n_dims=4)
projections_5d = information_projection_factor(velocities, n_dims=5)

ax2.plot(velocities/c, projections_3d, 'b-', label='3D→2D', linewidth=2)
ax2.plot(velocities/c, projections_4d, 'g-', label='4D→3D', linewidth=2)
ax2.plot(velocities/c, projections_5d, 'm-', label='5D→4D', linewidth=2)
ax2.set_xlabel('v/c')
ax2.set_ylabel('Projection factor')
ax2.set_title('Information Shadow vs Velocity')
ax2.legend()
ax2.grid(True, alpha=0.3)

# 3. Connection to quantum time dilation
# Show how projection relates to our γ factor
energies = np.logspace(-3, 6, 100) * const.eV  # meV to MeV
r_bohr = 0.529e-10  # Bohr radius

info_densities = []
gammas = []

for E in energies:
    density, gamma = information_density_2d(E, r_bohr)
    info_densities.append(density)
    gammas.append(gamma)

ax3.loglog(energies/const.eV, gammas, 'k-', linewidth=2)
ax3.axhline(y=1, color='r', linestyle='--', label='γ = 1 (classical limit)')
ax3.axvline(x=511e3, color='b', linestyle='--', label='Electron rest mass')
ax3.set_xlabel('Energy (eV)')
ax3.set_ylabel('γ (time dilation factor)')
ax3.set_title('Quantum Time Dilation as Information Spreading')
ax3.legend()
ax3.grid(True, alpha=0.3)

# 4. 2D plane visualization
# Two observers running orthogonally on a plane
t_points = np.linspace(0, 1, 100)
v_max = 0.9 * c

# Observer trajectories
x1 = v_max * t_points
y1 = np.zeros_like(t_points)
x2 = np.zeros_like(t_points)
y2 = v_max * t_points

# Their observed masses
m1 = observed_mass(m0, v_max * t_points, n_dims=4)
m2 = observed_mass(m0, v_max * t_points, n_dims=4)

ax4.scatter(x1[::5]/c, y1[::5], s=100*m1[::5], c=t_points[::5], 
           cmap='Reds', alpha=0.6, label='Observer 1')
ax4.scatter(x2[::5], y2[::5]/c, s=100*m2[::5], c=t_points[::5], 
           cmap='Blues', alpha=0.6, label='Observer 2')
ax4.arrow(0, 0, 0.5, 0, head_width=0.05, head_length=0.05, fc='red', ec='red')
ax4.arrow(0, 0, 0, 0.5, head_width=0.05, head_length=0.05, fc='blue', ec='blue')
ax4.set_xlabel('x position (light-seconds)')
ax4.set_ylabel('y position (light-seconds)')
ax4.set_title('Orthogonal Observers: Size = Observed Mass')
ax4.set_xlim(-0.1, 1)
ax4.set_ylim(-0.1, 1)
ax4.legend()
ax4.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('information_projection_theory.png', dpi=150)

# Key calculations
print("=== INFORMATION PROJECTION THEORY ===")
print("\nAt v = 0.9c:")
v_test = 0.9 * c
gamma_classical = classical_gamma(v_test)
proj_4d = information_projection_factor(v_test, n_dims=4)
m_observed = observed_mass(m0, v_test, n_dims=4)

print(f"Classical γ = {gamma_classical:.3f}")
print(f"Classical mass increase: m = {gamma_classical:.3f} m₀")
print(f"Information projection (4D→3D): {proj_4d:.3f}")
print(f"Our theory mass: m = {m_observed:.3f} m₀")
print(f"Mass DECREASES by factor of {1/m_observed:.3f}!")

# Connection to E=mc²
print("\n=== E=mc² AS INFORMATION ON 2D SURFACE ===")
print("If mass is information shadow, then E=mc² means:")
print("Energy = (Information content) × (Maximum info processing rate)²")
print("Where c² is the speed of information propagation squared")
print("\nThis explains why E ∝ c²:")
print("- c: speed of 1D information (along a line)")
print("- c²: speed of 2D information (on a surface)")
print("- Energy spreads as 2D information on spacetime surfaces!")

# Superconductivity connection
print("\n=== SUPERCONDUCTIVITY CONNECTION ===")
E_cooper = 1e-3 * const.eV  # 1 meV Cooper pair binding
r_cooper = 1000e-10  # 1000 Å coherence length
_, gamma_cooper = information_density_2d(E_cooper, r_cooper)

print(f"Cooper pair: E = 1 meV, r = 1000 Å")
print(f"γ = {gamma_cooper:.2e}")
print("Electrons are 'frozen' in higher dimensions!")
print("No projection into time dimension = no resistance!")

# Mathematical framework
print("\n=== MATHEMATICAL FRAMEWORK ===")
print("1. Mass is information projected from n-dimensions to (n-1)")
print("2. Projection factor: P(v) = cos^(n-3)(arcsin(v/c))")
print("3. Observed mass: m_obs = m₀ × P(v) / γ(v)")
print("4. At v→c: P→0, so m_obs→0 (not ∞!)")
print("5. Information cannot be destroyed, only rotated out of view")

plt.show()