Chapter 5: Parallel Transport

Parallel transport moves vectors along curves while keeping them "as constant as possible." On curved surfaces, this process is path-dependent—a key signature of curvature.

Parallel Transport Equation

A vector V^μ is parallel transported along a curve x^μ(λ) if:

$\frac{DV^\mu}{d\lambda} = \frac{dV^\mu}{d\lambda} + \Gamma^\mu_{\nu\rho} V^\nu \frac{dx^\rho}{d\lambda} = 0$

Covariant derivative along curve vanishes

This is a set of first-order ODEs. Given initial conditions V^μ(λ₀), there exists a unique solution along the curve.

Geometric Interpretation

On Flat Space

In flat space with Cartesian coordinates, Γ = 0 and parallel transport reduces to keeping components constant: dV^μ/dλ = 0. The vector doesn't change.

On Curved Space

Components must change to compensate for the changing basis vectors. The result is path-dependent: transporting around a closed loop generally rotates the vector.

Holonomy

The rotation acquired after parallel transport around a closed loop is called holonomy. For small loops, the rotation angle is proportional to the enclosed area times the Riemann curvature tensor.

Classic Example: The 2-Sphere

On a sphere, parallel transport around a closed loop rotates a vector. Consider transporting a vector from the North Pole:

Start at North Pole with vector pointing along 0° longitude
Transport down to equator along 0° meridian
Transport along equator to 90° longitude
Transport back to North Pole along 90° meridian
Vector now points along 90° longitude—rotated 90°!

The rotation angle equals the solid angle enclosed (π/2 steradians = 90°).

Python: Parallel Transport on a Sphere

Python

script.py182 lines

#!/usr/bin/env python3
"""
Parallel Transport - Vector transport along curves in Schwarzschild geometry.
"""
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
def odeint(f, y0, t, args=(), full_output=False):
    y0 = np.array(y0, dtype=float); t = np.asarray(t, dtype=float)
    n = len(y0); ys = np.zeros((len(t), n)); ys[0] = y0; y = y0.copy()
    for i in range(1, len(t)):
        h = t[i] - t[i-1]
        k1 = np.array(f(y, t[i-1], *args), dtype=float)
        k2 = np.array(f(y+.5*h*k1, t[i-1]+.5*h, *args), dtype=float)
        k3 = np.array(f(y+.5*h*k2, t[i-1]+.5*h, *args), dtype=float)
        k4 = np.array(f(y+h*k3, t[i], *args), dtype=float)
        y = y + (h/6)*(k1+2*k2+2*k3+k4); ys[i] = y
    return ys
import io
import base64

def christoffel_sphere(theta, phi):
    """Non-zero Christoffel symbols for unit 2-sphere"""
    # Gamma^theta_phi_phi = -sin(theta)*cos(theta)
    # Gamma^phi_theta_phi = Gamma^phi_phi_theta = cot(theta)
    return {
        'theta_phi_phi': -np.sin(theta) * np.cos(theta),
        'phi_theta_phi': 1/np.tan(theta) if theta != 0 else 0,
        'phi_phi_theta': 1/np.tan(theta) if theta != 0 else 0
    }

def parallel_transport_eq(y, t, path_func, path_deriv):
    """ODE for parallel transport along a parameterized path"""
    V_theta, V_phi = y
    theta, phi = path_func(t)
    dtheta_dt, dphi_dt = path_deriv(t)

Gamma = christoffel_sphere(theta, phi)

# dV^theta/dt + Gamma^theta_mu_nu V^mu dx^nu/dt = 0
    dV_theta = -Gamma['theta_phi_phi'] * V_phi * dphi_dt

# dV^phi/dt + Gamma^phi_mu_nu V^mu dx^nu/dt = 0
    dV_phi = -Gamma['phi_theta_phi'] * V_theta * dphi_dt - Gamma['phi_phi_theta'] * V_phi * dtheta_dt

return [dV_theta, dV_phi]

def sphere_to_cartesian(theta, phi):
    """Convert spherical to Cartesian coordinates"""
    x = np.sin(theta) * np.cos(phi)
    y = np.sin(theta) * np.sin(phi)
    z = np.cos(theta)
    return x, y, z

def vector_to_cartesian(V_theta, V_phi, theta, phi):
    """Convert vector components to Cartesian"""
    # Basis vectors
    e_theta = np.array([np.cos(theta)*np.cos(phi), np.cos(theta)*np.sin(phi), -np.sin(theta)])
    e_phi = np.array([-np.sin(phi), np.cos(phi), 0])

V_cart = V_theta * e_theta + V_phi * np.sin(theta) * e_phi
    return V_cart

# Define path: North pole -> equator -> 90° around equator -> back to pole
def path1(t):  # Down to equator (t: 0 to 1)
    theta = np.pi/2 * t
    phi = 0.0
    return theta, phi

def path1_deriv(t):
    return np.pi/2, 0.0

