Planetary Motion and Kepler's Laws

Learning Objectives

By the end of this section, you will be able to:

1. State and explain Kepler's three laws of planetary motion geometrically and mathematically
2. Derive Kepler's laws from Newton's law of gravitation using vector calculus
3. Apply the vis-viva equation to calculate orbital velocities at any point in an orbit
4. Calculate orbital periods, semi-major axes, and eccentricities for planetary and satellite orbits
5. Connect angular momentum conservation to Kepler's Second Law
6. Understand how these principles apply to modern space mission design and exoplanet detection

The Big Picture: From Observation to Universal Law

"The laws of planetary motion are the most beautiful application of calculus to the physical world—showing how vector-valued functions describe paths through space, governed by the simplest of force laws."

Planetary motion represents one of the greatest triumphs of mathematical physics. Johannes Kepler, working with Tycho Brahe's painstaking astronomical observations, discovered three empirical laws describing how planets orbit the Sun. Half a century later, Isaac Newton showed that all three laws follow from a single principle: the inverse-square law of gravitation.

This section brings together everything we've learned about vector-valued functions. The position of a planet is a vector function $\vec{r}(t)$, its velocity is the derivative $\vec{v}(t) = \frac{d\vec{r}}{dt}$, and its acceleration comes from Newton's Second Law combined with gravitation: $\vec{a} = -\frac{GM}{r^2}\hat{r}$.

Historical Context

The story of planetary motion is a story of scientific revolution:

• Tycho Brahe (1546-1601) made the most accurate pre-telescopic astronomical observations in history, tracking Mars with unprecedented precision over decades
• Johannes Kepler (1571-1630) inherited Brahe's data and spent years trying to fit the observations to circular orbits. Finally abandoning circles, he discovered that Mars follows an ellipse with the Sun at one focus
• Isaac Newton (1642-1727) showed that Kepler's laws follow from the inverse-square law of gravitation—a stunning unification that made the heavens obey the same laws as falling apples
• Edmond Halley (1656-1742) used Newton's theory to predict the return of a comet, spectacularly confirmed 16 years after his death

Newton's derivation required the invention of calculus itself. The tools we've developed—derivatives, integrals, and vector calculus—are precisely what Newton created to solve this problem.

Kepler's Three Laws of Planetary Motion

First Law: The Law of Ellipses

An ellipse is defined by two parameters:

• Semi-major axis (a): Half the longest diameter of the ellipse. This determines the "size" of the orbit.
• Eccentricity (e): A measure of how elongated the ellipse is. For a circle, $e = 0$. For increasingly elongated ellipses, $0 < e < 1$.

The polar equation of the orbit, with the Sun at the origin (focus), is:

Second Law: The Law of Equal Areas

This law has profound implications for the planet's speed:

• Near perihelion, the planet is closer to the Sun, so it must move faster to sweep the same area
• Near aphelion, the planet is farther from the Sun, so it moves slower
• The areal velocity $\frac{dA}{dt}$ is constant throughout the orbit

Mathematically, the area swept in time $dt$ is:

So the areal velocity is $\frac{dA}{dt} = \frac{1}{2}r^2\dot{\theta}$. This equals $\frac{L}{2m}$ where $L = mr^2\dot{\theta}$ is the angular momentum.

Interactive: Equal Areas Demonstration

This visualization divides an orbit into sectors swept in equal time intervals. Notice how all sectors have equal area, even though their shapes differ dramatically between perihelion and aphelion:

Third Law: The Harmonic Law

This elegant relationship connects orbital size to orbital period:

• In our solar system, using years and AU: $T^2 = a^3$ (exactly!)
• Earth: $a = 1$ AU, $T = 1$ year ✓
• Mars: $a = 1.52$ AU, $T = 1.88$ years ($1.52^3 \approx 3.51$, $1.88^2 \approx 3.53$) ✓
• Jupiter: $a = 5.2$ AU, $T = 11.9$ years ($5.2^3 \approx 141$, $11.9^2 \approx 142$) ✓

