Newton's second law, F = ma: what force really does

let V0 = 2
let X0 = -3.3
let PER = 0.97
let LANES = [[1.15, 0.5, "carpet", ROSE], [0.15, 0.2, "wood floor", GOLD], [-0.85, 0.03, "ice", AZURE]]
let slid = |mu, t| {
    let u = min(t, V0 / (mu * G))
    return V0 * u - 0.5 * mu * G * u * u
}
let speed = |mu, t| max(0, V0 - mu * G * t)
mesh lanes = block {
    for (ln in LANES) {
        . Lane(X0, PER, 7, ln[0], ln[3])
        . center{[X0 + 0.55, ln[0] + 0.5, 0]} Cap(ln[2], 0.76, ln[3])
    }
    . LaneNumbers(X0, PER, 7, -1.42, "distance slid (m)")
}
let Pucks = |t| block {
    for (ln in LANES) {
        let x = X0 + PER * slid(ln[1], t)
        let v = speed(ln[1], t)
        . fill{INK} stroke{INK, 1} center{[x, ln[0] + 0.11, 0]} Rect([0.34, 0.2])
        if (v > 0.45) {
            . Force([x + 0.2, ln[0] + 0.11, 0], [0.42 * v, 0, 0], EMBER, 4)
        }
    }
}
mesh pucks = Pucks(t: 0)

slide "slide"
    play Wait(0.7)
    pucks.t = 6.9
    play Lerp(6.9, [&pucks], linear)
    play Wait(1.2)

Give a puck a shove across a carpet and it stops within half a meter. Aristotle looked at motions like that one and drew the obvious conclusion: things move only while something pushes them, and stop when the pushing stops. For two thousand years this was physics.

Now give the same shove on a wood floor, and then on ice. The puck goes one meter, then nearly seven. Nothing about the puck or the shove changed; only the surface did. Galileo asked what the sequence is heading toward: on a surface with no friction at all, the puck would have no reason ever to stop. If that is right, Aristotle had it backward: the carpet is what stops the puck, and nothing at all is needed to keep it going.

Without a net force, velocity does not change

In the animation each puck loses velocity at a steady rate, and that rate is set by the surface: 4.9 m/s every second on the carpet, 1.96 on the wood, 0.29 on the ice. (These follow from friction coefficients of 0.5, 0.2 and 0.03; we will see how below.) As the friction force shrinks toward zero, so does the rate at which velocity is lost. The limiting case is Newton’s first law.

It needs one piece of vocabulary. A force is a push or a pull on one object by another: it has a size, measured in newtons (N), and a direction, so it is a vector. When several forces act on one object, their vector sum is the net force.

The clause about frames is needed. Watch a ball on the floor of a bus as the bus brakes: the ball rolls forward with no force pushing it. The law has not failed. A braking bus is not an inertial frame, and the law makes no claim there. For most purposes the ground is inertial to good accuracy, and every problem below is described from the ground.

Notice what the law says about the puck on carpet. Its velocity changes, so the net force on it cannot be zero, and the friction force is the only horizontal force around. Force is linked to the change of velocity. The next step is to find out exactly how.

The same push on different masses

Here is an experiment that can be done on an air-hockey table, where friction is negligible. Pull a puck with a spring held at a fixed stretch, so that the pull is constant, and record the motion. Then change the puck, or pull with two identical springs side by side for double the force.

let X0 = -3.0
let PER = 0.7
let F = 2
let LANES = [[1.15, 0.5, "0.5 kg", AZURE, 0.26, 0.18], [0.15, 1, "1 kg", EMBER, 0.36, 0.24], [-0.85, 2, "2 kg", PLUM, 0.5, 0.32]]
mesh lanes = block {
    for (ln in LANES) {
        . Lane(X0, PER, 8, ln[0], SLATE)
        . center{[X0 - 0.05, ln[0] + 0.56, 0]} Cap(ln[2], 0.76, ln[3])
    }
    . LaneNumbers(X0, PER, 8, -1.42, "distance from the start (m)")
}
let Pull = |t| block {
    for (ln in LANES) {
        let a = F / ln[1]
        let x = X0 + PER * 0.5 * a * t * t
        for (k in range(0, to_int(floor(t / 0.5 + 0.001)) + 1)) {
            . Pt([X0 + PER * 0.5 * a * 0.25 * k * k, ln[0] + 0.1, 0], ln[3], 0.055)
        }
        . fill{ln[3]} stroke{ln[3], 1} center{[x, ln[0] + ln[5] / 2, 0]} Rect([ln[4], ln[5]])
        . Force([x + ln[4] / 2, ln[0] + ln[5] / 2, 0], [0.62, 0, 0], FC)
    }
}
mesh pull = Pull(t: 0)

