← Back to Part IV: Electromagnetism & Fields

Chapter 5: Lagrangian Formulation

The Lagrangian formulation provides the deepest understanding of electromagnetism, connecting to symmetries via Noether's theorem and paving the way to quantum field theory.

Electromagnetic Lagrangian

\( \mathcal{L} = -\frac{1}{4\mu_0}F_{\mu\nu}F^{\mu\nu} - J^\mu A_\mu \)

Field kinetic term + interaction term

The Euler-Lagrange equations for A^μ give Maxwell's inhomogeneous equations. The action S = ∫ℒ d⁴x is Lorentz invariant.

Energy-Momentum Tensor

The stress-energy tensor T^μν encodes energy density, momentum density, and stress:

\( T^{\mu\nu} = \frac{1}{\mu_0}\left( F^{\mu\alpha}F^\nu_{\;\alpha} - \frac{1}{4}\eta^{\mu\nu}F_{\alpha\beta}F^{\alpha\beta} \right) \)

Conservation: \( \partial_\mu T^{\mu\nu} = -F^{\nu\alpha}J_\alpha \) (energy-momentum transfer to charges).

Symmetries and Conservation Laws

Gauge Symmetry → Charge Conservation

Invariance under A^μ → A^μ + ∂^μχ implies ∂_μJ^μ = 0.

Translation Symmetry → Energy-Momentum Conservation

Spacetime translation invariance gives ∂_μT^μν = 0 (in absence of sources).

Interactive Simulations

Relativistic Lagrangian: Action and Equations of Motion

Python

script.py62 lines

import numpy as np

print("=" * 70)
print("RELATIVISTIC LAGRANGIAN MECHANICS")
print("L = -mc^2 sqrt(1 - v^2/c^2) - V(x)")
print("=" * 70)

c = 1.0  # natural units
m = 1.0

# Free particle Lagrangian
print("\nFree particle: L = -m*c^2 * sqrt(1 - v^2/c^2)")
print(f"{'v/c':>8} {'L':>12} {'p = dL/dv':>14} {'E = pv - L':>14} {'E_check':>12}")
print("-" * 64)

for v in [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 0.95, 0.99]:
    gamma = 1.0 / np.sqrt(1.0 - v**2) if v > 0 else 1.0
    L = -m * np.sqrt(1.0 - v**2)  # c=1
    # Canonical momentum: p = dL/dv = m*gamma*v
    p = gamma * m * v
    # Energy: E = p*v - L (Legendre transform)
    E = p * v - L
    E_check = gamma * m  # should equal gamma*m*c^2
    print(f"{v:8.3f} {L:12.6f} {p:14.6f} {E:14.6f} {E_check:12.6f}")

print("\nNote: E = gamma*m (= gamma*mc^2 in SI) as expected!")

# Action for different paths
print("\n" + "=" * 70)
print("PRINCIPLE OF LEAST ACTION")
print("Action S = integral(-m * sqrt(1 - v^2)) dt")
print("=" * 70)

T = 5.0  # total time
D = 3.0  # total distance

# Path 1: Constant velocity
v_const = D / T
S1 = -m * np.sqrt(1.0 - v_const**2) * T

# Path 2: Fast then slow (piecewise)
t1 = T / 2
v_fast = D * 0.8 / t1
v_slow = D * 0.2 / (T - t1)
S2 = -m * (np.sqrt(1.0 - v_fast**2) * t1 + np.sqrt(1.0 - v_slow**2) * (T-t1))

# Path 3: Sinusoidal variation
N = 10000
dt = T / N
S3 = 0.0
for i in range(N):
    t = i * dt
    v_t = D/T + 0.3 * np.sin(2*np.pi*t/T)
    S3 += -m * np.sqrt(1.0 - v_t**2) * dt

print(f"\nTravel {D:.1f} units in {T:.1f} time units:")
print(f"  Constant v = {v_const:.4f}:  S = {S1:.6f}")
print(f"  Fast/slow split:       S = {S2:.6f}")
print(f"  Sinusoidal variation:  S = {S3:.6f}")
print(f"\nThe straight-line (constant v) path EXTREMIZES the action.")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Relativistic Lagrangian and Hamiltonian

Fortran

program.f9077 lines

program lagrangian
  implicit none
  double precision :: v, gamma_val, L, p, E, H
  double precision :: m, c2
  integer :: i
  double precision :: speeds(10)

m = 1.0d0
  c2 = 1.0d0  ! c = 1

speeds = (/0.0d0, 0.1d0, 0.2d0, 0.3d0, 0.4d0, &
             0.5d0, 0.7d0, 0.8d0, 0.9d0, 0.99d0/)

print '(A)', repeat('=', 70)
  print '(A)', 'RELATIVISTIC LAGRANGIAN AND HAMILTONIAN'
  print '(A)', 'L = -mc^2 * sqrt(1 - v^2/c^2)'
  print '(A)', 'H = gamma * mc^2  (total energy)'
  print '(A)', repeat('=', 70)

print '(A8, A10, A12, A12, A12, A12)', &
    'v/c', 'gamma', 'L', 'p=dL/dv', 'H=pv-L', 'gamma*m'
  print '(A)', repeat('-', 68)

do i = 1, 10
    v = speeds(i)
    if (v < 1.0d-15) then
      gamma_val = 1.0d0
    else
      gamma_val = 1.0d0 / sqrt(1.0d0 - v**2)
    end if

L = -m * sqrt(1.0d0 - v**2)
    p = gamma_val * m * v
    E = p * v - L  ! Legendre transform
    H = gamma_val * m

print '(F8.3, F10.4, F12.6, F12.6, F12.6, F12.6)', &
      v, gamma_val, L, p, E, H
  end do

print '(/,A)', 'H = pv - L = gamma*m*c^2 (verified!)'

! Euler-Lagrange equations verification
  print '(/,A)', repeat('=', 70)
  print '(A)', 'EULER-LAGRANGE: d/dt(dL/dv) = dL/dx'
  print '(A)', 'Free particle: dp/dt = 0 (momentum conserved)'
  print '(A)', repeat('=', 70)

block
    double precision :: T, dt, x, v_curr, p_init, p_final
    integer :: N, j

T = 10.0d0
    N = 10000
    dt = T / dble(N)
    v_curr = 0.6d0  ! constant velocity
    gamma_val = 1.0d0 / sqrt(1.0d0 - v_curr**2)
    p_init = gamma_val * m * v_curr

! Integrate free particle
    x = 0.0d0
    do j = 1, N
      x = x + v_curr * dt
    end do

p_final = gamma_val * m * v_curr

print '(A,F10.6)', 'Initial momentum:  ', p_init
    print '(A,F10.6)', 'Final momentum:    ', p_final
    print '(A,F10.6)', 'Final position:    ', x
    print '(A,F10.6)', 'Expected (v*T):    ', v_curr * T
    print '(A)', 'Momentum conserved for free particle!'
  end block

end program lagrangian

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

Share:X Reddit LinkedIn

← Four-Current and Charge Conservation Next: Path to General Relativity →