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 V: Advanced Topics

Chapter 28: Gravitational Lensing

Gravitational lensing — light bending by massive objects — was the first observational confirmation of GR (1919) and is now a major tool for cosmology, detecting dark matter, and finding exoplanets.

Light Deflection

$ \alpha = \frac{4GM}{c^2 b} $

α = deflection angle, b = impact parameter

For the Sun: α = 1.75 arcsec (grazing rays). GR predicts twice the Newtonian value!

Types of Lensing

Strong Lensing

Multiple images, arcs, Einstein rings. Galaxy clusters as lenses.

Weak Lensing

Statistical distortion of background galaxies. Maps dark matter!

Microlensing

Brightness changes as stars pass in front. Detects exoplanets!

Python: Gravitational Lensing Simulation

This comprehensive simulation calculates light deflection angles, Einstein radii for various lenses, and microlensing magnification curves, visualizing all key aspects of gravitational lensing.

Complete Gravitational Lensing Calculator

Python

Computes deflection, Einstein radii, and magnification with visualizations

script.py236 lines

#!/usr/bin/env python3
"""
Gravitational Lensing - Einstein Ring and Light Deflection Calculator
Visualizes strong and weak lensing effects
"""
import numpy as np
import matplotlib.pyplot as plt
import base64
from io import BytesIO

# Physical constants
G = 6.67430e-11       # m³/(kg·s²)
c = 2.99792458e8      # m/s
M_sun = 1.98892e30    # kg
pc = 3.08567758e16    # m (parsec)

print("╔══════════════════════════════════════════════════════════════════╗")
print("║            GRAVITATIONAL LENSING CALCULATOR                     ║")
print("╠══════════════════════════════════════════════════════════════════╣")
print("║  Computing light deflection, Einstein rings, and magnification  ║")
print("╚══════════════════════════════════════════════════════════════════╝")

print("\n" + "="*70)
print("LIGHT DEFLECTION FORMULA")
print("="*70)
print("\nEinstein's deflection angle for light passing a mass M:")
print("$ \\alpha = \\frac{4GM}{c^2 b} $")
print("\nwhere b is the impact parameter (closest approach distance)")
print("\nThis is TWICE the Newtonian prediction - confirmed in 1919!")

def deflection_angle_arcsec(M, b):
    """Compute deflection angle in arcseconds"""
    alpha_rad = 4 * G * M / (c**2 * b)
    return alpha_rad * 206265  # Convert to arcsec

def einstein_radius(M, D_L, D_S):
    """Compute Einstein radius in arcseconds"""
    D_LS = D_S - D_L
    if D_LS <= 0:
        return 0
    theta_E_rad = np.sqrt(4 * G * M / c**2 * D_LS / (D_L * D_S))
    return theta_E_rad * 206265  # Convert to arcsec

def magnification(u):
    """Compute magnification for point source"""
    # u = angular separation / Einstein radius
    return (u**2 + 2) / (u * np.sqrt(u**2 + 4))

print("\n" + "="*70)
print("SOLAR DEFLECTION (1919 Eclipse Test)")
print("="*70)

# Solar limb deflection
R_sun = 6.96e8  # m
M_solar = M_sun
alpha_sun = deflection_angle_arcsec(M_solar, R_sun)

print(f"\nSun's mass: M = 1 M☉")
print(f"Impact parameter (grazing): b = R☉ = {R_sun/1e9:.3f} × 10⁹ m")
print(f"\nDeflection angle: $ \\alpha = {alpha_sun:.3f}'' $")
print("\nEddington's 1919 measurement: 1.75 ± 0.06 arcsec")
print("Newtonian prediction (wrong): 0.87 arcsec")
print("\n✓ GR prediction confirmed!")

print("\n" + "="*70)
print("EINSTEIN RING")
print("="*70)
print("\nWhen source, lens, and observer are perfectly aligned:")
print("$ \\theta_E = \\sqrt{\\frac{4GM}{c^2} \\frac{D_{LS}}{D_L D_S}} $")

# Galaxy cluster lens example
M_cluster = 1e14 * M_sun  # Cluster mass
D_L = 500e6 * pc          # Lens at 500 Mpc
D_S = 2e9 * pc            # Source at 2 Gpc

theta_E = einstein_radius(M_cluster, D_L, D_S)

print(f"\n• Lens: Galaxy cluster (M = 10¹⁴ M☉)")
print(f"• Lens distance: D_L = 500 Mpc")
print(f"• Source distance: D_S = 2 Gpc")
print(f"\nEinstein radius: $ \\theta_E = {theta_E:.1f}'' $")