slide "pull"
    play Wait(0.8)
    pull.t = 2
    play Lerp(2, [&pull], linear)
    play Wait(1.8)

The dots spread out, so each puck is speeding up, and a measurement of the spacing shows that each one has a constant acceleration (the slope of its velocity graph; see the previous lesson). Here are the values such an experiment gives.

Monocurl source

Copy

let fg = Frame(0, 4.4, 0, 9, [-0.75, 0.2, 0], 5.0, 3.0)
let MASSES = [[0.5, AZURE, "0.5 kg"], [1, EMBER, "1 kg"], [2, PLUM, "2 kg"]]
mesh plot = Panel(fg, [1, 2, 3, 4], [2, 4, 6, 8], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8], "force F (N)", "acceleration a (m/s²)")
mesh lines = block {
    for (ms in MASSES) {
        . Seg(at(fg, 0, 0), at(fg, 4.3, 4.3 / ms[0]), ms[1], 4)
        for (f in [1, 2, 3, 4]) {
            . Pt(at(fg, f, f / ms[0]), ms[1], 0.085)
        }
        . center{[2.75, fy(fg, 4.3 / ms[0]), 0]} Cap(ms[2], 0.78, ms[1])
    }
}

Uses the shared definitions for this lesson's figures.

Newton’s second law

Each clause connects to something we have seen. “Net” is there because the puck on carpet responds to the total of the forces on it. The acceleration points along the net force, which is why friction, pointing backward, slows the puck. And $m$ measures how hard the object is to accelerate: the 2 kg puck needs twice the force of the 1 kg puck for the same acceleration. This resistance to acceleration is called inertia, and mass is its measure.

You might object that the law is circular: we measure force by the acceleration it causes and then announce that force causes acceleration. Part of the law is indeed a definition, since it fixes the size of the newton. But the table contains facts that no definition could force on nature: two identical springs give exactly twice the acceleration of one, and two identical pucks stuck together accelerate exactly half as much as one. Forces add, masses add, and one equation relates them. That is the experimental content, and it has been confirmed to high precision for everyday objects.

The law also answers the opening question precisely. What a force produces is acceleration, the rate of change of velocity. With zero net force the acceleration is zero and the velocity stays whatever it was, which is the first law again.

Several forces add as vectors

The second law is a vector equation. Suppose a 2 kg puck on the frictionless table is pushed with 3 N toward the east and, at the same time, 4 N toward the north. It does not accelerate at $7/2$ m/s².

let O = [-2.6, -1.55, 0]
let U = 0.8
let FE = 3
let FN = 4
let MASS = 2
let NET = sqrt(FE * FE + FN * FN)
let Puck = |d| center{[O[0] + 1.4 * d * FE / NET, O[1] + 1.4 * d * FN / NET, 0]} fill{INK} stroke{INK, 1} Circle(0.17, 48)
let North = |x| [
    Force([O[0] + x, O[1], 0], [0, U * FN, 0], EMBER),
    center{[O[0] + x + 0.5, O[1] + U * FN / 2, 0]} Math(str_join([to_string(FN), "\text{ N}"]), 0.85, EMBER)
]
mesh east = [
    Force(O, [U * FE, 0, 0], AZURE),
    center{[O[0] + U * FE / 2, O[1] - 0.38, 0]} Math(str_join([to_string(FE), "\text{ N}"]), 0.85, AZURE)
]
mesh north = North(x: 0)
mesh net = []
mesh puck = Puck(d: 0)
mesh side = [
    center{[2.0, 1.5, 0]} Note("mass of the puck", 0.74),
    center{[2.0, 1.05, 0]} Math(str_join([to_string(MASS), "\text{ kg}"]), 0.95)
]

slide "Two pushes act on a 2 kg puck seen from above: 3 N east and 4 N north."
    play Fade(0.8)

slide "Slide the second arrow to the tip of the first. Forces add tip to tail, as displacements do."
    north.x = U * FE
    play Lerp(1.4, [&north])

