← Back to Part III: Einstein Field Equations

Chapter 12: The Equivalence Principle

The equivalence principle is the cornerstone of general relativity. It states that gravitational and inertial mass are equivalent, and that locally, gravity is indistinguishable from acceleration. This insight led Einstein to describe gravity as spacetime curvature.

Three Forms

Weak Equivalence Principle (WEP)

All test particles fall with the same acceleration in a gravitational field, regardless of their composition.

m_{inertial} = m_{gravitational} (tested to 10^-15 precision)

Einstein Equivalence Principle (EEP)

In a freely falling local reference frame, the laws of physics are those of special relativity.

Includes WEP + local Lorentz invariance + local position invariance

Strong Equivalence Principle (SEP)

EEP applies to all physics, including gravitational experiments. Self-gravitating bodies fall like test particles.

Only satisfied by general relativity (not scalar-tensor theories)

Einstein's Thought Experiments

The Elevator

An observer in a closed elevator cannot distinguish between:
• Resting on Earth's surface in gravity g
• Accelerating upward at g in empty space

Free Fall

An observer in free fall cannot distinguish between:
• Falling in a gravitational field
• Floating in empty space far from masses

Key Implication

Gravity can be "transformed away" locally by choosing a freely falling frame. This means gravity is not a force but a property of spacetime geometry!

Mathematical Formulation

At any point in spacetime, we can choose coordinates where the metric is locally Minkowski:

$g_{\mu\nu}(P) = \eta_{\mu\nu}, \quad \Gamma^\rho_{\mu\nu}(P) = 0$

Local inertial frame (Riemann normal coordinates)

However, second derivatives (curvature) cannot be transformed away:$R^\rho_{\;\sigma\mu\nu}(P) \neq 0$ in general. This is the tidal effect that distinguishes true gravity from mere acceleration.

Python: Free Fall Simulation

Free Fall Simulation: The Equivalence Principle

Python

script.py63 lines

#!/usr/bin/env python3
"""
Equivalence Principle - Free Fall Simulation
Demonstrates that gravity and acceleration are locally indistinguishable.
"""
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def simulate_elevator(g, a_elevator, t_max=3.0, dt=0.01):
    t = np.arange(0, t_max, dt)
    g_eff = g - a_elevator
    y_ball = -0.5 * g_eff * t**2
    y_elevator = 0.5 * a_elevator * t**2
    y_ball_ground = y_elevator + 2.0 + y_ball
    return t, y_ball, y_elevator, y_ball_ground

fig, axes = plt.subplots(1, 3, figsize=(15, 5))
fig.patch.set_facecolor('#0a0a1a')

scenarios = [
    (9.8, 0, 'Stationary in Gravity (g=9.8)', '#06b6d4'),
    (0, -9.8, 'Accelerating Up (a=9.8, no g)', '#ef4444'),
    (9.8, 9.8, 'Free Fall (a=g=9.8)', '#22c55e'),
]

for i, (g, a, title, color) in enumerate(scenarios):
    t, y_ball, _, _ = simulate_elevator(g=g, a_elevator=a)
    ax = axes[i]
    ax.set_facecolor('#0f0f1a')
    ax.plot(t, y_ball, color=color, linewidth=2.5)
    ax.axhline(y=-2, color='#8b4513', linewidth=3, label='Floor')
    ax.set_xlabel('Time (s)', color='#94a3b8')
    ax.set_ylabel('Height above floor (m)', color='#94a3b8')
    ax.set_title(title, color='white', fontsize=11)
    ax.set_ylim(-2.5, 0.5)
    ax.grid(True, alpha=0.2, color='#334155')
    ax.tick_params(colors='#94a3b8')
    ax.legend(facecolor='#1a1a2e', edgecolor='#334155', labelcolor='white')
    for s in ax.spines.values(): s.set_edgecolor('#334155')

plt.tight_layout()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a1a')
plt.close()

print("Equivalence Principle Demonstration")
print("=" * 55)
print()
print("Scenario 1: Ball dropped in stationary elevator on Earth")
print("  -> Ball falls with g = 9.8 m/s^2")
print()
print("Scenario 2: Ball 'dropped' in elevator accelerating up at 9.8 m/s^2")
print("  -> Ball appears to fall with same acceleration!")
print("  -> Observer CANNOT distinguish from Scenario 1")
print()
print("Scenario 3: Ball in free-falling elevator")
print("  -> Ball floats (g_eff = g - a = 0)")
print("  -> Observer feels weightless, like in empty space")
print()
print("This is the Equivalence Principle:")
print("  Gravity <-> Acceleration (locally indistinguishable)")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Tidal Forces

