← Back to Part II: Lorentz Transformations

Chapter 5: Invariant Spacetime Interval

While observers disagree on time intervals and spatial distances, they all agree on the spacetime interval. This invariant quantity is the foundation of relativistic geometry, playing the same role as distance in Euclidean geometry.

The Spacetime Interval

\( \Delta s^2 = c^2\Delta t^2 - \Delta x^2 - \Delta y^2 - \Delta z^2 \)

All inertial observers calculate the same value for Δs²!

This is analogous to the Pythagorean theorem \( d^2 = x^2 + y^2 \) being invariant under rotations. The minus signs make spacetime geometry "hyperbolic" rather than Euclidean.

Classification of Intervals

Timelike (Δs² > 0)

Time separation dominates. Events can be connected by a massive particle. All observers agree on time ordering. \( \Delta s = c\Delta\tau \) (proper time).

Lightlike (Δs² = 0)

Events connected by light. Null separation. Photon worldlines have zero interval.

Spacelike (Δs² < 0)

Space separation dominates. No causal connection. Order of events is frame-dependent.\( \Delta s^2 = -\Delta\sigma^2 \) (proper distance).

Physical Interpretation

Timelike: Proper Time

For timelike intervals, \( \Delta\tau = \Delta s/c \) is the proper time—the time measured by a clock traveling between the events. This is the "wristwatch time" of a traveler.

Spacelike: Proper Distance

For spacelike intervals, \( \Delta\sigma = \sqrt{-\Delta s^2} \) is the proper distance—the spatial separation measured by an observer for whom the events are simultaneous.

Interactive Simulations

Invariant Interval: Same in Every Frame

Python

script.py59 lines

import numpy as np

print("=" * 70)
print("SPACETIME INVARIANT INTERVAL")
print("s^2 = -(c*dt)^2 + dx^2 + dy^2 + dz^2")
print("=" * 70)

def lorentz_boost(dt, dx, beta):
    gamma = 1.0 / np.sqrt(1.0 - beta**2)
    dt_p = gamma * (dt - beta * dx)
    dx_p = gamma * (dx - beta * dt)
    return dt_p, dx_p

# Event pairs and their intervals
events = [
    (5, 3, "Timelike"),
    (3, 5, "Spacelike"),
    (4, 4, "Lightlike"),
    (10, 6, "Timelike"),
    (2, 7, "Spacelike"),
    (1, 1, "Lightlike"),
]

boosts = [0.0, 0.3, 0.6, 0.9]

print(f"\n{'Event (dt,dx)':>16} {'s^2 (S)':>10}", end="")
for b in boosts[1:]:
    print(f" {'s^2(v='+str(b)+'c)':>14}", end="")
print(f" {'Type':>12}")
print("-" * 78)

for dt, dx, typ in events:
    s2_orig = -(dt**2) + dx**2
    line = f"({dt:2d}, {dx:2d})          {s2_orig:10.2f}"
    for beta in boosts[1:]:
        dtp, dxp = lorentz_boost(dt, dx, beta)
        s2_boosted = -(dtp**2) + dxp**2
        line += f" {s2_boosted:14.6f}"
    line += f" {typ:>12}"
    print(line)

print("\nAll columns show the SAME s^2 - the interval is invariant!")

print("\n" + "=" * 70)
print("PROPER TIME AND PROPER DISTANCE")
print("=" * 70)
print(f"{'dt':>5} {'dx':>5} {'s^2':>8} {'Type':>12} {'Proper qty':>16}")
print("-" * 50)
for dt, dx, typ in events:
    s2 = -(dt**2) + dx**2
    if s2 < 0:
        proper = f"tau = {np.sqrt(-s2):.4f}"
    elif s2 > 0:
        proper = f"d = {np.sqrt(s2):.4f}"
    else:
        proper = "null (light)"
    print(f"{dt:5d} {dx:5d} {s2:8.1f} {typ:>12} {proper:>16}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Verify Interval Invariance Under Boosts

Fortran

program.f9057 lines

program invariant_interval
  implicit none
  double precision :: dt, dx, dtp, dxp, s2, s2p
  double precision :: beta, gamma_val
  double precision :: dt_ev(6), dx_ev(6)
  double precision :: betas(5)
  integer :: i, j

dt_ev = (/5.0d0, 3.0d0, 4.0d0, 10.0d0, 2.0d0, 1.0d0/)
  dx_ev = (/3.0d0, 5.0d0, 4.0d0, 6.0d0, 7.0d0, 1.0d0/)
  betas = (/0.1d0, 0.3d0, 0.5d0, 0.7d0, 0.9d0/)

print '(A)', repeat('=', 70)
  print '(A)', 'INVARIANT INTERVAL VERIFICATION'
  print '(A)', 's^2 = -dt^2 + dx^2  (c = 1)'
  print '(A)', repeat('=', 70)

do i = 1, 6
    dt = dt_ev(i)
    dx = dx_ev(i)
    s2 = -dt**2 + dx**2

if (abs(s2) < 1.0d-10) then
      print '(/,A,F4.1,A,F4.1,A,A)', &
        '  Event (', dt, ', ', dx, ') -> LIGHTLIKE, s^2 = 0'
    else if (s2 < 0.0d0) then
      print '(/,A,F4.1,A,F4.1,A,F8.2)', &
        '  Event (', dt, ', ', dx, ') -> TIMELIKE, s^2 = ', s2
    else
      print '(/,A,F4.1,A,F4.1,A,F8.2)', &
        '  Event (', dt, ', ', dx, ') -> SPACELIKE, s^2 = ', s2
    end if

print '(A10, A10, A10, A14, A12)', &
      'v/c', 'dt''', 'dx''', 's''^2', 'Match?'
    print '(A)', repeat('-', 58)

do j = 1, 5
      beta = betas(j)
      gamma_val = 1.0d0 / sqrt(1.0d0 - beta**2)
      dtp = gamma_val * (dt - beta * dx)
      dxp = gamma_val * (dx - beta * dt)
      s2p = -dtp**2 + dxp**2

if (abs(s2 - s2p) < 1.0d-8) then
        print '(F10.1, F10.4, F10.4, F14.6, A12)', &
          beta, dtp, dxp, s2p, '  YES'
      else
        print '(F10.1, F10.4, F10.4, F14.6, A12)', &
          beta, dtp, dxp, s2p, '  NO!'
      end if
    end do
  end do

end program invariant_interval

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

Share:X Reddit LinkedIn

← Classic Paradoxes Next: Proper Time and Worldlines →