slide "The arrow from start to finish is the net force: 5 N, pointing 53 degrees north of east."
    net = [
        Force(O, [U * FE, U * FN, 0], FC, 5.5),
        center{[O[0] + U * FE / 2 - 0.55, O[1] + U * FN / 2 + 0.25, 0]} Math(str_join([to_string(NET, 0), "\text{ N}"]), 0.95, FC)
    ]
    side .= center{[2.0, 0.35, 0]} Note("net force", 0.74)
    side .= center{[2.0, -0.1, 0]} Math(str_join([to_string(NET, 0), "\text{ N}"]), 0.95, FC)
    play Fade(0.8, [&net, &side])

slide "The puck accelerates along the net force at 5 N / 2 kg = 2.5 m/s². Here is its first second."
    side .= center{[2.0, -0.8, 0]} Note("acceleration", 0.74)
    side .= center{[2.0, -1.25, 0]} Math(str_join([to_string(NET / MASS, 1), "\text{ m/s}^2"]), 0.95)
    play Fade(0.5, [&side])
    puck.d = 0.5 * (NET / MASS)
    play Lerp(1, [&puck], |u| u * u)

Forces combine the way displacements do, tip to tail (the lesson on vectors explains this addition in detail). Here the two pushes are perpendicular, so the Pythagorean theorem gives the size of the sum, $\sqrt{3^2 + 4^2} = 5$ N, and the acceleration is $5/2 = 2.5$ m/s² along that diagonal.

In practice we rarely draw the triangle. We choose perpendicular $x$ and $y$ axes, describe each force by its components along them, and use the second law once per axis:

For the puck, $a_x = 3/2 = 1.5$ m/s² and $a_y = 4/2 = 2$ m/s², and $\sqrt{1.5^2 + 2^2} = 2.5$ m/s² as before.

Weight is a force; mass is not

Near the Earth’s surface, every object dropped in a vacuum falls with the same acceleration, $g \approx 9.8$ m/s² downward. Read through the second law, that fact tells us the force of gravity on an object of mass $m$: it must have magnitude $mg$.

A 2 kg block has a weight of $2 \times 9.8 = 19.6$ N. Its mass is a property of the block and is 2 kg anywhere. Its weight depends on where it is: on the Moon, where $g$ is 1.62 m/s², the same block weighs 3.2 N and is exactly as hard to shove sideways as on Earth.

Forces come in pairs

A book lying on a table has weight, yet it does not accelerate, so some other force must balance its weight. The table pushes up on it. A force that a surface exerts at right angles to itself is called a normal force (“normal” meaning perpendicular).

Where there is a force there are always two objects, and the third law says the interaction is symmetric.

The book pushes down on the table as hard as the table pushes up on the book. The Earth pulls the book down with 19.6 N, say, and the book pulls the Earth up with 19.6 N. The Earth’s acceleration in response is that force divided by $6 \times 10^{24}$ kg, which is why nobody notices it.

Free-body diagrams: the method

Almost every mechanics problem is solved by the same procedure, and it is worth following it rigidly until it is automatic.

1. Choose one object.
2. Draw it alone, and draw an arrow for every force exerted on it by something else: its weight, plus one force for each thing touching it (surfaces, strings, hands). This drawing is a free-body diagram.
3. Choose axes, with one of them along the direction of the acceleration if you know it.
4. Split each force into components along the axes.
5. Write $\sum F = ma$ for each axis and solve.
6. Check units, and check a special case where you know the answer.

The standard first test of the method is a block sliding down a ramp. Take a 2 kg block on a frictionless ramp tilted at $30°$.

let TH = deg_to_rad(30)
let M = 2
let W = M * G
let U = 0.08
let B = [0.9, -1.85, 0]
let LEN = 5.2
let A = [B[0] - LEN * cos(TH), B[1] + LEN * sin(TH), 0]
let D = [cos(TH), -sin(TH), 0]
let N = [sin(TH), cos(TH), 0]
let P = [A[0] + 0.46 * LEN * D[0], A[1] + 0.46 * LEN * D[1], 0]
let C = [P[0] + 0.23 * N[0], P[1] + 0.23 * N[1], 0]
let along = W * sin(TH)
let into = W * cos(TH)
let Row = |y, tex, col| center{[2.5, y, 0]} Math(tex, 0.9, col)
let Q = [-2.9, 0.95, 0]
mesh ramp = [
    Shape([A, B, [A[0], B[1], 0]], SLATE, 0.12, 2.5),
    stroke{SLATE, 2.5} Angle(B, [B[0] - 1, B[1], 0], A, 0.9),
    center{[B[0] - 1.35, B[1] + 0.3, 0]} Math("30^\circ", 0.8, SLATE)
]
mesh body = Block(P, D, N, SLATE)
mesh given = Row(1.75, "m = 2\text{ kg}", INK)
mesh axes = []
mesh comps = []
mesh forces = []
mesh rows = []