The constant $\frac{4\pi^2}{GM}$ depends only on the central body's mass. This allows us to "weigh" the Sun by measuring planetary orbits, or weigh stars by observing their planets!

Interactive: Third Law Demonstration

Watch multiple planets orbit simultaneously and see how the third law predicts their periods:

Interactive Orbit Visualizer

Explore all three of Kepler's laws with this interactive visualization. Adjust the eccentricity to see how it affects the orbit shape, velocity variations, and area sweeping:

Newton's Derivation of Kepler's Laws

Newton showed that Kepler's empirical laws follow mathematically from two principles:

1. Newton's Second Law: $\vec{F} = m\vec{a}$
2. Law of Universal Gravitation: $\vec{F} = -\frac{GMm}{r^2}\hat{r}$

The Inverse Square Law

The gravitational force between two masses is:

Key properties of this force:

• Central force: Always points toward (or away from) the central body
• Inverse square: Magnitude decreases as $1/r^2$
• Conservative: Work done depends only on initial and final positions

Vector-Valued Functions Approach

We describe the planet's position as a vector-valued function $\vec{r}(t)$. In polar coordinates centered at the Sun:

Since the gravitational force is purely radial, the tangential component of acceleration must be zero:

This proves angular momentum is conserved: $L = mr^2\dot{\theta} = \text{constant}$. This is Kepler's Second Law!

Step-by-Step Derivation

Follow Newton's derivation step by step with this interactive walkthrough:

The complete derivation shows that the radial equation of motion:

has solutions of the form $r = \frac{p}{1 + e\cos\theta}$ where $p = L^2/(GMm^2)$. This is a conic section:

Orbital Mechanics

Orbital Elements

Six parameters completely describe an orbit in 3D space:

1. Semi-major axis (a): Size of the orbit
2. Eccentricity (e): Shape of the orbit
3. Inclination (i): Tilt relative to reference plane
4. Longitude of ascending node (Ω): Where orbit crosses reference plane going "up"
5. Argument of perihelion (ω): Angle from ascending node to closest approach
6. True anomaly (θ) or time of perihelion (T₀): Position in orbit at a reference time

The Vis-Viva Equation

One of the most useful results in orbital mechanics relates velocity to position:

Derivation: From conservation of energy:

Applications:

• At perihelion ($r = a(1-e)$): $v_p = \sqrt{\frac{GM(1+e)}{a(1-e)}}$
• At aphelion ($r = a(1+e)$): $v_a = \sqrt{\frac{GM(1-e)}{a(1+e)}}$
• For a circular orbit ($r = a$): $v_{circ} = \sqrt{GM/a}$

Escape Velocity

What if we want to escape the gravitational field entirely? Setting $a \to \infty$ (parabolic trajectory) in vis-viva:

Notable values:

Applications

Space Mission Design

Kepler's laws and orbital mechanics are fundamental to spacecraft design:

• Hohmann Transfer Orbits: The most fuel-efficient way to move between circular orbits uses an elliptical transfer orbit tangent to both circles
• Launch Windows: Kepler's Third Law determines when planets align favorably for missions
• Gravity Assists: Using a planet's orbital motion to gain velocity (Voyager missions)

Satellite Orbits

Different satellite missions require different orbital characteristics:

Geostationary Orbit (GEO): Using Kepler's Third Law with T = 24 hours:

Exoplanet Detection

Kepler's laws help us find planets around other stars:

• Radial Velocity Method: As a planet orbits, it causes the star to "wobble." The period and amplitude reveal the planet's orbit and minimum mass using Kepler's laws
• Transit Method: When a planet crosses in front of its star, we measure the orbital period. Combined with the star's mass, Kepler's Third Law gives us the orbital distance
• Direct Imaging: For wide-separation planets, we can observe orbital motion and apply Kepler's laws directly

Machine Learning Connection

The mathematics of planetary motion appears in several machine learning contexts:

N-Body Simulations and Neural Networks

Modern ML approaches like Graph Neural Networks (GNNs) and Neural ODEs are used to:

• Learn gravitational dynamics from observation data
• Speed up N-body simulations by orders of magnitude
• Predict long-term orbital evolution
• Detect subtle perturbations indicating unseen planets

