Why does gravity write a parabola, every time?

Two motions, one ball

Once the ball leaves your hand, the only force on it is gravity — pulling straight down. Nothing pushes it horizontally. So horizontally, it carries on at whatever velocity you launched it with — uniform, forever, until it lands. Vertically, gravity slows it on the way up, stops it briefly at the apex, and speeds it up on the way down. The horizontal motion has no idea there’s gravity. The vertical motion has no idea there’s a horizontal velocity. Each is a one-dimensional problem; we solve them in parallel and only later combine them into a 2D picture.

Equations of motion

Split the launch velocity into components: $vₓ = v₀ \cos θ$, $v_y = v₀ \sin θ$. The horizontal component is constant; the vertical component decreases at a rate of $g$ (the constant downward acceleration ): $v_y(t) = v₀ \sin θ − g·t$. Integrate once and you get position:

x(t) = v₀ cos θ · t
y(t) = v₀ sin θ · t − ½ g t²

That pair is a parametric curve: two functions of a shared time parameter $t$. The image of this curve is the shape on the field; the parametrization is the actual motion in time. Same image can be painted by many parametrizations — we’ll see one shortly.

The phrase “integrate once and you get position” is doing real work here. Gravity gives acceleration. Integrate acceleration to get velocity; integrate velocity to get position. The parabola is not magic — it is accumulated change twice. The constants of integration are fixed by initial conditions: at $t = 0$ the velocity is the launch velocity (no fall yet) and the position is the launch point (no displacement yet). Two integrations, two constants, one closed-form trajectory.

import math

# Two motions, independent. The horizontal one ignores gravity;
# the vertical one ignores horizontal velocity.
def position(t, v0, theta_deg, g):
    th = math.radians(theta_deg)
    x = v0 * math.cos(th) * t           # uniform velocity → linear in t
    y = v0 * math.sin(th) * t - 0.5 * g * t**2  # constant accel → quadratic
    return x, y

def velocity(t, v0, theta_deg, g):
    th = math.radians(theta_deg)
    return v0 * math.cos(th), v0 * math.sin(th) - g * t

position(0.0, 20, 45, 9.8)   # → (0.0, 0.0)         start
position(1.0, 20, 45, 9.8)   # → (14.14, 9.24)
velocity(1.0, 20, 45, 9.8)   # → (14.14, 4.34)      vy decreased

Eliminate time, see the parabola

Solve $x(t) = v₀ \cos θ · t$ for $t$: $t = x / (v₀ \cos θ)$. Plug into $y(t)$:

y(x) = (tan θ) · x  −  g · x² / (2 v₀² cos²θ)

That is a quadratic in $x$. The trace of two independent linear processes (in $t$) is necessarily quadratic (in $x$) — and the graph of a quadratic is a parabola . The parabola is the image of the motion. The motion is the parametrization. The image hides the time axis; you can read shape off it, but you cannot tell how fast the ball got there.

# Eliminate t. Substitute t = x / (v0 cos θ) into y(t):
#   y = (tan θ) · x  −  g · x² / (2 v0² cos²θ)
# That's a quadratic in x — a parabola. The motion's image, with
# the time-axis collapsed.
def trajectory(x, v0, theta_deg, g):
    th = math.radians(theta_deg)
    a = -g / (2 * v0**2 * math.cos(th)**2)
    b = math.tan(th)
    return a * x**2 + b * x

trajectory(14.14, 20, 45, 9.8)  # → 9.24   (matches y from arc2 — same image)

What you can read off without solving anything

Four facts fall out of the formula.

• Time to peak. Vertical velocity $v_y(t) = v₀ \sin θ − g·t$ hits zero at $t_peak = v₀ \sin θ / g$. That is when the ball is highest.
• Time to land. By symmetry, the down-trip mirrors the up-trip: $t_land = 2 · t_peak$. The widget’s stat row shows it.
• Range. $R = v₀ \cos θ · t_land = v₀² \sin(2θ) / g$. Maximum at $2θ = 90°$, i.e. launch angle $θ = 45°$. The longest throw is the one split evenly between up and forward.
• Symmetry. The peak sits at $x = R/2$. The speed at impact equals the speed at launch (same $vₓ$, equal-magnitude opposite-sign $v_y$). Without drag, the ball loses no energy to the air.

# Standard closed forms — read off the parabola without solving anything.
def t_peak(v0, theta_deg, g):
    return v0 * math.sin(math.radians(theta_deg)) / g

def t_land(v0, theta_deg, g):
    return 2 * t_peak(v0, theta_deg, g)        # symmetric flight

def range_(v0, theta_deg, g):
    return v0**2 * math.sin(math.radians(2 * theta_deg)) / g

def y_max(v0, theta_deg, g):
    return v0**2 * math.sin(math.radians(theta_deg))**2 / (2 * g)

range_(20, 45, 9.8)   # → 40.82  (max range at 45° on a flat field)
y_max(20, 45, 9.8)    # → 10.20

Same image, different motions

The image-vs-parametrization distinction the parametric-curves module makes precise applies right here. Look at $y(x) = (\tan θ) x − g x² / (2 v₀² \cos²θ)$: the shape of the parabola depends only on $θ$ and the ratio $g/v₀²$. Double both $v₀$ and $g$ together by appropriate factors and you get the same parabola, traversed in a different time. A throw on the Moon with the right matching speed paints exactly the same shape as a throw on Earth — but slower, because the Moon’s clock for the same shape ticks differently.

That is the same lesson as Bezier curves and as the parametric-curves spike that became a module: the picture is one thing, the motion that paints it is another. Two parametrizations can disagree on every detail except the image they produce.