slide "Isolate the block. Everything else matters only through the forces it exerts on the block."
    play Fade(0.8)

slide "Gravity pulls straight down with the block's weight: 2 kg times 9.8 m/s², or 19.6 N."
    forces = [Force(C, [0, -U * W, 0], EMBER)]
    rows = [Row(1.25, str_join(["mg = ", to_string(W, 1), "\text{ N}"]), EMBER)]
    play Fade(0.7, [&forces, &rows])

slide "The ramp pushes on the block at right angles to its surface. This is the normal force N."
    forces .= Force(C, [U * into * N[0], U * into * N[1], 0], AZURE)
    rows .= Row(0.75, "N = \,?", AZURE)
    play Fade(0.7, [&forces, &rows])

slide "Tilt the axes: x points down the ramp and y points out of it. The block can only move along x."
    axes = [
        Force(Q, 0.9 * D, SLATE, 2.5),
        Force(Q, 0.9 * N, SLATE, 2.5),
        center{Q + 1.15 * D} Math("x", 0.85, SLATE),
        center{Q + 1.15 * N} Math("y", 0.85, SLATE)
    ]
    play Fade(0.7, [&axes])

slide "Split the weight along the axes: 9.8 N down the ramp and 17.0 N into the ramp."
    comps = [
        dashed{[0.12, 0.08]} stroke{EMBER, 2.5} Line(C + U * along * D, C + [0, -U * W, 0]),
        dashed{[0.12, 0.08]} stroke{EMBER, 2.5} Line(C - U * into * N, C + [0, -U * W, 0]),
        Force(C, -U * into * N, GOLD, 3.5),
        Force(C, U * along * D, GOLD, 3.5)
    ]
    rows .= Row(0.1, str_join(["mg\sin 30^\circ = ", to_string(along, 1), "\text{ N}"]), GOLD)
    rows .= Row(-0.4, str_join(["mg\cos 30^\circ = ", to_string(into, 1), "\text{ N}"]), GOLD)
    play Fade(0.7, [&comps, &rows])

slide "Out of the ramp the forces cancel, so N = 17.0 N. Down the ramp, 9.8 N is left unbalanced: the net force."
    rows = [
        Row(1.25, str_join(["mg = ", to_string(W, 1), "\text{ N}"]), EMBER),
        Row(0.75, str_join(["N = ", to_string(into, 1), "\text{ N}"]), AZURE),
        Row(0.1, str_join(["mg\sin 30^\circ = ", to_string(along, 1), "\text{ N}"]), GOLD),
        Row(-0.4, str_join(["mg\cos 30^\circ = ", to_string(into, 1), "\text{ N}"]), GOLD),
        Row(-1.05, str_join(["F_{\text{net}} = ", to_string(along, 1), "\text{ N}"]), FC),
        Row(-1.55, str_join(["a = ", to_string(along / M, 1), "\text{ m/s}^2"]), FC)
    ]
    comps .= Force(C + 0.62 * N, U * along * D, FC, 5.5)
    play Fade(0.7, [&comps, &rows])

The one piece of geometry in that figure is the angle between the weight and the $y$ axis. Tilting a ramp by $\theta$ from the horizontal tilts its perpendicular by the same $\theta$ from the vertical, so the weight makes angle $\theta$ with the perpendicular. Its component along the perpendicular is therefore $mg\cos\theta$, and its component along the ramp is $mg\sin\theta$.

A real ramp also has friction. For a block that is sliding, the friction force is found by experiment to be roughly proportional to the normal force, $f = \mu_k N$, directed against the sliding, where the number $\mu_k$ (the coefficient of kinetic friction) depends on the two surfaces. This is an empirical rule that holds well for dry solids, and it is a model, with nothing like the standing of Newton’s laws.

The checks from step 6: $\sin\theta$ and $\cos\theta$ and $\mu_k$ are pure numbers, so $a$ has the units of $g$. With no friction, a flat ramp ($\theta \to 0°$) gives $a \to 0$ and a vertical one ($\theta \to 90°$) gives $a \to g$, free fall. And the mass has cancelled, for the same reason all objects fall together: a heavier block is pulled harder and is harder to accelerate, in the same proportion.

