Are the courses on CoursesHub.World free?

Yes, all courses on CoursesHub.World are completely free and open access. We believe in democratizing education and making university-level science courses available to everyone worldwide.

What subjects are covered on CoursesHub.World?

CoursesHub.World offers courses in physics (Quantum Mechanics, General Relativity, QFT, Plasma Physics, Cosmology), biology (Molecular Biology, Cell Physiology, Pharmacology), and earth sciences (Oceanography, Atmospheric Science, Climatology).

What level are the courses?

Our courses are designed at the graduate and advanced undergraduate level. They include rigorous mathematical derivations and are suitable for physics students, researchers, and serious self-learners.

Where do the video lectures come from?

Our 400+ video lectures come from world-renowned sources including MIT OpenCourseWare, Stanford, lectures by Nobel laureates, and other leading universities and educators.

← Back to Part I: Differential Geometry

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.py187 lines

#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════╗
║       Parallel Transport on the 2-Sphere                     ║
║       Demonstrating Holonomy via Path-Dependent Transport    ║
╚══════════════════════════════════════════════════════════════╝

Transport a vector around a closed triangular path on S² to demonstrate
that parallel transport is path-dependent on curved manifolds.

Christoffel symbols for unit 2-sphere (θ, φ coordinates):
  \(\Gamma^\\theta_{\\phi\\phi} = -\\sin\\theta\\cos\\theta\)
  \(\Gamma^\\phi_{\\theta\\phi} = \\Gamma^\\phi_{\\phi\\theta} = \\cot\\theta\)

Parallel transport equation:
  \(\\frac{DV^\\mu}{d\\lambda} = \\frac{dV^\\mu}{d\\lambda} + \\Gamma^\\mu_{\\nu\\rho} V^\\nu \\frac{dx^\\rho}{d\\lambda} = 0\)