Conservation Laws in Neural Networks

Hamiltonian Neural Networks (HNNs) are designed to conserve energy, inspired by orbital mechanics. They parameterize the Hamiltonian (total energy) and use it to derive equations of motion:

This guarantees energy conservation, essential for accurate long-term predictions of orbits and other physical systems.

Orbital Mechanics Optimization

Trajectory optimization for space missions is increasingly done with ML:

• Reinforcement Learning: Training agents to find fuel-optimal trajectories
• Gaussian Processes: Uncertainty quantification in orbital predictions
• Variational Autoencoders: Generating diverse trajectory candidates

Python Implementation

Computing Orbital Positions

1import numpy as np
2import matplotlib.pyplot as plt
3
4def solve_kepler_equation(M, e, tol=1e-10):
5    """
6    Solve Kepler's equation: M = E - e*sin(E)
7
8    Uses Newton-Raphson iteration to find eccentric anomaly E
9    given mean anomaly M and eccentricity e.
10    """
11    E = M  # Initial guess
12    for _ in range(50):
13        f = E - e * np.sin(E) - M
14        f_prime = 1 - e * np.cos(E)
15        E_new = E - f / f_prime
16        if abs(E_new - E) < tol:
17            break
18        E = E_new
19    return E
20
21def orbital_position(t, a, e, T):
22    """
23    Calculate position in orbit at time t.
24
25    Args:
26        t: Time (same units as period T)
27        a: Semi-major axis
28        e: Eccentricity
29        T: Orbital period
30
31    Returns:
32        (x, y, r, theta): Cartesian coords, radius, true anomaly
33    """
34    # Mean anomaly (linearly increasing with time)
35    M = 2 * np.pi * t / T
36
37    # Solve for eccentric anomaly E
38    E = solve_kepler_equation(M, e)
39
40    # True anomaly from eccentric anomaly
41    theta = 2 * np.arctan2(
42        np.sqrt(1 + e) * np.sin(E / 2),
43        np.sqrt(1 - e) * np.cos(E / 2)
44    )
45
46    # Radius from orbit equation
47    r = a * (1 - e * np.cos(E))
48
49    # Cartesian coordinates
50    x = r * np.cos(theta)
51    y = r * np.sin(theta)
52
53    return x, y, r, theta
54
55# Example: Plot an orbit with e = 0.5
56a = 1.0  # Semi-major axis (AU)
57e = 0.5  # Eccentricity
58T = np.sqrt(a**3)  # Period (years) from Kepler III
59
60times = np.linspace(0, T, 1000)
61positions = [orbital_position(t, a, e, T) for t in times]
62x_vals = [p[0] for p in positions]
63y_vals = [p[1] for p in positions]
64
65print(f"Semi-major axis a = {a} AU")
66print(f"Eccentricity e = {e}")
67print(f"Period T = {T:.4f} years")
68print(f"Perihelion: r_p = {a*(1-e):.4f} AU")
69print(f"Aphelion: r_a = {a*(1+e):.4f} AU")

Velocity Calculations with Vis-Viva

1import numpy as np
2
3def orbital_velocity(r, a, mu=1.0):
4    """
5    Calculate orbital velocity using vis-viva equation.
6
7    v² = μ(2/r - 1/a)
8
9    Args:
10        r: Current distance from central body
11        a: Semi-major axis of orbit
12        mu: Gravitational parameter (G*M)
13
14    Returns:
15        v: Orbital speed at distance r
16    """
17    return np.sqrt(mu * (2/r - 1/a))
18
19def escape_velocity(r, mu=1.0):
20    """
21    Calculate escape velocity at distance r.
22
23    v_escape = sqrt(2μ/r)
24
25    This is the minimum speed needed to escape
26    the gravitational field entirely.
27    """
28    return np.sqrt(2 * mu / r)
29
30# Example: Earth orbiting the Sun
31# Using AU and years, μ = 4π² (from Kepler's third law)
32mu_sun = 4 * np.pi**2
33
34# Earth's orbital parameters
35a_earth = 1.0  # AU
36e_earth = 0.017  # Nearly circular
37
38r_perihelion = a_earth * (1 - e_earth)
39r_aphelion = a_earth * (1 + e_earth)
40
41v_perihelion = orbital_velocity(r_perihelion, a_earth, mu_sun)
42v_aphelion = orbital_velocity(r_aphelion, a_earth, mu_sun)
43v_escape_earth = escape_velocity(1.0, mu_sun)
44
45print("Earth's Orbital Motion:")
46print(f"  Perihelion velocity: {v_perihelion:.4f} AU/year")
47print(f"  Aphelion velocity: {v_aphelion:.4f} AU/year")
48print(f"  Escape velocity at 1 AU: {v_escape_earth:.4f} AU/year")
49print(f"  Velocity ratio: {v_perihelion/v_aphelion:.4f}")

