← Back to Part II: Lorentz Transformations

Chapter 1: Lorentz Transformations

The Lorentz transformations are the mathematical heart of special relativity. They describe exactly how space and time coordinates transform between different inertial reference frames, replacing the simpler Galilean transformations that fail at high velocities.

The Lorentz Transformation Equations

Consider frame S' moving at velocity v in the +x direction relative to frame S. Both frames use standard configuration (origins coincide at t = t' = 0, axes parallel).

Lorentz Transformations (S → S')

\( t' = \gamma \left( t - \frac{vx}{c^2} \right) \)

\( x' = \gamma (x - vt) \)

\( y' = y \)

\( z' = z \)

where \( \gamma = \frac{1}{\sqrt{1 - v^2/c^2}} \)

Inverse Transformations (S' → S)

\( t = \gamma \left( t' + \frac{vx'}{c^2} \right) \)

\( x = \gamma (x' + vt') \)

\( y = y' \)

\( z = z' \)

Just replace v with −v (S moves at −v relative to S')

Geometric Picture: axes "scissor" under a boost

Derivation from Einstein's Postulates

Step 1: Linearity

The transformation must be linear (to preserve uniform motion):

\( x' = Ax + Bt \) and \( t' = Cx + Dt \)

where A, B, C, D depend only on v

Step 2: Origin of S' at x' = 0

The origin of S' moves at x = vt in frame S:

\( 0 = A(vt) + Bt \Rightarrow B = -Av \)

Step 3: Light Speed Invariance

A light pulse at x = ct must also be at x' = ct':

\( ct' = c(Ct + Dt) \) and \( x' = A(ct - vt) = ct' \)

This gives us relations between A, C, D

Step 4: Reciprocity

S sees S' moving at +v; S' sees S moving at −v. By the principle of relativity:

The inverse transformation uses −v (not different coefficients)

Final Result: Combining all constraints yields A = D = γ, B = −γv, C = −γv/c², giving us the Lorentz transformations.

Matrix Formulation

The Lorentz transformation can be written elegantly in matrix form:

\( \begin{pmatrix} ct' \\ x' \end{pmatrix} = \begin{pmatrix} \gamma & -\beta\gamma \\ -\beta\gamma & \gamma \end{pmatrix} \begin{pmatrix} ct \\ x \end{pmatrix} \)

where β = v/c

Using rapidity φ where tanh(φ) = β:

\( \Lambda = \begin{pmatrix} \cosh\phi & -\sinh\phi \\ -\sinh\phi & \cosh\phi \end{pmatrix} \)

Compare to rotation matrix with cos and sin!

Key Properties

1. Preserves the Spacetime Interval

\( c^2t'^2 - x'^2 = c^2t^2 - x^2 \) (invariant under Lorentz transformation)

2. Forms a Group (the Lorentz Group)

Successive transformations give another Lorentz transformation. Identity exists (v = 0). Every transformation has an inverse (v → −v).

3. Reduces to Galilean at Low Speeds

When v ≪ c, γ ≈ 1 and vx/c² ≈ 0, so t' ≈ t and x' ≈ x − vt (Galilean form).

4. Composition is Non-Linear in Velocities

Two successive boosts (v₁, then v₂) give a combined velocity less than v₁ + v₂. Rapidities add linearly: φ₁₂ = φ₁ + φ₂.

Reading Time Dilation and Length Contraction

Time Dilation

Clock at rest in S' (x' = 0). In S:

\( \Delta t = \gamma \Delta t' \) (moving clock runs slow)

Length Contraction

Rod at rest in S' (proper length L₀). In S, measured simultaneously:

\( L = L_0/\gamma \) (moving rod is shortened)

Interactive Simulations

Lorentz Boost: Transform Events Between Frames

Python

script.py53 lines

import numpy as np

print("=" * 70)
print("LORENTZ TRANSFORMATION VISUALIZER")
print("=" * 70)

def lorentz_boost(t, x, beta):
    gamma = 1.0 / np.sqrt(1.0 - beta**2)
    t_prime = gamma * (t - beta * x)
    x_prime = gamma * (x - beta * t)
    return t_prime, x_prime

# Define events in frame S
events = [
    (0.0, 0.0, "Origin"),
    (1.0, 0.0, "Pure time"),
    (0.0, 1.0, "Pure space"),
    (1.0, 1.0, "On light cone"),
    (3.0, 1.0, "Timelike"),
    (1.0, 3.0, "Spacelike"),
    (5.0, 4.0, "Future timelike"),
]

betas = [0.3, 0.6, 0.9]

for beta in betas:
    gamma = 1.0 / np.sqrt(1.0 - beta**2)
    print(f"\n--- Boost: v = {beta}c, gamma = {gamma:.4f} ---")
    print(f"{'Event':>20} {'S: (t, x)':>14} {'S_prime: (t, x)':>20} {'s^2 (S)':>10} {'s^2 (S_prime)':>14}")
    print("-" * 82)

for t, x, name in events:
        tp, xp = lorentz_boost(t, x, beta)
        s2 = -t**2 + x**2
        s2p = -tp**2 + xp**2
        print(f"{name:>20} ({t:5.2f},{x:5.2f}) ({tp:8.4f},{xp:8.4f}) {s2:10.4f} {s2p:14.4f}")

print("\n" + "=" * 70)
print("KEY: s^2 is INVARIANT under Lorentz transformations!")
print("The interval is the same in every frame.")
print("=" * 70)

# Lorentz transformation matrix
print("\nLorentz Matrix for v = 0.6c:")
beta = 0.6
gamma = 1.0 / np.sqrt(1.0 - beta**2)
L_matrix = np.array([[gamma, -gamma*beta],
                      [-gamma*beta, gamma]])
print(f"  [{L_matrix[0,0]:8.4f}  {L_matrix[0,1]:8.4f}]")
print(f"  [{L_matrix[1,0]:8.4f}  {L_matrix[1,1]:8.4f}]")
print(f"  det(L) = {np.linalg.det(L_matrix):.6f} (should be 1)")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Lorentz Transformation Matrix and Event Mapping

Fortran

program.f9055 lines

program lorentz_transform
  implicit none
  double precision :: beta, gamma_val, t, x, tp, xp, s2, s2p
  double precision :: L(2,2), det_L
  double precision :: t_ev(6), x_ev(6)
  character(len=16) :: names(6)
  integer :: i, j
  double precision :: betas(5)

t_ev = (/0.0d0, 1.0d0, 0.0d0, 1.0d0, 3.0d0, 1.0d0/)
  x_ev = (/0.0d0, 0.0d0, 1.0d0, 1.0d0, 1.0d0, 3.0d0/)
  names = (/'Origin          ', 'Pure time       ', &
            'Pure space      ', 'Light cone      ', &
            'Timelike        ', 'Spacelike       '/)

betas = (/0.1d0, 0.3d0, 0.5d0, 0.7d0, 0.9d0/)

print '(A)', repeat('=', 70)
  print '(A)', 'LORENTZ TRANSFORMATION: BOOST ALONG X-AXIS'
  print '(A)', repeat('=', 70)

do j = 1, 5
    beta = betas(j)
    gamma_val = 1.0d0 / sqrt(1.0d0 - beta**2)

! Build Lorentz matrix
    L(1,1) = gamma_val
    L(1,2) = -gamma_val * beta
    L(2,1) = -gamma_val * beta
    L(2,2) = gamma_val
    det_L = L(1,1)*L(2,2) - L(1,2)*L(2,1)

print '(/,A,F4.1,A,F8.4,A,F8.6)', &
      '  v/c = ', beta, '  gamma = ', gamma_val, '  det = ', det_L
    print '(A16, A14, A18, A10, A12)', &
      'Event', 'S(t,x)', 'S''(t'',x'')', 's^2(S)', 's^2(S'')'
    print '(A)', repeat('-', 70)

do i = 1, 6
      t = t_ev(i)
      x = x_ev(i)
      tp = L(1,1)*t + L(1,2)*x
      xp = L(2,1)*t + L(2,2)*x
      s2 = -t**2 + x**2
      s2p = -tp**2 + xp**2
      print '(A16, A1, F5.2, A1, F5.2, A3, F7.3, A1, F7.3, A2, F10.4, F12.4)', &
        names(i), '(', t, ',', x, ')  (', tp, ',', xp, ') ', s2, s2p
    end do
  end do

print '(/,A)', 'Invariant s^2 is preserved in every boost!'

end program lorentz_transform

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

Share:X Reddit LinkedIn

← Part II Overview Next: Velocity Addition Formula →