"""
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from scipy.integrate import odeint
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° meridian):")
print(f"  \(V^\\theta = {V_end1[0]:.4f}\), \(V^\\phi = {V_end1[1]:.4f}\)")
print()
print(f"After segment 2 (Along equator 0° → 90°):")
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° 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(buf, format='png', dpi=150, bbox_inches='tight')
buf.seek(0)
img_base64 = base64.b64encode(buf.read()).decode('utf-8')
buf.close()
plt.close()

print(f'<img src="data:image/png;base64,{img_base64}" alt="Parallel Transport on Sphere" />')

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Parallel Transport in Schwarzschild

Fortran

program.f90134 lines

! parallel_transport_schwarzschild.f90
!
! ╔══════════════════════════════════════════════════════════════╗
! ║   Parallel Transport in Schwarzschild Spacetime              ║
! ║   Vector transport along circular orbit at ISCO              ║
! ╚══════════════════════════════════════════════════════════════╝
!
! Schwarzschild metric in Schwarzschild coordinates:
!   \(ds^2 = -f dt^2 + f^{-1} dr^2 + r^2 d\theta^2 + r^2\sin^2\theta d\phi^2\)
!   where \(f = 1 - 2M/r\)
!
! Non-zero Christoffel symbols (selection):
!   \(\Gamma^t_{tr} = M/(r(r-2M))\)
!   \(\Gamma^r_{tt} = M(r-2M)/r^3\)
!   \(\Gamma^r_{\phi\phi} = -(r-2M)\sin^2\theta\)
!   \(\Gamma^\phi_{r\phi} = 1/r\)
!   \(\Gamma^\phi_{\theta\phi} = \cot\theta\)
!
! Compile: gfortran -o parallel_schwarzschild parallel_transport_schwarzschild.f90
! Run: ./parallel_schwarzschild

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, t_coord
    real(dp) :: V(4), dV(4)
    real(dp) :: omega, dphi, dt_step
    real(dp) :: dt_dphi, dr_dphi, dtheta_dphi
    integer :: i, n_steps

print '(A)', '╔════════════════════════════════════════════════════════╗'
    print '(A)', '║  Parallel Transport in Schwarzschild Spacetime        ║'
    print '(A)', '╚════════════════════════════════════════════════════════╝'
    print '(A)', ''

! Circular orbit at r = 6M (ISCO), equatorial plane
    r = 6.0_dp * M
    theta = pi / 2.0_dp

! Angular velocity for circular orbit: \(\omega = \sqrt{M/r^3}\)
    omega = sqrt(M / r**3)

print '(A)', 'Setup:'
    print '(A,F8.4,A)', '  Circular orbit at r = ', r, 'M (innermost stable)'
    print '(A,F12.8)', '  Angular velocity: \(\omega\) = ', omega
    print '(A)', '  Equatorial plane: \(\theta = \pi/2\)'
    print '(A)', ''

! Initial vector: radial direction in local frame
    V(1) = 0.0_dp  ! t component
    V(2) = 1.0_dp  ! r component
    V(3) = 0.0_dp  ! theta component
    V(4) = 0.0_dp  ! phi component

print '(A)', 'Initial vector (pointing radially outward):'
    print '(A,4F10.6)', '  \(V^\mu = (V^t, V^r, V^\theta, V^\phi)\) = ', V
    print '(A)', ''

! Transport one full orbit
    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
    t_coord = 0.0_dp

do i = 1, n_steps
        call compute_dV(r, theta, V, dt_dphi, dr_dphi, dtheta_dphi, dV)
        V = V + dV * dphi
        phi = phi + dphi
        t_coord = t_coord + dt_dphi * dphi
    end do

print '(A)', 'After one complete orbit (\(\Delta\phi = 2\pi\)):'
    print '(A,4F10.6)', '  \(V^\mu\) = ', V
    print '(A)', ''
    print '(A)', 'Observation:'
    print '(A)', '  The vector has undergone Thomas precession!'
    print '(A,F10.6)', '  \(V^r\) changed from 1.000000 to ', V(2)
    print '(A)', '  This is due to the curvature of spacetime near the black hole.'
    print '(A)', ''

contains

subroutine compute_dV(r, theta, V, dt_dphi, dr_dphi, dtheta_dphi, dV)
        real(dp), intent(in) :: r, theta, V(4)
        real(dp), intent(in) :: dt_dphi, dr_dphi, dtheta_dphi
        real(dp), intent(out) :: dV(4)
        real(dp) :: f, Gamma_t_tr, Gamma_r_tt, Gamma_r_rr, Gamma_r_thth
        real(dp) :: Gamma_r_phiphi, Gamma_th_rth, Gamma_th_phiphi
        real(dp) :: Gamma_phi_rphi, Gamma_phi_thphi

f = 1.0_dp - 2.0_dp*M/r

! Non-zero Christoffel symbols for Schwarzschild metric
        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_thth = -(r - 2.0_dp*M)
        Gamma_r_phiphi = -(r - 2.0_dp*M) * sin(theta)**2
        Gamma_th_rth = 1.0_dp / r
        Gamma_th_phiphi = -sin(theta) * cos(theta)
        Gamma_phi_rphi = 1.0_dp / r
        Gamma_phi_thphi = cos(theta) / sin(theta)

! Parallel transport equation: \(dV^\mu/d\phi = -\Gamma^\mu_{\nu\rho} V^\nu dx^\rho/d\phi\)
        ! Note: dx^phi/dphi = 1

dV(1) = -Gamma_t_tr * V(1) * dr_dphi &
                -Gamma_t_tr * V(2) * dt_dphi

dV(2) = -Gamma_r_tt * V(1) * dt_dphi &
                -Gamma_r_rr * V(2) * dr_dphi &
                -Gamma_r_thth * V(3) * dtheta_dphi &
                -Gamma_r_phiphi * V(4) * 1.0_dp

dV(3) = -Gamma_th_rth * V(3) * dr_dphi &
                -Gamma_th_rth * V(2) * dtheta_dphi &
                -Gamma_th_phiphi * V(4) * 1.0_dp

dV(4) = -Gamma_phi_rphi * V(4) * dr_dphi &
                -Gamma_phi_rphi * V(2) * 1.0_dp &
                -Gamma_phi_thphi * V(4) * dtheta_dphi &
                -Gamma_phi_thphi * V(3) * 1.0_dp

end subroutine

end program parallel_transport_schwarzschild

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

← Connection and Covariant Derivative Next: Geodesics →