For our block at $30°$ with no friction, $a = 9.8 \times 0.5 = 4.9$ m/s². With $\mu_k = 0.2$, the friction force is $0.2 \times 17.0 = 3.4$ N and $a = 9.8\,(0.5 - 0.2 \times 0.866) = 3.2$ m/s². If friction is strong enough that $\mu_k > \tan\theta$, the formula gives a negative $a$: a block already sliding down slows, and once it stops it is no longer sliding, so the theorem no longer describes it.

let M = 2
let W = M * G
let U = 0.085
let P0 = [-1.5, 0.35, 0]
let Tilt = |deg| {
    let th = deg_to_rad(deg)
    let d = [cos(th), -sin(th), 0]
    let n = [sin(th), cos(th), 0]
    let a = P0 - 1.3 * d
    let b = P0 + 2.3 * d
    let c = P0 + 0.2 * n
    return [
        Shape([a, b, [a[0], b[1], 0]], SLATE, 0.12, 2.5),
        Block(P0, d, n, SLATE, 0.3, 0.4),
        dashed{[0.12, 0.08]} stroke{EMBER, 2.5} Line(c + U * W * sin(th) * d, c + [0, -U * W, 0]),
        dashed{[0.12, 0.08]} stroke{EMBER, 2.5} Line(c - U * W * cos(th) * n, c + [0, -U * W, 0]),
        Force(c, [0, -U * W, 0], EMBER),
        Force(c, -U * W * cos(th) * n, GOLD, 3.5),
        Force(c, U * W * sin(th) * d, FC, 5),
        center{[2.45, 1.2, 0]} scale{1.3} color{INK} Number(deg, 0),
        center{[2.45, 0.05, 0]} scale{1.3} color{FC} Number(W * sin(th), 1),
        center{[2.45, -1.1, 0]} scale{1.3} color{GOLD} Number(W * cos(th), 1)
    ]
}
mesh labels = [
    center{[2.45, 1.65, 0]} Note("ramp angle (degrees)", 0.72),
    center{[2.45, 0.5, 0]} Cap("along the ramp (N)", 0.72, FC),
    center{[2.45, -0.65, 0]} Cap("into the ramp (N)", 0.72, GOLD)
]
mesh tilt = Tilt(deg: 10)

slide "tilt"
    play Wait(0.8)
    tilt.deg = 80
    play Lerp(6, [&tilt], smooth)
    play Wait(1.4)

let TH = deg_to_rad(30)
let MU = 0.2
let PER = 0.56
let RUN = 5
let D = [cos(TH), -sin(TH), 0]
let N = [sin(TH), cos(TH), 0]
let A1 = G * sin(TH)
let A2 = G * (sin(TH) - MU * cos(TH))
let T1 = sqrt(2 * RUN / A1)
let T2 = sqrt(2 * RUN / A2)
let Ramp = |top| Shape([top, top + (RUN + 0.9) * PER * D, [top[0], top[1] + (RUN + 0.9) * PER * D[1], 0]], SLATE, 0.12, 2.5)
let TOP1 = [-3.5, 0.75, 0]
let TOP2 = [0.55, 0.75, 0]
let Slider = |top, acc, t, col| {
    let s = 0.45 + min(RUN, 0.5 * acc * t * t)
    return Block(top + s * PER * D, D, N, col, 0.2, 0.28)
}
mesh ramps = [Ramp(TOP1), Ramp(TOP2)]
mesh words = [
    center{[-2.0, 1.85, 0]} Cap("no friction", 0.76, AZURE),
    center{[-2.0, 1.4, 0]} Math(str_join(["a = ", to_string(A1, 1), "\text{ m/s}^2"]), 0.82, AZURE),
    center{[2.05, 1.85, 0]} Cap("friction coefficient 0.2", 0.76, EMBER),
    center{[2.05, 1.4, 0]} Math(str_join(["a = ", to_string(A2, 1), "\text{ m/s}^2"]), 0.82, EMBER),
    center{[-2.0, -1.4, 0]} Note("5 m takes", 0.74),
    center{[-2.0, -1.82, 0]} Math(str_join([to_string(T1, 2), "\text{ s}"]), 0.85, AZURE),
    center{[2.05, -1.4, 0]} Note("5 m takes", 0.74),
    center{[2.05, -1.82, 0]} Math(str_join([to_string(T2, 2), "\text{ s}"]), 0.85, EMBER)
]
let Race = |t| [Slider(TOP1, A1, t, AZURE), Slider(TOP2, A2, t, EMBER)]
mesh race = Race(t: 0)

