Chapter 11: Symmetries and Killing Vectors

Killing vectors generate symmetries of spacetime—isometries that leave the metric unchanged. Each Killing vector corresponds to a conserved quantity along geodesics, providing powerful tools for solving the geodesic equation.

Killing's Equation

A vector field ξ^μ is a Killing vector if the Lie derivative of the metric vanishes:

$\mathcal{L}_\xi g_{\mu\nu} = 0$

Equivalently: $\nabla_\mu \xi_\nu + \nabla_\nu \xi_\mu = 0$

This means the metric is unchanged when we "flow" along the direction of ξ^μ. The spacetime looks the same from any point along this flow.

Common Killing Vectors

Time Translation (Schwarzschild)

$\xi^\mu = (1, 0, 0, 0) = \partial_t$

Metric doesn't depend on t → Energy conservation

Axial Rotation (Schwarzschild)

$\psi^\mu = (0, 0, 0, 1) = \partial_\phi$

Metric doesn't depend on φ → Angular momentum conservation

Minkowski Space (10 Killing vectors)

4 translations + 3 rotations + 3 boosts = 10 generators of Poincaré group

Conserved Quantities

For a geodesic with tangent u^μ, each Killing vector gives a conserved quantity:

$Q = \xi_\mu u^\mu = \text{constant along geodesic}$

Energy

$E = -\xi_\mu u^\mu = -g_{tt} \frac{dt}{d\tau}$

From time translation symmetry

Angular Momentum

$L = \psi_\mu u^\mu = g_{\phi\phi} \frac{d\phi}{d\tau}$

From axial rotation symmetry

Killing Tensors

Some spacetimes have higher-rank Killing tensors K_μν satisfying:

$\nabla_{(\rho} K_{\mu\nu)} = 0$

Carter Constant (Kerr Spacetime)

The Kerr metric has a non-trivial Killing tensor giving the Carter constant Q:

$Q = K_{\mu\nu} u^\mu u^\nu = \text{constant}$

This "hidden symmetry" makes geodesics in Kerr spacetime integrable.

Python: Killing Vector Analysis

Python

killing_vectors.py229 lines

#!/usr/bin/env python3
"""
╔════════════════════════════════════════════════════════════════════════════╗
║          KILLING VECTOR ANALYSIS FOR SCHWARZSCHILD (Numerical)             ║
║                                                                            ║
║  Killing Equation: nabla_mu xi_nu + nabla_nu xi_mu = 0                    ║
║                                                                            ║
║  Time Translation:  xi = d_t  -> Energy Conservation                       ║
║  Axial Rotation:    psi = d_phi -> Angular Momentum Conservation           ║
╚════════════════════════════════════════════════════════════════════════════╝
"""
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import io, base64

# ═══════════════════════════════════════════════════════════════
# Numerical infrastructure (Schwarzschild)
# ═══════════════════════════════════════════════════════════════

def schwarzschild_metric(r_val, theta_val, M=1.0):
    f = 1.0 - 2.0*M/r_val
    g = np.diag([-f, 1.0/f, r_val**2, r_val**2 * np.sin(theta_val)**2])
    g_inv = np.diag([-1.0/f, f, 1.0/r_val**2, 1.0/(r_val**2 * np.sin(theta_val)**2)])
    return g, g_inv

def metric_derivs(r_val, theta_val, M=1.0, h=1e-6):
    n = 4
    dg = [np.zeros((n, n)) for _ in range(n)]
    gp, _ = schwarzschild_metric(r_val + h, theta_val, M)
    gm, _ = schwarzschild_metric(r_val - h, theta_val, M)
    dg[1] = (gp - gm) / (2*h)
    gp, _ = schwarzschild_metric(r_val, theta_val + h, M)
    gm, _ = schwarzschild_metric(r_val, theta_val - h, M)
    dg[2] = (gp - gm) / (2*h)
    return dg