Angular Momentum and Kepler's Second Law

1import numpy as np
2
3def angular_momentum(a, e, mu=4*np.pi**2):
4    """
5    Calculate specific angular momentum of an orbit.
6
7    L/m = sqrt(μ * a * (1 - e²))
8
9    This is constant throughout the orbit (Kepler's 2nd Law).
10    """
11    return np.sqrt(mu * a * (1 - e**2))
12
13def areal_velocity(L_specific):
14    """
15    Calculate areal velocity from angular momentum.
16
17    dA/dt = L/(2m) = L_specific/2
18
19    This is constant - proof of Kepler's Second Law!
20    """
21    return L_specific / 2
22
23def verify_second_law(a, e, T, num_sectors=6, mu=4*np.pi**2):
24    """
25    Verify Kepler's Second Law numerically.
26
27    We divide the orbit into equal time intervals and
28    compute the area swept in each interval.
29    """
30    from orbital_utils import orbital_position  # From previous code
31
32    areas = []
33    dt = T / num_sectors
34
35    for i in range(num_sectors):
36        t1 = i * dt
37        t2 = (i + 1) * dt
38
39        # Calculate area of sector by integration
40        n_points = 100
41        area = 0
42        for j in range(n_points):
43            t = t1 + j * (t2 - t1) / n_points
44            t_next = t1 + (j + 1) * (t2 - t1) / n_points
45
46            x1, y1, _, _ = orbital_position(t, a, e, T)
47            x2, y2, _, _ = orbital_position(t_next, a, e, T)
48
49            # Triangle area with Sun at origin (actually at focus)
50            area += 0.5 * abs(x1 * y2 - x2 * y1)
51
52        areas.append(area)
53
54    return areas
55
56# Example: Verify for a comet-like orbit (high eccentricity)
57a = 5.0  # Semi-major axis
58e = 0.8  # High eccentricity (like a comet)
59T = np.sqrt(a**3)
60
61L_specific = angular_momentum(a, e)
62dA_dt = areal_velocity(L_specific)
63
64print(f"Comet orbit: a = {a} AU, e = {e}")
65print(f"Specific angular momentum: {L_specific:.4f} AU²/year")
66print(f"Areal velocity: {dA_dt:.4f} AU²/year")
67print(f"Expected area per sector (T/{6}): {dA_dt * T/6:.4f} AU²")

Test Your Understanding

Summary

Kepler's Three Laws

Key Equations

Key Takeaways

1. Kepler's laws describe planetary motion empirically; Newton's derivation shows they follow from the inverse square law of gravity
2. Angular momentum conservation is equivalent to Kepler's Second Law—central forces produce no torque
3. The vis-viva equation relates speed to position and orbit size, enabling velocity calculations at any point
4. Orbital mechanics applies to satellites, spacecraft trajectories, and exoplanet detection
5. Modern ML uses these principles in Hamiltonian neural networks, N-body simulations, and trajectory optimization

Concluding Chapter 16: You've completed the study of vector-valued functions! From parametric curves to space curves, from the TNB frame to planetary orbits, you've seen how calculus describes motion in three dimensions. Next, we'll extend calculus to functions of multiple variables with Partial Derivatives.