slide "race"
    play Wait(1)
    race.t = 1.9
    play Lerp(1.9, [&race], linear)
    play Wait(1.8)

We can now account for the opening figure. A puck on a level surface has $N = mg$, so friction is $\mu_k mg$ and the puck’s acceleration is $-\mu_k g$: $-4.9$ m/s² for $\mu_k = 0.5$, $-0.29$ m/s² for $\mu_k = 0.03$.

Worked examples

A harder problem has two objects tied together. In an Atwood machine two masses hang from a string that passes over a pulley. Take $m_1 = 3$ kg and $m_2 = 2$ kg, released from rest.

let M1 = 3
let M2 = 2
let ACC = (M1 - M2) * G / (M1 + M2)
let TEN = 2 * M1 * M2 * G / (M1 + M2)
let PER = 1.0
let U = 0.04
let PC = [-1.7, 1.42, 0]
let R = 0.48
let Hang = |x, y, mass, col, side| {
    let hw = 0.22 + 0.06 * mass
    return [
        Seg([x, PC[1], 0], [x, y + 0.35, 0], SLATE, 2.5),
        Box([x, y, 0], [2 * hw, 0.7], col, 0.3),
        center{[x, y, 0]} Math(str_join([to_string(mass), "\text{ kg}"]), 0.8, col),
        Force([x + side * (hw + 0.2), y, 0], [0, U * TEN, 0], GOLD),
        Force([x + side * (hw + 0.2), y, 0], [0, -U * mass * G, 0], EMBER)
    ]
}
let Machine = |t| {
    let drop = PER * 0.5 * ACC * t * t
    return [Hang(PC[0] - R, 0.5 - drop, M1, PLUM, -1), Hang(PC[0] + R, -0.9 + drop, M2, AZURE, 1)]
}
mesh support = [
    Seg([PC[0] - 1.3, 2.05, 0], [PC[0] + 1.3, 2.05, 0], SLATE, 4),
    Seg([PC[0], 2.05, 0], PC, SLATE, 3),
    Disc(PC, R, SLATE, 0.15, 2.5),
    Pt(PC, SLATE, 0.06)
]
mesh words = [
    center{[2.0, 1.6, 0]} Cap("string tension, up", 0.74, GOLD),
    center{[2.0, 1.15, 0]} Math(str_join([to_string(TEN, 1), "\text{ N on each}"]), 0.82, GOLD),
    center{[2.0, 0.4, 0]} Cap("weights, down", 0.74, EMBER),
    center{[2.0, -0.05, 0]} Math(str_join([to_string(M1 * G, 1), "\text{ N and }", to_string(M2 * G, 1), "\text{ N}"]), 0.82, EMBER),
    center{[2.0, -0.8, 0]} Note("acceleration of each", 0.74),
    center{[2.0, -1.25, 0]} Math(str_join([to_string(ACC, 2), "\text{ m/s}^2"]), 0.9)
]
mesh machine = Machine(t: 0)

slide "release"
    play Wait(1)
    machine.t = 1.2
    play Lerp(1.2, [&machine], linear)
    play Wait(1.8)

Where the laws apply

Each hypothesis in the second law marks a boundary. The frame must be inertial: inside the braking bus, or on a spinning carousel, objects accelerate with no force on them, and the law has to be supplemented before it can be used there. The object is treated as a single point with one acceleration; a block that tips or a wheel that spins needs more than this lesson. The mass must stay constant, which rules out a rocket burning its fuel. And at speeds near that of light, about $3 \times 10^8$ m/s, the law itself gives way to special relativity. For cars, balls and planets it is accurate far beyond what you can measure in a school laboratory.

The next lesson, on projectile motion, applies the two component equations to a ball in flight, where the only force is gravity.

Problems

Use $g = 9.8$ m/s². Draw a free-body diagram for every problem that involves forces on an object.

# house kit: prepended to every essay figure after the std imports

# palette. AZURE and EMBER are the two actors, LEAF marks an answer, ROSE a problem
let PAPER = [1, 1, 1, 1]
let INK = [0.08, 0.09, 0.11, 1]
let SLATE = [0.40, 0.44, 0.50, 1]
let MIST = [0.85, 0.86, 0.88, 1]
let AZURE = [0.13, 0.42, 0.68, 1]
let EMBER = [0.89, 0.42, 0.12, 1]
let LEAF = [0.13, 0.55, 0.36, 1]
let ROSE = [0.78, 0.22, 0.24, 1]
let PLUM = [0.47, 0.30, 0.66, 1]
let GOLD = [0.85, 0.62, 0.08, 1]