Python

tidal_forces_plot.py116 lines

import subprocess, tempfile, os, io, base64
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

fortran_source = r"""
program tidal_forces
    implicit none
    integer, parameter :: dp = selected_real_kind(15)
    real(dp), parameter :: G = 6.674e-11_dp
    real(dp), parameter :: c = 3.0e8_dp
    real(dp), parameter :: M_sun = 1.989e30_dp
    real(dp) :: M, r_s, r, delta_r, tidal
    real(dp) :: log_M
    integer :: i, n_pts, j
    real(dp) :: masses(3)

delta_r = 2.0_dp
    masses(1) = 10.0_dp
    masses(2) = 1.0e6_dp
    masses(3) = 4.0e9_dp

! Tidal force vs distance for each BH mass
    n_pts = 150
    do j = 1, 3
        M = masses(j) * M_sun
        r_s = 2.0_dp * G * M / c**2
        write(*,'(A,ES12.4)') 'DATA_START mass=', masses(j)
        do i = 1, n_pts
            r = r_s * (1.01_dp + real(i-1, dp) * 49.0_dp / real(n_pts-1, dp))
            tidal = 2.0_dp * G * M * delta_r / r**3
            write(*,'(F14.8,A,ES16.8)') r/r_s, ',', tidal
        end do
        print '(A)', 'DATA_END'
    end do

! Human survivability threshold
    print '(A)', 'DATA_START threshold'
    write(*,'(ES12.4)') 10.0_dp  ! ~10 m/s^2 = 1g tidal
    print '(A)', 'DATA_END'
end program tidal_forces
"""

workdir = tempfile.mkdtemp()
src = os.path.join(workdir, 'tidal.f90')
exe = os.path.join(workdir, 'tidal')

with open(src, 'w') as f:
    f.write(fortran_source)

comp = subprocess.run(['gfortran', '-O2', '-o', exe, src],
                      capture_output=True, text=True, timeout=30)
if comp.returncode != 0:
    print("Compilation error:", comp.stderr)
else:
    result = subprocess.run([exe], capture_output=True, text=True, timeout=30, cwd=workdir)
    output = result.stdout

sections = {}
    current = None
    threshold = 10.0
    for line in output.split('\n'):
        if 'DATA_START mass=' in line:
            current = line.split('mass=')[1].strip()
            sections[current] = []
            continue
        if 'DATA_START threshold' in line:
            current = 'threshold'
            continue
        if 'DATA_END' in line:
            current = None
            continue
        if current == 'threshold' and line.strip():
            threshold = float(line.strip())
        elif current and line.strip():
            sections[current].append(line.strip())

fig, ax = plt.subplots(1, 1, figsize=(10, 7))
    fig.patch.set_facecolor('#0f172a')
    ax.set_facecolor('#1e293b')

colors = ['#ef4444', '#fbbf24', '#4ade80']
    labels = ['10 $M_\\odot$ (stellar)', '$10^6 M_\\odot$ (intermediate)', '$4 \\times 10^9 M_\\odot$ (supermassive)']

for idx, (mass_key, data) in enumerate(sections.items()):
        if mass_key == 'threshold':
            continue
        r_arr, t_arr = [], []
        for line in data:
            vals = [float(x) for x in line.split(',')]
            r_arr.append(vals[0])
            t_arr.append(vals[1])
        ax.semilogy(r_arr, t_arr, color=colors[idx], linewidth=2, label=labels[idx])

ax.axhline(y=threshold, color='#a78bfa', linestyle='--', linewidth=2, label='Human limit (~1g tidal)')
    ax.set_xlabel('$r / r_s$ (Schwarzschild radii)', color='#cbd5e1', fontsize=12)
    ax.set_ylabel('Tidal acceleration (m/s$^2$)', color='#cbd5e1', fontsize=12)
    ax.set_title('Tidal Forces Near Black Holes (2m separation)', color='white', fontsize=14, fontweight='bold')
    ax.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1', fontsize=10)
    ax.tick_params(colors='#cbd5e1')
    for spine in ax.spines.values():
        spine.set_color('#334155')
    ax.grid(True, color='#334155', alpha=0.4)

plt.tight_layout()
    buf = io.BytesIO()
    plt.savefig(buf, format='png', dpi=150, bbox_inches='tight', facecolor=fig.get_facecolor())
    buf.seek(0)
    img_b64 = base64.b64encode(buf.read()).decode()
    buf.close()
    plt.close()
    print("Stellar BH: spaghettification outside horizon")
    print("Supermassive BH: survivable crossing!")
    # Image saved as output.png

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Symmetries and Killing Vectors Next: Einstein Field Equations →