NeuralBlitz Relativity
What I Do
I provide comprehensive relativity tools including Lorentz transformations, spacetime geometry, relativistic kinematics and dynamics, black hole metrics, gravitational waves, and relativistic field theory for physics and astronomy applications.
When to Use Me
- High-speed particle dynamics
- GPS satellite corrections
- Gravitational time dilation
- Black hole calculations
- Cosmological models
- Gravitational wave analysis
Core Concepts
- Lorentz Transformations: Time dilation, length contraction
- Spacetime Intervals: Invariant quantities
- Four-Vectors: Energy-momentum, position
- Relativistic Dynamics: E=mc², relativistic momentum
- General Relativity: Curvature, geodesics
- Black Holes: Schwarzschild, Kerr metrics
- Gravitational Waves: Strain, propagation
- Cosmology: FLRW metric, expansion history
Code Examples
Lorentz Transformations
import numpy as np
c = 299792458 # Speed of light (m/s)
def lorentz_factor(v):
beta = v / c
return 1 / np.sqrt(1 - beta**2)
def time_dilation(t, v):
return lorentz_factor(v) * t
def length_contraction(L, v):
return L / lorentz_factor(v)
def velocity_addition(v, u):
return (v + u) / (1 + v * u / c**2)
v = 0.8 * c
gamma = lorentz_factor(v)
print(f"γ at 0.8c: {gamma:.4f}")
t_proper = 1.0 # seconds
t_lab = time_dilation(t_proper, v)
print(f"Time in lab frame: {t_lab:.4f} s")
Four-Vectors
class FourVector:
def __init__(self, ct, x, y, z):
self.ct = ct
self.x = x
self.y = y
self.z = z
def lorentz_boost(self, v, axis='x'):
gamma = lorentz_factor(v)
if axis == 'x':
new_ct = gamma * (self.ct - v * self.x / c)
new_x = gamma * (self.x - v * self.ct / c)
return FourVector(new_ct, new_x, self.y, self.z)
return self
def magnitude_squared(self):
return self.ct**2 - (self.x**2 + self.y**2 + self.z**2) / c**2
p = FourVector(c * 10, 5, 3, 1)
print(f"Invariant: {p.magnitude_squared():.4f}")
p_boosted = p.lorentz_boost(0.5 * c)
print(f"Boosted ct: {p_boosted.ct:.4f}")
Energy-Momentum Relations
def relativistic_energy(m, v):
gamma = lorentz_factor(v)
return gamma * m * c**2
def relativistic_momentum(m, v):
return lorentz_factor(v) * m * v
def kinetic_energy(m, v):
return relativistic_energy(m, v) - m * c**2
m = 1e-30 # kg (electron mass scale)
v = 0.9 * c
E = relativistic_energy(m, v)
p = relativistic_momentum(m, v)
K = kinetic_energy(m, v)
print(f"Total energy: {E:.4e} J")
print(f"Momentum: {p:.4e} kg·m/s")
print(f"Kinetic energy: {K:.4e} J")
def de_broglie_wavelength(m, v):
h = 6.626e-34
return h / relativistic_momentum(m, v)
wavelength = de_broglie_wavelength(m, v)
print(f"de Broglie wavelength: {wavelength:.4e} m")
Schwarzschild Black Hole
G = 6.674e-11 # Gravitational constant
M_sun = 1.989e30
def schwarzschild_radius(M):
return 2 * G * M / c**2
def time_dilation_factor(r, M):
rs = schwarzschild_radius(M)
return np.sqrt(1 - rs / r)
def orbital_velocity(r, M):
return np.sqrt(G * M / r)
M = M_sun
rs = schwarzschild_radius(M)
print(f"Schwarzschild radius of Sun: {rs:.4f} m")
r = 10 * rs
time_factor = time_dilation_factor(r, M)
print(f"Time dilation at 10rs: {time_factor:.4f}")
Gravitational Waves
def gw_strain(m1, m2, d, f):
G = 6.674e-11
c2 = c**2
return (4 * G**2 * m1 * m2 / (c2**4 * d)) * (np.pi * G * (m1 + m2) * f / c2**3)**(2/3)
m1, m2 = 30 * 1.989e30, 30 * 1.989e30 # Solar masses
d = 1e6 * 3.086e16 # 1 Mpc in meters
f = 100 # Hz
h = gw_strain(m1, m2, d, f)
print(f"GW strain: {h:.4e}")
def gw_frequency_evolution(m1, m2, f0, t):
tau = 5 / (256 * np.pi * c**5 / (G**3 * m1 * m2)) * (np.pi * G * (m1 + m2) * f0 / c**3)**(-8/3)
return f0 / (1 - t / tau)**(3/8)
Best Practices
- Units: Use geometric units (c=1) when possible
- Approximations: Weak field, slow motion limits
- Sign Conventions: Be consistent with metric signature
- Singularities: Physical interpretation of singularities
- Observables: Consider what can actually be measured
Common Patterns
# FLRW scale factor
def hubble_parameter(H0, Omega_m, Omega_Lambda, z):
return H0 * np.sqrt(Omega_m * (1+z)**3 + Omega_Lambda)
def redshift_to_distance(z, H0=70, Omega_m=0.3):
dL = (c * z / H0) * (1 + z/2 - z**2/10)
return dL
# Proper time along geodesic
def proper_time_integral(a_max, omega):
return 2 * a_max / omega * (1 - np.exp(-omega * a_max / c))
Core Competencies
- Lorentz transformations and four-vectors
- Relativistic kinematics and dynamics
- General relativity fundamentals
- Black hole physics
- Gravitational wave basics