def path2(t):  # Along equator (t: 0 to 1)
    theta = np.pi/2
    phi = np.pi/2 * t
    return theta, phi

def path2_deriv(t):
    return 0.0, np.pi/2

def path3(t):  # Back to pole (t: 0 to 1)
    theta = np.pi/2 * (1 - t)
    phi = np.pi/2
    return theta, phi

def path3_deriv(t):
    return -np.pi/2, 0.0

# Initial vector at North pole pointing in theta direction
V0 = [1.0, 0.0]  # (V^theta, V^phi)

# Transport along each segment
t = np.linspace(0, 1, 100)

# Segment 1
sol1 = odeint(parallel_transport_eq, V0, t, args=(path1, path1_deriv))
V_end1 = sol1[-1]

# Segment 2
sol2 = odeint(parallel_transport_eq, V_end1, t, args=(path2, path2_deriv))
V_end2 = sol2[-1]

# Segment 3
sol3 = odeint(parallel_transport_eq, V_end2, t, args=(path3, path3_deriv))
V_final = sol3[-1]

print("╔════════════════════════════════════════════════════════╗")
print("║      Parallel Transport on 2-Sphere: Holonomy         ║")
print("╚════════════════════════════════════════════════════════╝")
print()
print(f"Initial vector at North Pole:")
print(f"  V^theta = {V0[0]:.4f}, V^phi = {V0[1]:.4f}")
print()
print(f"After segment 1 (North Pole -> Equator along 0 deg meridian):")
print(f"  V^theta = {V_end1[0]:.4f}, V^phi = {V_end1[1]:.4f}")
print()
print(f"After segment 2 (Along equator 0 deg -> 90 deg):")
print(f"  V^theta = {V_end2[0]:.4f}, V^phi = {V_end2[1]:.4f}")
print()
print(f"After segment 3 (Equator -> North Pole along 90 deg meridian):")
print(f"  V^theta = {V_final[0]:.4f}, V^phi = {V_final[1]:.4f}")
print()
print("Result: The vector has rotated by 90°!")
print("The rotation angle equals the solid angle enclosed: (\\Omega = \\pi/2) steradians")
print()

# Visualization
fig = plt.figure(figsize=(12, 10))
ax = fig.add_subplot(111, projection='3d')

# Draw sphere
u = np.linspace(0, 2*np.pi, 50)
v = np.linspace(0, np.pi, 50)
x = np.outer(np.cos(u), np.sin(v))
y = np.outer(np.sin(u), np.sin(v))
z = np.outer(np.ones(np.size(u)), np.cos(v))
ax.plot_surface(x, y, z, alpha=0.2, color='cyan', edgecolor='none')

# Draw path
path_theta = []
path_phi = []
for ti in t:
    th, ph = path1(ti)
    path_theta.append(th)
    path_phi.append(ph)
for ti in t:
    th, ph = path2(ti)
    path_theta.append(th)
    path_phi.append(ph)
for ti in t:
    th, ph = path3(ti)
    path_theta.append(th)
    path_phi.append(ph)

path_x, path_y, path_z = sphere_to_cartesian(np.array(path_theta), np.array(path_phi))
ax.plot(path_x, path_y, path_z, 'r-', linewidth=3, label='Transport path')

# Draw initial and final vectors at North pole
ax.quiver(0, 0, 1, 1, 0, 0, color='green', linewidth=3, arrow_length_ratio=0.3, label='Initial vector')
ax.quiver(0, 0, 1, 0, 1, 0, color='orange', linewidth=3, arrow_length_ratio=0.3, label='Final vector (rotated 90°)')

# Mark the three vertices of the path
ax.scatter([0], [0], [1], color='red', s=100, marker='o', label='North Pole')
theta_eq = np.pi/2
ax.scatter(*sphere_to_cartesian(theta_eq, 0), color='blue', s=100, marker='o')
ax.scatter(*sphere_to_cartesian(theta_eq, np.pi/2), color='blue', s=100, marker='o')

ax.set_xlabel('X', fontsize=12)
ax.set_ylabel('Y', fontsize=12)
ax.set_zlabel('Z', fontsize=12)
ax.legend(fontsize=10)
ax.set_title('Parallel Transport Around Triangle on S²: Demonstrating Holonomy', fontsize=14, fontweight='bold')
ax.set_box_aspect([1,1,1])

# Convert plot to base64
buf = io.BytesIO()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a1a')
buf.close()
plt.close()

# Image saved as output.png (rendered by ServerCodeRunner)

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Parallel Transport in Schwarzschild

Python

parallel_transport_plot.py167 lines

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