# Different lens masses
print("\n" + "="*70)
print("EINSTEIN RADIUS FOR DIFFERENT LENSES")
print("="*70)
print("\n(D_L = 10 kpc, D_S = 20 kpc for stellar lenses)")
print("(D_L = 500 Mpc, D_S = 2 Gpc for galaxy/cluster lenses)")
print("\n  Lens Type          Mass (M☉)      θ_E")
print("  " + "─"*50)

lenses = [
    ("Sun (microlens)", 1, 10e3*pc, 20e3*pc),
    ("White dwarf", 0.6, 10e3*pc, 20e3*pc),
    ("Neutron star", 1.4, 10e3*pc, 20e3*pc),
    ("Stellar BH", 10, 10e3*pc, 20e3*pc),
    ("Galaxy", 1e11, 500e6*pc, 2e9*pc),
    ("Galaxy cluster", 1e14, 500e6*pc, 2e9*pc),
]

for name, mass_msun, DL, DS in lenses:
    M = mass_msun * M_sun
    theta = einstein_radius(M, DL, DS)
    if theta < 1:
        print(f"  {name:18s} {mass_msun:12.1e}    {theta*1000:.2f} mas")
    else:
        print(f"  {name:18s} {mass_msun:12.1e}    {theta:.2f} arcsec")

print("\n" + "="*70)
print("MICROLENSING MAGNIFICATION")
print("="*70)
print("\nMagnification for point source:")
print("$ \\mu = \\frac{u^2 + 2}{u\\sqrt{u^2 + 4}} $")
print("\nwhere u = β/θ_E (source position / Einstein radius)")

# Create visualization
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Plot 1: Deflection angle vs impact parameter
ax1 = axes[0, 0]
b_vals = np.linspace(1, 10, 100) * R_sun
alpha_vals = [deflection_angle_arcsec(M_sun, b) for b in b_vals]
ax1.plot(b_vals/R_sun, alpha_vals, 'c-', linewidth=2)
ax1.axhline(y=1.75, color='yellow', linestyle='--', alpha=0.7, label='GR (1.75")')
ax1.axhline(y=0.875, color='red', linestyle='--', alpha=0.7, label='Newton (0.87")')
ax1.set_xlabel('Impact parameter (R☉)', fontsize=11)
ax1.set_ylabel('Deflection angle (arcsec)', fontsize=11)
ax1.set_title('Solar Light Deflection', fontsize=12, fontweight='bold')
ax1.legend()
ax1.grid(True, alpha=0.3)
ax1.set_xlim(1, 10)

# Plot 2: Einstein radius vs lens mass
ax2 = axes[0, 1]
log_masses = np.linspace(10, 15, 100)  # 10^10 to 10^15 M_sun
masses = 10**log_masses
D_L_ext = 500e6 * pc
D_S_ext = 2e9 * pc
theta_vals = [einstein_radius(m * M_sun, D_L_ext, D_S_ext) for m in masses]
ax2.loglog(masses, theta_vals, 'm-', linewidth=2)
ax2.axhline(y=1, color='cyan', linestyle='--', alpha=0.7, label='1 arcsec')
ax2.axhline(y=10, color='yellow', linestyle='--', alpha=0.7, label='10 arcsec')
ax2.set_xlabel('Lens mass (M☉)', fontsize=11)
ax2.set_ylabel('Einstein radius (arcsec)', fontsize=11)
ax2.set_title('Einstein Radius vs Mass\n(D_L=500 Mpc, D_S=2 Gpc)', fontsize=12, fontweight='bold')
ax2.legend()
ax2.grid(True, alpha=0.3)

# Plot 3: Microlensing light curve
ax3 = axes[1, 0]
t = np.linspace(-2, 2, 200)  # Time in units of t_E
t_0 = 0  # Peak time
u_min = 0.3  # Minimum impact parameter
u = np.sqrt(u_min**2 + (t - t_0)**2)
mu = magnification(u)
ax3.plot(t, mu, 'g-', linewidth=2, label=f'u_min = {u_min}')
# Second curve with different u_min
u_min2 = 0.1
u2 = np.sqrt(u_min2**2 + (t - t_0)**2)
mu2 = magnification(u2)
ax3.plot(t, mu2, 'y-', linewidth=2, label=f'u_min = {u_min2}')
ax3.set_xlabel('Time (t/t_E)', fontsize=11)
ax3.set_ylabel('Magnification μ', fontsize=11)
ax3.set_title('Microlensing Light Curve', fontsize=12, fontweight='bold')
ax3.legend()
ax3.grid(True, alpha=0.3)
ax3.set_ylim(0, 15)

# Plot 4: Einstein ring geometry
ax4 = axes[1, 1]
theta = np.linspace(0, 2*np.pi, 100)
r_ring = 1.0  # Einstein radius (normalized)