background = PAPER

# an opaque pastel of col; use for fills so overlaps do not darken
let tint = |col, amount = 0.18| [
    1 - (1 - col[0]) * amount,
    1 - (1 - col[1]) * amount,
    1 - (1 - col[2]) * amount,
    1
]

# text: Cap for labels, Note for quiet labels, Math for typeset maths
let Cap = |txt, size = 0.75, col = INK| color{col} Text(txt, size, "Charter")
let Note = |txt, size = 0.65| color{SLATE} Text(txt, size, "Charter")
let Math = |tex, size = 0.9, col = INK| color{col} Tex(tex, size)

# a paper rectangle to sit behind text that crosses lines
let Plate = |pos, size| center{pos} fill{PAPER} stroke{alpha{0} PAPER, 0} Rect(size)

# shapes with fill and stroke both set, so no stray black appears
let Pt = |pos, col = INK, r = 0.075| center{pos} fill{col} stroke{col, 1} Circle(r, 48)
let Ring = |pos, col = INK, r = 0.1, w = 3| center{pos} fill{PAPER} stroke{col, w} Circle(r, 48)
let Seg = |a, b, col = INK, w = 3| stroke{col, w} Line(a, b)
let Path = |pts, col = INK, w = 3| stroke{col, w} Polyline(pts)
let Region = |pts, col| fill{col} stroke{alpha{0} col, 0} Polygon(pts)
let Outline = |pts, col = INK, w = 3| fill{alpha{0} PAPER} stroke{col, w} Polygon(pts)
let Shape = |pts, col, amount = 0.18, w = 3| fill{tint(col, amount)} stroke{col, w} Polygon(pts)
let Disc = |pos, r, col, amount = 0.18, w = 3| center{pos} fill{tint(col, amount)} stroke{col, w} Circle(r, 96)
let Box = |pos, size, col, amount = 0.18, w = 3| center{pos} fill{tint(col, amount)} stroke{col, w} Rect(size)
# a line from a to b ending in a small solid arrowhead
let Tip = |a, b, col = INK, w = 3, head = 0.17| {
    let d = normalize([b[0] - a[0], b[1] - a[1], 0])
    let n = [-d[1], d[0], 0]
    let base = [b[0] - d[0] * head, b[1] - d[1] * head, 0]
    return [
        stroke{col, w} Line(a, base),
        fill{col} stroke{col, 1} Polygon([
            b,
            [base[0] + n[0] * head * 0.42, base[1] + n[1] * head * 0.42, 0],
            [base[0] - n[0] * head * 0.42, base[1] - n[1] * head * 0.42, 0]
        ])
    ]
}

# plots. a frame is [x0, x1, y0, y1, centre, width, height]: a data window and the scene box it fills
let Frame = |x0, x1, y0, y1, c = [0, 0, 0], w = 6.4, h = 3.6| [x0, x1, y0, y1, c, w, h]
let fx = |fr, x| fr[4][0] + (x - (fr[0] + fr[1]) / 2) * fr[5] / (fr[1] - fr[0])
let fy = |fr, y| fr[4][1] + (y - (fr[2] + fr[3]) / 2) * fr[6] / (fr[3] - fr[2])
let at = |fr, x, y| [fx(fr, x), fy(fr, y), 0]

# axes through the data origin (or the nearest edge of the window), with optional names
let Axes = |fr, x_name = "", y_name = "", col = SLATE| {
    let ox = clamp(fr[0], 0, fr[1])
    let oy = clamp(fr[2], 0, fr[3])
    var parts = [
        Tip(at(fr, fr[0], oy), [fx(fr, fr[1]) + 0.25, fy(fr, oy), 0], col, 2.5, 0.15),
        Tip(at(fr, ox, fr[2]), [fx(fr, ox), fy(fr, fr[3]) + 0.25, 0], col, 2.5, 0.15)
    ]
    if (x_name != "") {
        parts .= center{[fx(fr, fr[1]) + 0.5, fy(fr, oy), 0]} Math(x_name, 0.8, col)
    }
    if (y_name != "") {
        parts .= center{[fx(fr, ox), fy(fr, fr[3]) + 0.5, 0]} Math(y_name, 0.8, col)
    }
    return parts
}