fortran_source = r"""
program parallel_transport_schwarzschild
    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) :: r, theta, phi
    real(dp) :: V(4), dV(4)
    real(dp) :: omega, dphi
    real(dp) :: dt_dphi, dr_dphi, dtheta_dphi
    real(dp) :: f, Gamma_t_tr, Gamma_r_tt, Gamma_r_rr
    real(dp) :: Gamma_r_phiphi, Gamma_phi_rphi
    real(dp) :: V_mag
    integer :: i, n_steps, n_out

r = 6.0_dp * M
    theta = pi / 2.0_dp
    omega = sqrt(M / r**3)

V(1) = 0.0_dp
    V(2) = 1.0_dp
    V(3) = 0.0_dp
    V(4) = 0.0_dp

n_steps = 10000
    dphi = 2.0_dp * pi / real(n_steps, dp)
    dt_dphi = 1.0_dp / omega
    dr_dphi = 0.0_dp
    dtheta_dphi = 0.0_dp
    phi = 0.0_dp

f = 1.0_dp - 2.0_dp*M/r
    Gamma_t_tr = M / (r * (r - 2.0_dp*M))
    Gamma_r_tt = M * (r - 2.0_dp*M) / r**3
    Gamma_r_rr = -M / (r * (r - 2.0_dp*M))
    Gamma_r_phiphi = -(r - 2.0_dp*M)
    Gamma_phi_rphi = 1.0_dp / r

print '(A)', 'DATA_START'
    n_out = 200
    do i = 0, n_steps
        if (mod(i, n_steps/n_out) == 0) then
            V_mag = sqrt(abs(-f*V(1)**2 + V(2)**2/f + r**2*V(4)**2))
            write(*,'(F12.8,A,F12.8,A,F12.8,A,F12.8,A,F12.8)') &
                phi/(2.0_dp*pi), ',', V(1), ',', V(2), ',', V(4), ',', V_mag
        end if
        if (i == n_steps) exit

dV(1) = -Gamma_t_tr * V(2) * dt_dphi
        dV(2) = -Gamma_r_tt * V(1) * dt_dphi - Gamma_r_phiphi * V(4) * 1.0_dp
        dV(3) = 0.0_dp
        dV(4) = -Gamma_phi_rphi * V(2) * 1.0_dp

V = V + dV * dphi
        phi = phi + dphi
    end do
    print '(A)', 'DATA_END'

print '(A,4F12.6)', 'Final vector: ', V
    print '(A,F12.6)', 'Precession angle ~ ', atan2(V(4)*r, V(2))
end program parallel_transport_schwarzschild
"""

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

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
    print(output.split('DATA_END')[-1].strip())

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

phi_frac, vt, vr, vphi, vmag = [], [], [], [], []
    for line in lines:
        vals = [float(x) for x in line.split(',')]
        phi_frac.append(vals[0])
        vt.append(vals[1])
        vr.append(vals[2])
        vphi.append(vals[3])
        vmag.append(vals[4])

phi_frac = np.array(phi_frac)
    vt = np.array(vt)
    vr = np.array(vr)
    vphi = np.array(vphi)
    vmag = np.array(vmag)

fig, axes = plt.subplots(1, 3, figsize=(16, 5))
    fig.patch.set_facecolor('#0f172a')
    fig.suptitle('Parallel Transport at ISCO (r = 6M) in Schwarzschild Spacetime',
                 color='white', fontsize=14, fontweight='bold')

colors = ['#22d3ee', '#f472b6', '#a78bfa']
    labels_data = [
        (vr, '$V^r$', colors[0]),
        (vphi, '$V^\\phi$', colors[1]),
        (vt, '$V^t$', colors[2]),
    ]

ax = axes[0]
    ax.set_facecolor('#1e293b')
    for data, label, c in labels_data:
        ax.plot(phi_frac, data, color=c, linewidth=1.5, label=label)
    ax.set_xlabel('$\\phi / 2\\pi$ (orbits)', color='#cbd5e1')
    ax.set_ylabel('Component value', color='#cbd5e1')
    ax.set_title('Vector Components During Transport', color='white')
    ax.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1')
    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[1]
    ax2.set_facecolor('#1e293b')
    ax2.plot(phi_frac, vmag, color='#4ade80', linewidth=2)
    ax2.set_xlabel('$\\phi / 2\\pi$ (orbits)', color='#cbd5e1')
    ax2.set_ylabel('$|V|$', color='#cbd5e1')
    ax2.set_title('Vector Magnitude (Conservation Check)', 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[2]
    ax3.set_facecolor('#1e293b')
    theta_arr = np.arctan2(vphi * 6.0, vr)
    ax3.plot(phi_frac, np.degrees(theta_arr), color='#fbbf24', linewidth=2)
    ax3.set_xlabel('$\\phi / 2\\pi$ (orbits)', color='#cbd5e1')
    ax3.set_ylabel('Direction angle (degrees)', color='#cbd5e1')
    ax3.set_title('Thomas Precession: Vector Direction', color='white')
    ax3.tick_params(colors='#cbd5e1')
    for spine in ax3.spines.values():
        spine.set_color('#334155')
    ax3.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

← Connection and Covariant Derivative Next: Geodesics →