def compute_christoffel(r_val, theta_val, M=1.0, h=1e-6):
    n = 4
    g, g_inv = schwarzschild_metric(r_val, theta_val, M)
    dg = metric_derivs(r_val, theta_val, M, h)
    Gamma = np.zeros((n, n, n))
    for rho in range(n):
        for mu in range(n):
            for nu in range(n):
                s = 0.0
                for sigma in range(n):
                    s += g_inv[rho, sigma] * (dg[mu][sigma, nu] + dg[nu][sigma, mu] - dg[sigma][mu, nu])
                Gamma[rho, mu, nu] = 0.5 * s
    return Gamma

def verify_killing_numerical(xi_up, r_val, theta_val, M=1.0, h=1e-6):
    """
    Verify Killing equation: nabla_mu xi_nu + nabla_nu xi_mu = 0
    numerically at given point.

xi_up: contravariant components of the Killing vector candidate
    Returns: 4x4 array of Killing equation residuals
    """
    n = 4
    xi = np.array(xi_up, dtype=float)
    g, g_inv = schwarzschild_metric(r_val, theta_val, M)
    Gamma = compute_christoffel(r_val, theta_val, M, h)

# Lower the index: xi_mu = g_mu_nu xi^nu
    xi_lower = g @ xi

# We need d_mu (xi_lower_nu). Since xi^a are constants in coord basis,
    # xi_nu = g_nu_a xi^a, so d_mu xi_nu = (d_mu g_nu_a) xi^a
    dg = metric_derivs(r_val, theta_val, M, h)

# nabla_mu xi_nu = d_mu xi_nu - Gamma^rho_mu_nu xi_rho
    nabla = np.zeros((n, n))
    for mu in range(n):
        for nu in range(n):
            # partial_mu xi_nu = sum_a (dg[mu][nu, a]) * xi^a
            partial = sum(dg[mu][nu, a] * xi[a] for a in range(n))
            conn = -sum(Gamma[rho, mu, nu] * xi_lower[rho] for rho in range(n))
            nabla[mu, nu] = partial + conn

# Killing check: nabla_mu xi_nu + nabla_nu xi_mu
    killing = nabla + nabla.T
    return killing

# ═══════════════════════════════════════════════════════════════
# Main computation
# ═══════════════════════════════════════════════════════════════
M = 1.0
r0, th0 = 6.0*M, np.pi/2

print("=" * 66)
print("KILLING VECTORS OF SCHWARZSCHILD SPACETIME (Numerical)")
print("=" * 66)
print(f"\nEvaluated at r = {r0:.1f}M, theta = pi/2\n")

coord_names = ['t', 'r', 'theta', 'phi']

# 1. Time translation: xi = d_t = (1, 0, 0, 0)
xi_t = [1, 0, 0, 0]
K_t = verify_killing_numerical(xi_t, r0, th0, M)
print("1. Time Translation Killing Vector")
print("   xi = d_t = (1, 0, 0, 0)")
print("   Killing equation residual nabla_(mu xi_nu):")
for mu in range(4):
    row = "     ["
    for nu in range(4):
        row += f" {K_t[mu,nu]:+10.2e}"
    row += " ]"
    print(row)
max_t = np.max(np.abs(K_t))
print(f"   Max residual: {max_t:.2e}")
if max_t < 1e-8:
    print("   -> YES, this is a Killing vector!")
    print("   Physical: metric independent of t -> Energy conservation")
    print("   Conserved: E = -(1-2M/r) dt/dtau")

print()
print("-" * 66)
print()

# 2. Axial rotation: psi = d_phi = (0, 0, 0, 1)
xi_phi = [0, 0, 0, 1]
K_phi = verify_killing_numerical(xi_phi, r0, th0, M)
print("2. Axial Rotation Killing Vector")
print("   psi = d_phi = (0, 0, 0, 1)")
print("   Killing equation residual nabla_(mu psi_nu):")
for mu in range(4):
    row = "     ["
    for nu in range(4):
        row += f" {K_phi[mu,nu]:+10.2e}"
    row += " ]"
    print(row)