# tick marks with numbers at the listed data values
let XTicks = |fr, xs, col = SLATE, places = 0| block {
    let oy = fy(fr, clamp(fr[2], 0, fr[3]))
    for (x in xs) {
        . Seg([fx(fr, x), oy - 0.07, 0], [fx(fr, x), oy + 0.07, 0], col, 2)
        . center{[fx(fr, x), oy - 0.33, 0]} Math(to_string(x, places), 0.72, col)
    }
}
let YTicks = |fr, ys, col = SLATE, places = 0| block {
    let ox = fx(fr, clamp(fr[0], 0, fr[1]))
    for (y in ys) {
        . Seg([ox - 0.07, fy(fr, y), 0], [ox + 0.07, fy(fr, y), 0], col, 2)
        . center{[ox - 0.36, fy(fr, y), 0]} Math(to_string(y, places), 0.72, col)
    }
}

# faint grid lines at the listed data values
let GridLines = |fr, xs, ys, col = MIST| block {
    for (x in xs) {
        . Seg(at(fr, x, fr[2]), at(fr, x, fr[3]), col, 1.5)
    }
    for (y in ys) {
        . Seg(at(fr, fr[0], y), at(fr, fr[1], y), col, 1.5)
    }
}

# the graph of f over [a, b], drawn in the frame. values are clamped to the window
let Graph = |fr, f, a, b, col = AZURE, w = 4, n = 160|
    stroke{col, w} Polyline(map(sample(a, b, n), |x| at(fr, x, clamp(fr[2], f(x), fr[3]))))

# the region between the graph of f and the x axis over [a, b]
let AreaUnder = |fr, f, a, b, col = AZURE, amount = 0.2, n = 80| {
    var pts = [at(fr, a, 0)]
    for (x in sample(a, b, n)) {
        pts .= at(fr, x, clamp(fr[2], f(x), fr[3]))
    }
    pts .= at(fr, b, 0)
    return fill{tint(col, amount)} stroke{alpha{0} col, 0} Polygon(pts)
}

let G = 9.8
let FC = LEAF
# plot furniture: grid, left and bottom edges, numbers along the edges, names
let Panel = |f, gx, gy, lx, ly, xname, title, col = SLATE| block {
    . GridLines(f, gx, gy)
    . Path([at(f, f[0], f[3]), at(f, f[0], f[2]), at(f, f[1], f[2])], SLATE, 2.5)
    for (x in lx) {
        . center{[fx(f, x), fy(f, f[2]) - 0.3, 0]} Math(to_string(x), 0.72, SLATE)
    }
    for (y in ly) {
        . center{[fx(f, f[0]) - 0.36, fy(f, y), 0]} Math(to_string(y), 0.72, SLATE)
    }
    . center{[(fx(f, f[0]) + fx(f, f[1])) / 2, fy(f, f[2]) - 0.64, 0]} Note(xname, 0.72)
    . center{[(fx(f, f[0]) + fx(f, f[1])) / 2, fy(f, f[3]) + 0.3, 0]} Cap(title, 0.74, col)
}
# an arrow for a force: from tail, along vec (scene units)
let Force = |tail, vec, col, w = 4.5| Tip(tail, [tail[0] + vec[0], tail[1] + vec[1], 0], col, w, 0.2)
# a horizontal surface with a tick every meter, from 0 m to n m
let Lane = |x0, per, n, y, col| block {
    . fill{tint(col, 0.3)} stroke{col, 2} center{[x0 + per * n / 2, y - 0.07, 0]} Rect([per * n + 0.6, 0.14])
    for (m in range(0, n + 1)) {
        . Seg([x0 + per * m, y - 0.14, 0], [x0 + per * m, y - 0.26, 0], SLATE, 2)
    }
}
let LaneNumbers = |x0, per, n, y, name| block {
    for (m in range(0, n + 1)) {
        . center{[x0 + per * m, y, 0]} Math(to_string(m), 0.72, SLATE)
    }
    . center{[x0 + per * n / 2, y - 0.36, 0]} Note(name, 0.72)
}
# a block resting on the point p of a surface whose downhill direction is d and outward normal n
let Block = |p, d, n, col, half = 0.36, tall = 0.46| fill{tint(col, 0.35)} stroke{col, 3} Polygon([
    [p[0] - half * d[0], p[1] - half * d[1], 0],
    [p[0] + half * d[0], p[1] + half * d[1], 0],
    [p[0] + half * d[0] + tall * n[0], p[1] + half * d[1] + tall * n[1], 0],
    [p[0] - half * d[0] + tall * n[0], p[1] - half * d[1] + tall * n[1], 0]
])