← Back to Part III: Relativistic Mechanics

Chapter 1: Four-Vectors

Four-vectors are the natural objects in spacetime. They transform simply under Lorentz transformations, have invariant "lengths," and provide a unified framework for relativistic physics.

Four-Position

\( x^\mu = (ct, x, y, z) = (ct, \vec{x}) \)

The four-position combines time and space into a single 4-component vector. The index μ runs from 0 to 3, with x⁰ = ct. Under Lorentz transformations: \( x'^\mu = \Lambda^\mu_{\;\nu} x^\nu \)

Four-Velocity

\( u^\mu = \frac{dx^\mu}{d\tau} = \gamma(c, \vec{v}) \)

The derivative with respect to proper time τ (not coordinate time t). This ensures u^μ transforms as a four-vector. Note: \( u_\mu u^\mu = c^2 \) (invariant magnitude).

The Minkowski Metric

\( \eta_{\mu\nu} = \text{diag}(1, -1, -1, -1) \)

The metric is used to raise/lower indices and compute inner products:

• \( x_\mu = \eta_{\mu\nu} x^\nu = (ct, -x, -y, -z) \)
• \( A \cdot B = A_\mu B^\mu = A^0 B^0 - \vec{A} \cdot \vec{B} \)
• \( x_\mu x^\mu = c^2t^2 - x^2 - y^2 - z^2 \) (invariant interval)

Interactive Simulations

Four-Vector Transformations Under Lorentz Boosts

Python

script.py60 lines

import numpy as np

print("=" * 70)
print("FOUR-VECTOR LORENTZ TRANSFORMATION")
print("=" * 70)

def lorentz_matrix(beta):
    gamma = 1.0 / np.sqrt(1.0 - beta**2)
    return np.array([
        [gamma, -gamma*beta, 0, 0],
        [-gamma*beta, gamma, 0, 0],
        [0, 0, 1, 0],
        [0, 0, 0, 1]
    ])

def minkowski_norm(v):
    """Compute A_mu A^mu = -v[0]^2 + v[1]^2 + v[2]^2 + v[3]^2"""
    return -v[0]**2 + v[1]**2 + v[2]**2 + v[3]**2

# Four-vectors to transform
vectors = [
    (np.array([5.0, 3.0, 0.0, 0.0]), "Position 4-vector"),
    (np.array([1.0, 0.6, 0.0, 0.0]), "4-velocity (v=0.6c)"),
    (np.array([2.0, 1.5, 0.5, 0.0]), "4-momentum"),
    (np.array([1.0, 1.0, 0.0, 0.0]), "Null vector (light)"),
]

beta = 0.5
L = lorentz_matrix(beta)
gamma = 1.0 / np.sqrt(1.0 - beta**2)

print(f"\nBoost velocity: v = {beta}c (gamma = {gamma:.4f})")
print(f"\nLorentz Matrix:")
for row in L:
    print(f"  [{row[0]:8.4f} {row[1]:8.4f} {row[2]:8.4f} {row[3]:8.4f}]")

for vec, name in vectors:
    vec_prime = L @ vec
    norm_orig = minkowski_norm(vec)
    norm_prime = minkowski_norm(vec_prime)
    print(f"\n{name}:")
    print(f"  S:  ({vec[0]:7.3f}, {vec[1]:7.3f}, {vec[2]:7.3f}, {vec[3]:7.3f})  norm = {norm_orig:8.4f}")
    print(f"  S': ({vec_prime[0]:7.3f}, {vec_prime[1]:7.3f}, {vec_prime[2]:7.3f}, {vec_prime[3]:7.3f})  norm = {norm_prime:8.4f}")
    print(f"  Norm preserved: {'YES' if abs(norm_orig - norm_prime) < 1e-10 else 'NO'}")

# Four-velocity construction
print("\n" + "=" * 70)
print("FOUR-VELOCITY: u^mu = gamma*(c, v)")
print("=" * 70)
print(f"{'v/c':>6} {'gamma':>8} {'u^0':>10} {'u^1':>10} {'u_mu u^mu':>12}")
print("-" * 50)
for v in [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 0.99]:
    g = 1.0 / np.sqrt(1.0 - v**2) if v > 0 else 1.0
    u0 = g
    u1 = g * v
    norm = -u0**2 + u1**2
    print(f"{v:6.2f} {g:8.4f} {u0:10.4f} {u1:10.4f} {norm:12.6f}")
print("\nFour-velocity norm is always -1 (in c=1 units)!")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Four-Vector Inner Products and Boosts

Fortran

program.f9078 lines

program four_vectors
  implicit none
  double precision :: beta, gamma_val, v
  double precision :: u0, u1, norm
  double precision :: L(4,4), vec(4), vec_p(4)
  double precision :: norm_orig, norm_boost
  integer :: i, j, k

print '(A)', repeat('=', 60)
  print '(A)', 'FOUR-VELOCITY CONSTRUCTION'
  print '(A)', 'u^mu = gamma * (c, v_x, v_y, v_z)'
  print '(A)', repeat('=', 60)

print '(A8, A10, A12, A12, A14)', &
    'v/c', 'gamma', 'u^0', 'u^1', 'u_mu*u^mu'
  print '(A)', repeat('-', 58)

do i = 0, 9
    v = dble(i) * 0.1d0
    if (v < 1.0d-15) then
      gamma_val = 1.0d0
    else
      gamma_val = 1.0d0 / sqrt(1.0d0 - v**2)
    end if
    u0 = gamma_val
    u1 = gamma_val * v
    norm = -u0**2 + u1**2
    print '(F8.1, F10.4, F12.4, F12.4, F14.6)', &
      v, gamma_val, u0, u1, norm
  end do
  print '(A)', 'Norm = -1 always (timelike, unit four-velocity)'

! Lorentz boost of a four-momentum
  print '(/,A)', repeat('=', 60)
  print '(A)', 'FOUR-MOMENTUM UNDER LORENTZ BOOST'
  print '(A)', repeat('=', 60)

beta = 0.6d0
  gamma_val = 1.0d0 / sqrt(1.0d0 - beta**2)

! Build Lorentz matrix
  L = 0.0d0
  L(1,1) = gamma_val
  L(1,2) = -gamma_val * beta
  L(2,1) = -gamma_val * beta
  L(2,2) = gamma_val
  L(3,3) = 1.0d0
  L(4,4) = 1.0d0

! Particle: m=1, v=0.3c in frame S
  v = 0.3d0
  gamma_val = 1.0d0 / sqrt(1.0d0 - v**2)
  vec(1) = gamma_val       ! E/c
  vec(2) = gamma_val * v   ! p_x
  vec(3) = 0.0d0
  vec(4) = 0.0d0

! Boost
  vec_p = 0.0d0
  do i = 1, 4
    do j = 1, 4
      vec_p(i) = vec_p(i) + L(i,j) * vec(j)
    end do
  end do

norm_orig = -vec(1)**2 + vec(2)**2 + vec(3)**2 + vec(4)**2
  norm_boost = -vec_p(1)**2 + vec_p(2)**2 + vec_p(3)**2 + vec_p(4)**2

print '(A,F4.1,A)', 'Boost: v = ', beta, 'c'
  print '(A,4F10.4)', 'p^mu (S):  ', vec
  print '(A,4F10.4)', 'p^mu (S''): ', vec_p
  print '(A,F12.6)', 'Norm (S):   ', norm_orig
  print '(A,F12.6)', 'Norm (S''):  ', norm_boost
  print '(A)', 'p_mu*p^mu = -m^2 is invariant!'

end program four_vectors

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

Share:X Reddit LinkedIn

← Part III Overview Next: Relativistic Momentum →