max_phi = np.max(np.abs(K_phi))
print(f"   Max residual: {max_phi:.2e}")
if max_phi < 1e-8:
    print("   -> YES, this is a Killing vector!")
    print("   Physical: metric independent of phi -> Angular momentum conservation")
    print("   Conserved: L = r^2 sin^2(theta) dphi/dtau")

print()
print("-" * 66)
print()

# 3. Counter-example: d_r (NOT a Killing vector)
xi_r = [0, 1, 0, 0]
K_r = verify_killing_numerical(xi_r, r0, th0, M)
print("3. Radial Direction (Counter-example)")
print("   d_r = (0, 1, 0, 0)")
print("   Killing equation residual:")
for mu in range(4):
    row = "     ["
    for nu in range(4):
        row += f" {K_r[mu,nu]:+10.2e}"
    row += " ]"
    print(row)
max_r = np.max(np.abs(K_r))
print(f"   Max residual: {max_r:.2e}")
if max_r > 1e-8:
    print("   -> NO, NOT a Killing vector!")
    print("   Metric depends on r: no radial translation symmetry")

print()
print("=" * 66)
print("CONSERVED QUANTITIES ALONG GEODESICS")
print("=" * 66)
print()
print("Energy (from xi = d_t):")
print("  E = -xi_mu u^mu = (1 - 2M/r) dt/dtau")
print()
print("Angular Momentum (from psi = d_phi):")
print("  L = psi_mu u^mu = r^2 sin^2(theta) dphi/dtau")
print()
print("These reduce the geodesic equation from 4 coupled ODEs to 2!")

# ═══════════════════════════════════════════════════════════════
# Plot Killing equation residuals vs radius
# ═══════════════════════════════════════════════════════════════
r_arr = np.linspace(2.5*M, 25*M, 100)
max_K_t = np.zeros_like(r_arr)
max_K_phi = np.zeros_like(r_arr)
max_K_r = np.zeros_like(r_arr)

for i, rv in enumerate(r_arr):
    Kt = verify_killing_numerical([1,0,0,0], rv, th0, M)
    max_K_t[i] = np.max(np.abs(Kt))
    Kp = verify_killing_numerical([0,0,0,1], rv, th0, M)
    max_K_phi[i] = np.max(np.abs(Kp))
    Kr = verify_killing_numerical([0,1,0,0], rv, th0, M)
    max_K_r[i] = np.max(np.abs(Kr))

fig, axes = plt.subplots(1, 2, figsize=(14, 5))
fig.patch.set_facecolor('#0a0a1a')
fig.suptitle('Killing Equation Verification for Schwarzschild',
             color='white', fontsize=14, fontweight='bold', y=1.02)

# Left: true Killing vectors (residuals should be ~0)
ax = axes[0]
ax.set_facecolor('#0a0a1a')
ax.semilogy(r_arr/M, max_K_t + 1e-20, color='#f472b6', linewidth=2, label=r'$\xi = \partial_t$ (time)')
ax.semilogy(r_arr/M, max_K_phi + 1e-20, color='#38bdf8', linewidth=2, label=r'$\psi = \partial_\phi$ (axial)')
ax.set_xlabel('r / M', color='#94a3b8')
ax.set_ylabel('Max |Killing residual|', color='#94a3b8')
ax.set_title('True Killing Vectors (residual ~ 0)', color='white')
ax.legend(facecolor='#0a0a1a', edgecolor='#334155', labelcolor='#94a3b8')
ax.tick_params(colors='#94a3b8')
for spine in ax.spines.values():
    spine.set_color('#334155')