# Draw Einstein ring
ax4.plot(r_ring * np.cos(theta), r_ring * np.sin(theta), 'c-', linewidth=3, label='Einstein ring')

# Draw lens (at center)
ax4.plot(0, 0, 'yo', markersize=15, label='Lens (center)')

# Draw tangential arcs for misaligned source
for offset in [0.3, -0.3]:
    arc_theta = np.linspace(-np.pi/3, np.pi/3, 50)
    r_arc = 1.1
    ax4.plot(r_arc * np.cos(arc_theta) - offset, r_arc * np.sin(arc_theta), 'g-', linewidth=2)

ax4.set_xlim(-2, 2)
ax4.set_ylim(-2, 2)
ax4.set_aspect('equal')
ax4.set_xlabel('θ_x (θ_E)', fontsize=11)
ax4.set_ylabel('θ_y (θ_E)', fontsize=11)
ax4.set_title('Einstein Ring Geometry', fontsize=12, fontweight='bold')
ax4.legend(loc='upper right')
ax4.grid(True, alpha=0.3)

# Add circle showing source position for arcs
circle = plt.Circle((0, 0), 0.2, color='orange', fill=False, linestyle='--', label='Source region')
ax4.add_patch(circle)

plt.suptitle('Gravitational Lensing Physics', fontsize=14, fontweight='bold', color='white')
fig.patch.set_facecolor('#1a1a2e')
for ax in axes.flatten():
    ax.set_facecolor('#16213e')
    ax.tick_params(colors='white')
    ax.xaxis.label.set_color('white')
    ax.yaxis.label.set_color('white')
    ax.title.set_color('white')
    for spine in ax.spines.values():
        spine.set_color('gray')

plt.tight_layout()

# Save to base64
buf = BytesIO()
plt.savefig(buf, format='png', dpi=150, facecolor='#1a1a2e', edgecolor='none', bbox_inches='tight')
buf.seek(0)
img_base64 = base64.b64encode(buf.read()).decode('utf-8')
plt.close()

print("\n" + "="*70)
print("APPLICATIONS OF GRAVITATIONAL LENSING")
print("="*70)
print("\n1. Dark Matter Mapping")
print("   - Weak lensing reveals mass distribution in clusters")
print("   - Shows dark matter halos extend beyond visible galaxies")
print("\n2. Exoplanet Detection (Microlensing)")
print("   - 196+ planets discovered via microlensing")
print("   - Sensitive to planets at 1-10 AU from host star")
print("\n3. High-Redshift Universe")
print("   - Clusters magnify distant galaxies by 10-100×")
print("   - Enabled study of earliest galaxies")
print("\n4. Cosmological Parameters")
print("   - Time delays in multiple images → H₀")
print("   - Cosmic shear maps → dark energy equation of state")

print(f"\n<img src='data:image/png;base64,{img_base64}' alt='Gravitational Lensing Physics' style='max-width:100%;'/>")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Lensing Calculations

This Fortran program performs precise lensing calculations including the solar deflection (confirming GR over Newton), Einstein radii for different lens masses, and magnification formulas.

Gravitational Lensing Visualization

Python

Deflection angle, Einstein radius, and magnification plots

lensing_plot.py157 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 lensing_plot
    implicit none
    real(8), parameter :: G = 6.67430d-11
    real(8), parameter :: c = 2.99792458d8
    real(8), parameter :: M_sun = 1.98892d30
    real(8), parameter :: pc = 3.08567758d16
    real(8), parameter :: pi = 3.14159265358979d0
    real(8), parameter :: arcsec = 206265.0d0

real(8) :: M, b, alpha, u, mu
    real(8) :: R_sun
    integer :: i, n_pts

R_sun = 6.96d8

! Deflection vs impact parameter
    n_pts = 200
    print *, 'DATA_START deflection'
    do i = 1, n_pts
        b = R_sun * (1.0d0 + dble(i-1) * 99.0d0 / dble(n_pts-1))
        alpha = (4.0d0 * G * M_sun / (c**2 * b)) * arcsec
        write(*,'(F14.6,A,F14.6)') b/R_sun, ',', alpha
    end do
    print *, 'DATA_END'

! Magnification curve
    print *, 'DATA_START magnification'
    do i = 1, 200
        u = 0.01d0 + dble(i-1) * 4.99d0 / 199.0d0
        mu = (u**2 + 2.0d0) / (u * sqrt(u**2 + 4.0d0))
        write(*,'(F14.8,A,F14.8)') u, ',', mu
    end do
    print *, 'DATA_END'

