← Back to Part II: Lorentz Transformations

Chapter 2: Velocity Addition Formula

In Galilean physics, velocities add simply: if you walk at 3 mph on a train moving at 60 mph, you're moving at 63 mph relative to the ground. But this breaks down at relativistic speeds. The correct formula ensures that no combination of velocities ever exceeds the speed of light.

The Relativistic Velocity Addition Formula

\( u = \frac{u' + v}{1 + \frac{u'v}{c^2}} \)

u' = velocity in frame S' | v = velocity of S' relative to S | u = velocity in frame S

Galilean (Wrong at High Speeds)

\( u = u' + v \)

Simple addition—can exceed c!

Relativistic (Correct)

\( u = \frac{u' + v}{1 + u'v/c^2} \)

Always gives u ≤ c!

Derivation

From the Lorentz transformations: \( x = \gamma(x' + vt') \) and \( t = \gamma(t' + vx'/c^2) \)

Velocity in S: \( u = \frac{dx}{dt} = \frac{dx'/dt' + v}{1 + (v/c^2)(dx'/dt')} = \frac{u' + v}{1 + u'v/c^2} \)

Worked Examples

Example 1: Low Speeds

Train at v = 60 mph, walking at u' = 3 mph. Then u'v/c² ≈ 0, so u ≈ 63 mph (Galilean result).

Example 2: High Speeds

Spaceship at v = 0.9c, fires missile at u' = 0.9c forward.

\( u = \frac{0.9c + 0.9c}{1 + (0.9)(0.9)} = \frac{1.8c}{1.81} = 0.994c \) (not 1.8c!)

Example 3: Adding Light Speed

Spaceship at v = 0.9c, shines a flashlight (u' = c).

\( u = \frac{c + 0.9c}{1 + (0.9c)(c)/c^2} = \frac{1.9c}{1.9} = c \) (light speed is invariant!)

Rapidity: The Natural Velocity Parameter

Define rapidity φ by: \( \tanh\phi = v/c \), then velocities add as:

\( \phi_{total} = \phi_1 + \phi_2 \)

Rapidities add linearly like angles in Euclidean rotations!

This is why rapidity is often more convenient than velocity in relativistic calculations. As v → c, φ → ∞, but the addition remains simple.

Interactive Simulations

Relativistic vs Classical Velocity Addition

Python

script.py48 lines

import numpy as np

print("=" * 70)
print("VELOCITY ADDITION: CLASSICAL vs RELATIVISTIC")
print("=" * 70)

c = 1.0  # natural units

# Frame S' moves at V relative to S
# Object moves at u' in S'
# Classical: u = u' + V
# Relativistic: u = (u' + V) / (1 + u'*V/c^2)

V_values = [0.1, 0.3, 0.5, 0.7, 0.9]
u_prime_values = [0.1, 0.3, 0.5, 0.7, 0.9, 0.99, 1.0]

for V in V_values:
    print(f"\n--- Frame velocity V = {V}c ---")
    print(f"{'u_prime/c':>10} {'Classical':>12} {'Relativistic':>14} {'Error %':>10} {'> c?':>6}")
    print("-" * 55)

for up in u_prime_values:
        u_class = up + V
        u_rel = (up + V) / (1.0 + up * V)
        error = abs(u_class - u_rel) / u_rel * 100 if u_rel > 0 else 0
        exceeds = "YES!" if u_class > 1.0 else "no"
        print(f"{up:10.2f} {u_class:12.4f} {u_rel:14.6f} {error:10.2f} {exceeds:>6}")

print("\n" + "=" * 70)
print("SPECIAL CASE: Adding light speed")
print("=" * 70)
print("If u' = c, result is always c regardless of V:")
for V in [0.0, 0.5, 0.9, 0.99, 0.999]:
    u = (1.0 + V) / (1.0 + 1.0 * V)
    print(f"  V = {V:.3f}c, u' = c  =>  u = {u:.10f}c")

print("\nRAPIDITY ADDITION (additive!):")
print("  tanh(phi) = v/c,  rapidities ADD: phi = phi1 + phi2")
print(f"{'v1/c':>8} {'v2/c':>8} {'phi1':>10} {'phi2':>10} {'phi_tot':>10} {'v_result':>10}")
print("-" * 60)
for v1, v2 in [(0.5, 0.5), (0.9, 0.9), (0.5, 0.9), (0.99, 0.99)]:
    phi1 = np.arctanh(v1)
    phi2 = np.arctanh(v2)
    phi_tot = phi1 + phi2
    v_res = np.tanh(phi_tot)
    print(f"{v1:8.2f} {v2:8.2f} {phi1:10.4f} {phi2:10.4f} {phi_tot:10.4f} {v_res:10.6f}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Relativistic Velocity Addition Table

Fortran

program.f9063 lines

program velocity_addition
  implicit none
  double precision :: V, u_prime, u_class, u_rel, error_pct
  double precision :: V_vals(5), up_vals(7)
  integer :: i, j

V_vals = (/0.1d0, 0.3d0, 0.5d0, 0.7d0, 0.9d0/)
  up_vals = (/0.1d0, 0.3d0, 0.5d0, 0.7d0, 0.9d0, 0.95d0, 1.0d0/)

print '(A)', repeat('=', 70)
  print '(A)', 'RELATIVISTIC VELOCITY ADDITION'
  print '(A)', 'u = (u'' + V) / (1 + u''*V/c^2)'
  print '(A)', repeat('=', 70)

do i = 1, 5
    V = V_vals(i)
    print '(/,A,F4.1,A)', '  Frame velocity V = ', V, 'c'
    print '(A10, A14, A14, A12)', &
      'u''/c', 'Classical', 'Relativistic', 'Diff %'
    print '(A)', repeat('-', 55)

do j = 1, 7
      u_prime = up_vals(j)
      u_class = u_prime + V
      u_rel = (u_prime + V) / (1.0d0 + u_prime * V)

if (u_rel > 1.0d-15) then
        error_pct = abs(u_class - u_rel) / u_rel * 100.0d0
      else
        error_pct = 0.0d0
      end if

print '(F10.2, F14.6, F14.6, F12.4)', &
        u_prime, u_class, u_rel, error_pct
    end do
  end do

print '(/,A)', repeat('=', 70)
  print '(A)', 'SUCCESSIVE BOOSTS: Combining many small velocities'
  print '(A)', repeat('=', 70)

block
    double precision :: dv, v_total, v_classical
    integer :: n, k

dv = 0.1d0
    print '(A,F4.1,A)', 'Adding increments of ', dv, 'c repeatedly:'
    print '(A8, A14, A14)', 'Step', 'Relativistic', 'Classical'
    print '(A)', repeat('-', 40)

v_total = 0.0d0
    v_classical = 0.0d0
    do k = 1, 15
      v_total = (v_total + dv) / (1.0d0 + v_total * dv)
      v_classical = v_classical + dv
      print '(I8, F14.6, F14.6)', k, v_total, v_classical
    end do
    print '(A)', 'Relativistic result NEVER exceeds c = 1.0!'
  end block

end program velocity_addition

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

Share:X Reddit LinkedIn

← Lorentz Transformations Next: Spacetime Diagrams →