# Right: non-Killing vector (large residuals)
ax = axes[1]
ax.set_facecolor('#0a0a1a')
ax.plot(r_arr/M, max_K_r, color='#ef4444', linewidth=2, label=r'$\partial_r$ (NOT Killing)')
ax.axhline(0, color='#94a3b8', linewidth=0.5, linestyle='--')
ax.set_xlabel('r / M', color='#94a3b8')
ax.set_ylabel('Max |Killing residual|', color='#94a3b8')
ax.set_title('Non-Killing Direction (large residual)', color='white')
ax.legend(facecolor='#0a0a1a', edgecolor='#334155', labelcolor='#94a3b8')
ax.tick_params(colors='#94a3b8')
for spine in ax.spines.values():
    spine.set_color('#334155')

plt.tight_layout()
buf = io.BytesIO()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a1a'))
# Image saved as output.png
buf.close()
plt.close()

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Conserved Quantities

Python

conserved_plot.py179 lines

import subprocess, tempfile, os, io, base64
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

fortran_source = r"""
program conserved_orbit
    implicit none
    integer, parameter :: dp = selected_real_kind(15)
    real(dp), parameter :: M = 1.0_dp
    real(dp), parameter :: pi = 4.0_dp * atan(1.0_dp)

real(dp) :: r0, E0, L0, f0
    real(dp) :: r, phi, t_coord, tau
    real(dp) :: r_dot, phi_dot, t_dot
    real(dp) :: f, E_check, L_check, norm
    real(dp) :: dtau
    real(dp) :: kr1,kr2,kr3,kr4,kp1,kp2,kp3,kp4
    integer :: i, n_steps, n_out

r0 = 10.0_dp * M
    f0 = 1.0_dp - 2.0_dp*M/r0

! Slightly eccentric orbit
    L0 = 4.0_dp * M
    E0 = 0.97_dp

t_dot = E0 / f0
    phi_dot = L0 / r0**2
    r_dot = sqrt(abs(E0**2 - f0*(1.0_dp + L0**2/r0**2)))

r = r0
    phi = 0.0_dp
    t_coord = 0.0_dp
    tau = 0.0_dp

n_steps = 50000
    dtau = 0.01_dp
    n_out = 500

print '(A)', 'DATA_START'
    do i = 0, n_steps
        if (mod(i, n_steps/n_out) == 0) then
            f = 1.0_dp - 2.0_dp*M/r
            E_check = f * t_dot
            L_check = r**2 * phi_dot
            norm = -f*t_dot**2 + r_dot**2/f + r**2*phi_dot**2
            write(*,'(F14.8,A,F14.8,A,F14.8,A,F14.8,A,F14.8,A,F14.8)') &
                tau, ',', r, ',', phi, ',', E_check, ',', L_check, ',', norm
        end if
        if (i == n_steps) exit

! Simple Euler integration for orbit
        f = 1.0_dp - 2.0_dp*M/r
        ! d(r_dot)/dtau = -M/r^2 + L0^2*(r - 3*M)/r^4
        kr1 = (-M/r**2 + L0**2/r**3 - 3.0_dp*M*L0**2/r**4)
        kp1 = -2.0_dp*r_dot*phi_dot/r

r = r + r_dot * dtau
        r_dot = r_dot + kr1 * dtau
        phi = phi + phi_dot * dtau
        phi_dot = L0 / r**2
        f = 1.0_dp - 2.0_dp*M/r
        t_dot = E0 / f
        tau = tau + dtau

if (r < 2.1_dp*M) exit
    end do
    print '(A)', 'DATA_END'
end program conserved_orbit
"""

workdir = tempfile.mkdtemp()
src = os.path.join(workdir, 'conserved.f90')
exe = os.path.join(workdir, 'conserved')

with open(src, 'w') as f:
    f.write(fortran_source)

comp = subprocess.run(['gfortran', '-O2', '-o', exe, src],
                      capture_output=True, text=True, timeout=30)
if comp.returncode != 0:
    print("Compilation error:", comp.stderr)
else:
    result = subprocess.run([exe], capture_output=True, text=True, timeout=30, cwd=workdir)
    output = result.stdout