! Image positions
    print *, 'DATA_START images'
    do i = 1, 100
        u = 0.01d0 + dble(i-1) * 2.99d0 / 99.0d0
        ! theta_+ and theta_-
        write(*,'(F14.8,A,F14.8,A,F14.8)') u, ',', &
            0.5d0*(u + sqrt(u**2 + 4.0d0)), ',', &
            0.5d0*(u - sqrt(u**2 + 4.0d0))
    end do
    print *, 'DATA_END'
end program lensing_plot
"""

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

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

sections = {}
    current = None
    for line in output.split('\n'):
        if 'DATA_START' in line:
            current = line.split('DATA_START')[1].strip()
            sections[current] = []
            continue
        if 'DATA_END' in line:
            current = None
            continue
        if current and line.strip():
            sections[current].append(line.strip())

fig, axes = plt.subplots(1, 3, figsize=(18, 6))
    fig.patch.set_facecolor('#0f172a')
    fig.suptitle('Gravitational Lensing in General Relativity', color='white', fontsize=14, fontweight='bold')

if 'deflection' in sections:
        b_arr, alpha_arr = [], []
        for line in sections['deflection']:
            vals = [float(x) for x in line.split(',')]
            b_arr.append(vals[0])
            alpha_arr.append(vals[1])
        ax = axes[0]
        ax.set_facecolor('#1e293b')
        ax.loglog(b_arr, alpha_arr, color='#f472b6', linewidth=2, label='GR: $4GM/(c^2 b)$')
        ax.loglog(b_arr, [a/2 for a in alpha_arr], color='#94a3b8', linewidth=2, linestyle='--', label='Newtonian (half)')
        ax.axhline(y=1.75, color='#fbbf24', linestyle=':', alpha=0.7, label='Solar limb (1.75")')
        ax.set_xlabel('Impact parameter ($b/R_\\odot$)', color='#cbd5e1')
        ax.set_ylabel('Deflection (arcsec)', color='#cbd5e1')
        ax.set_title('Light Deflection by the Sun', color='white')
        ax.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1', fontsize=9)
        ax.tick_params(colors='#cbd5e1')
        for spine in ax.spines.values():
            spine.set_color('#334155')
        ax.grid(True, color='#334155', alpha=0.4)

if 'magnification' in sections:
        u_arr, mu_arr = [], []
        for line in sections['magnification']:
            vals = [float(x) for x in line.split(',')]
            u_arr.append(vals[0])
            mu_arr.append(vals[1])
        ax2 = axes[1]
        ax2.set_facecolor('#1e293b')
        ax2.semilogy(u_arr, mu_arr, color='#4ade80', linewidth=2)
        ax2.axvline(x=1.0, color='#fbbf24', linestyle='--', alpha=0.7, label='$u = \\theta_E$')
        ax2.set_xlabel('$u = \\beta / \\theta_E$', color='#cbd5e1')
        ax2.set_ylabel('Magnification $\\mu$', color='#cbd5e1')
        ax2.set_title('Point Source Magnification', color='white')
        ax2.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1')
        ax2.tick_params(colors='#cbd5e1')
        for spine in ax2.spines.values():
            spine.set_color('#334155')
        ax2.grid(True, color='#334155', alpha=0.4)

if 'images' in sections:
        beta_arr, tp_arr, tm_arr = [], [], []
        for line in sections['images']:
            vals = [float(x) for x in line.split(',')]
            beta_arr.append(vals[0])
            tp_arr.append(vals[1])
            tm_arr.append(vals[2])
        ax3 = axes[2]
        ax3.set_facecolor('#1e293b')
        ax3.plot(beta_arr, tp_arr, color='#22d3ee', linewidth=2, label='$\\theta_+$ (primary)')
        ax3.plot(beta_arr, tm_arr, color='#f472b6', linewidth=2, label='$\\theta_-$ (secondary)')
        ax3.plot(beta_arr, beta_arr, color='#94a3b8', linewidth=1, linestyle='--', label='$\\theta = \\beta$ (no lens)')
        ax3.axhline(y=0, color='#334155', linewidth=0.5)
        ax3.set_xlabel('Source position $\\beta / \\theta_E$', color='#cbd5e1')
        ax3.set_ylabel('Image position $\\theta / \\theta_E$', color='#cbd5e1')
        ax3.set_title('Lens Equation: Two Images', color='white')
        ax3.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1', fontsize=9)
        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(buf, format='png', dpi=150, bbox_inches='tight', facecolor=fig.get_facecolor())
    buf.seek(0)
    img_b64 = base64.b64encode(buf.read()).decode()
    buf.close()
    plt.close()
    print("Solar limb deflection: 1.75 arcsec (Eddington 1919 confirmed GR!)")
    print(f'<img src="data:image/png;base64,{img_b64}" />')

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Numerical Relativity Next: Quantum Gravity Introduction →