diff --git a/scripts/information-projection-theory.py b/scripts/information-projection-theory.py new file mode 100644 index 0000000..70d319b --- /dev/null +++ b/scripts/information-projection-theory.py @@ -0,0 +1,193 @@ +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() diff --git a/scripts/spacetime-equation-solver.py b/scripts/spacetime-equation-solver.py new file mode 100644 index 0000000..23d68a7 --- /dev/null +++ b/scripts/spacetime-equation-solver.py @@ -0,0 +1,111 @@ +import numpy as np +import scipy.constants as const +from scipy.optimize import fsolve + +# Physical constants in SI units +c = const.c # speed of light: 299792458 m/s +e = const.e # elementary charge: 1.602176634e-19 C +k = 1 / (4 * np.pi * const.epsilon_0) # Coulomb constant: 8.9875517923e9 N⋅m²/C² +hbar = const.hbar # reduced Planck constant: 1.054571817e-34 J⋅s +m_e = const.m_e # electron mass: 9.1093837015e-31 kg +m_p = const.m_p # proton mass: 1.67262192369e-27 kg +alpha = const.alpha # fine structure constant: ~1/137 + +print("=== DIMENSIONAL ANALYSIS ===") +print(f"ℏ = {hbar:.6e} J⋅s = kg⋅m²/s") +print(f"ℏ² = {hbar**2:.6e} J²⋅s² = kg²⋅m⁴/s²") +print(f"Units of ℏ²: [M²L⁴T⁻²]") +print(f"\nInteresting: L⁴ = (L²)² - suggesting 2D area squared!") +print(f"So ℏ² relates mass², area², and time² fundamentally") + +print("\n=== OUR EQUATION: c² = ke²γEr/(ℏ²) ===") +print("Rearranged forms:") +print("γ = c²ℏ²/(ke²Er)") +print("E = c²ℏ²/(ke²γr)") +print("r = c²ℏ²/(ke²γE)") + +# Case 1: Hydrogen-antihydrogen annihilation +print("\n=== CASE 1: H + anti-H annihilation ===") +E_annihilation = 2 * (m_e + m_p) * c**2 # Total rest mass energy +r_bohr = const.physical_constants['Bohr radius'][0] # 5.29e-11 m + +# Solve for gamma at Bohr radius +gamma_annihilation = (c**2 * hbar**2) / (k * e**2 * E_annihilation * r_bohr) +v_from_gamma = c * np.sqrt(1 - 1/gamma_annihilation**2) if gamma_annihilation > 1 else 0 + +print(f"Total annihilation energy: {E_annihilation:.6e} J = {E_annihilation/const.eV:.3f} eV") +print(f"At Bohr radius r = {r_bohr:.3e} m:") +print(f" γ = {gamma_annihilation:.6f}") +print(f" Implied velocity: {v_from_gamma/c:.6f}c") + +# Case 2: Ground state hydrogen (binding energy) +print("\n=== CASE 2: Ground state hydrogen ===") +E_binding = 13.6 * const.eV # Hydrogen ionization energy +gamma_ground = (c**2 * hbar**2) / (k * e**2 * E_binding * r_bohr) + +print(f"Binding energy: {E_binding:.6e} J = 13.6 eV") +print(f"γ = {gamma_ground:.3e}") +print(f"This huge γ suggests we're probing quantum regime!") + +# Case 3: What if we set γ = 1 (non-relativistic)? +print("\n=== CASE 3: Non-relativistic case (γ = 1) ===") +gamma_nr = 1 +E_nr = (c**2 * hbar**2) / (k * e**2 * gamma_nr * r_bohr) +print(f"Energy when γ = 1: {E_nr:.6e} J = {E_nr/const.eV:.3f} eV") +print(f"This is {E_nr/E_binding:.1f}× the actual binding energy") + +# Explore the meaning of the equation parts +print("\n=== EQUATION COMPONENTS ===") +quantum_term = hbar**2 +em_term = k * e**2 +print(f"Quantum term (ℏ²): {quantum_term:.6e} J²⋅s²") +print(f"EM term (ke²): {em_term:.6e} J⋅m") +print(f"Ratio c²ℏ²/(ke²) = {(c**2 * quantum_term)/em_term:.6e} J⋅m") +print(f"This has units of [Energy × Length]") + +# The fine structure connection +print("\n=== FINE STRUCTURE CONSTANT CONNECTION ===") +# α = ke²/(ℏc) in SI units +calculated_alpha = (k * e**2) / (hbar * c) +print(f"α calculated: {calculated_alpha:.10f}") +print(f"α known: {alpha:.10f}") +print(f"Our equation can be rewritten using α:") +print(f"γ = c/(αEr/ℏ)") + +# Exploring unit independence +print("\n=== UNIT INDEPENDENCE CHECK ===") +# In natural units where c = ℏ = 1 +print("In natural units (c = ℏ = 1):") +print("γ = 1/(αEr)") +print("This shows γ depends only on:") +print(" - The fine structure constant α (dimensionless)") +print(" - Energy × distance (action units)") + +# What this means for spacetime +print("\n=== SPACETIME INTERPRETATION ===") +print("Since γ = dt/dτ (time dilation factor):") +print("Our equation suggests coordinate time / proper time = c²ℏ²/(ke²Er)") +print("\nThis means time dilation emerges from the balance between:") +print(" - Quantum action (ℏ²) pushing toward uncertainty") +print(" - EM binding (ke²Er) pulling toward classical behavior") +print("\nAt high energies or small distances, γ becomes huge,") +print("suggesting extreme time dilation in the quantum regime!") + +# Function to explore different scenarios +def explore_scenario(E, r, label): + gamma = (c**2 * hbar**2) / (k * e**2 * E * r) + print(f"\n{label}:") + print(f" E = {E/const.eV:.3e} eV, r = {r:.3e} m") + print(f" γ = {gamma:.3e}") + if gamma > 1 and gamma < 1e6: + v = c * np.sqrt(1 - 1/gamma**2) + print(f" v/c = {v/c:.6f}") + +# Explore various energy/distance scales +print("\n=== EXPLORING DIFFERENT SCALES ===") +explore_scenario(1*const.eV, 1e-9, "1 eV at 1 nm") +explore_scenario(1*const.eV*1000, 1e-12, "1 keV at 1 pm") +explore_scenario(511*const.eV*1000, const.physical_constants['classical electron radius'][0], + "Electron rest mass at classical radius") +explore_scenario(const.m_e * c**2, const.physical_constants['Compton wavelength'][0]/(2*np.pi), + "Electron at reduced Compton wavelength") diff --git a/scripts/testscript-gpt.py b/scripts/testscript-gpt.py new file mode 100644 index 0000000..69c916e --- /dev/null +++ b/scripts/testscript-gpt.py @@ -0,0 +1,31 @@ +import math +from scipy import constants as const + +# Konstanten aus scipy.constants +c = const.c # Lichtgeschwindigkeit in m/s +hbar= const.hbar # ℏ in J·s +e = const.e # Elementarladung in Coulomb +k_e = 1/(4*math.pi*const.epsilon_0) # Coulomb-Konstante in N·m²/C² + +def gamma_quantum_time(E_joule, r_meter): + """Berechnet γ = c^2 ℏ^2 / (k e^2 E r).""" + return c**2 * hbar**2 / (k_e * e**2 * E_joule * r_meter) + +# Beispielszenarien (E in eV, r in m): +scenarios = [ + ("Wasserstoff Grundzustand", 13.6, 0.529e-10), # E=13,6 eV, r = 0,529 Å + ("Wasserstoff angeregt (n=2)", 3.4, 2.116e-10), # E≈3,4 eV, r≈2,116 Å (n=2) + ("Chemische Bindung (~C–H)", 4.5, 1.10e-10), # E≈4-5 eV, r≈1,1 Å + ("Thermische Energie (300 K)", 0.025, 5.0e-10), # E≈0,025 eV, r≈5 Å (Raumtemperatur, Atomgitter) + ("Kernbindung (typisch)", 8.0e6, 5.0e-15), # E≈8 MeV, r≈5 fm (Bindung in mittelschwerem Kern) + ("Starke Kernkraft (extrem)", 2.0e8, 1.0e-15), # E≈200 MeV, r=1 fm (starke Bindung im Kern) + ("H–Anti-H Annihilation", 1.88e9, 0.529e-10), # E≈1,88 GeV, r=0,529 Å (H mit Anti-H Abstand ~ Bohr) + ("Kritischer Punkt (γ=1)", 5.11e5, 0.529e-10) # E=511 keV, r=0,529 Å (Elektron-Ruheenergie) +] + +print(f"{'Szenario':30} | {'Energie E':>15} | {'Abstand r':>12} | γ (berechnet)") +print("-"*75) +for name, E_eV, r in scenarios: + E_J = E_eV * const.e # eV -> Joule + gamma_val = gamma_quantum_time(E_J, r) + print(f"{name:30} | {E_eV:9.2e} eV | {r:8.2e} m | {gamma_val:9.3e}")