lines = []
    in_data = False
    for line in output.split('\n'):
        if 'DATA_START' in line:
            in_data = True
            continue
        if 'DATA_END' in line:
            break
        if in_data and line.strip():
            lines.append(line.strip())

tau_arr, r_arr, phi_arr, E_arr, L_arr, norm_arr = [], [], [], [], [], []
    for line in lines:
        vals = [float(x) for x in line.split(',')]
        if len(vals) == 6:
            tau_arr.append(vals[0])
            r_arr.append(vals[1])
            phi_arr.append(vals[2])
            E_arr.append(vals[3])
            L_arr.append(vals[4])
            norm_arr.append(vals[5])

tau_arr = np.array(tau_arr)
    r_arr = np.array(r_arr)
    phi_arr = np.array(phi_arr)
    E_arr = np.array(E_arr)
    L_arr = np.array(L_arr)
    norm_arr = np.array(norm_arr)

fig, axes = plt.subplots(2, 2, figsize=(14, 10))
    fig.patch.set_facecolor('#0f172a')
    fig.suptitle('Conserved Quantities Along Geodesic (Killing Vectors)', color='white', fontsize=14, fontweight='bold')

ax = axes[0, 0]
    ax.set_facecolor('#1e293b')
    x = r_arr * np.cos(phi_arr)
    y = r_arr * np.sin(phi_arr)
    ax.plot(x, y, color='#22d3ee', linewidth=0.8)
    circle = plt.Circle((0, 0), 2.0, color='black', zorder=5)
    ax.add_patch(circle)
    ax.set_aspect('equal')
    ax.set_xlabel('x / M', color='#cbd5e1')
    ax.set_ylabel('y / M', color='#cbd5e1')
    ax.set_title('Orbit Shape', color='white')
    ax.tick_params(colors='#cbd5e1')
    for spine in ax.spines.values():
        spine.set_color('#334155')
    ax.grid(True, color='#334155', alpha=0.4)

ax2 = axes[0, 1]
    ax2.set_facecolor('#1e293b')
    ax2.plot(tau_arr, r_arr, color='#f472b6', linewidth=1.5)
    ax2.set_xlabel('Proper time $\\tau$', color='#cbd5e1')
    ax2.set_ylabel('r / M', color='#cbd5e1')
    ax2.set_title('Radial Oscillation', color='white')
    ax2.tick_params(colors='#cbd5e1')
    for spine in ax2.spines.values():
        spine.set_color('#334155')
    ax2.grid(True, color='#334155', alpha=0.4)

ax3 = axes[1, 0]
    ax3.set_facecolor('#1e293b')
    ax3.plot(tau_arr, E_arr, color='#4ade80', linewidth=2, label='Energy E')
    ax3.set_xlabel('Proper time $\\tau$', color='#cbd5e1')
    ax3.set_ylabel('E', color='#cbd5e1')
    ax3.set_title('Energy Conservation ($\\partial_t$ Killing vector)', color='white')
    ax3.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1')
    ax3.tick_params(colors='#cbd5e1')
    for spine in ax3.spines.values():
        spine.set_color('#334155')
    ax3.grid(True, color='#334155', alpha=0.4)

ax4 = axes[1, 1]
    ax4.set_facecolor('#1e293b')
    ax4.plot(tau_arr, L_arr, color='#fbbf24', linewidth=2, label='Angular Momentum L')
    ax4.set_xlabel('Proper time $\\tau$', color='#cbd5e1')
    ax4.set_ylabel('L', color='#cbd5e1')
    ax4.set_title('Angular Momentum Conservation ($\\partial_\\phi$ Killing vector)', color='white')
    ax4.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1')
    ax4.tick_params(colors='#cbd5e1')
    for spine in ax4.spines.values():
        spine.set_color('#334155')
    ax4.grid(True, color='#334155', alpha=0.4)

plt.tight_layout()
    buf = io.BytesIO()
    plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a1a'))
    buf.close()
    plt.close()
    # Image saved as output.png

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Bianchi Identities Next: Part III - Einstein Field Equations →