Monocurl Essays
Series Download

Why the area of a circle is πr²

The number π is defined by the distance around a circle. Cutting the circle into sectors, and then into rings, shows why the same π gives its area.

23 min·High school·

AssumesThe Pythagorean theorem: a proof you can see

A circle is cut into 16 equal sectors, and the sectors are stood in a row, pointing alternately up and down. The row is close to a rectangle whose height is the radius and whose width is half the circumference.
Monocurl source
let R = 1.25
let FROM = [-2.45, 0, 0]
let TO = [1.6, 0, 0]
let W = PI * R
mesh ghost = center{FROM} fill{tint(SLATE, 0.08)} stroke{MIST, 2.5} Circle(R, 96)
mesh fig = Sectors(n: 16, s: 0, R, FROM, TO)
mesh labels = []

slide "deal"
    play Wait(0.9)
    fig.s = 1
    play Lerp(4, [&fig])
    labels = [
        Seg([TO[0] - W / 2, -R / 2 - 0.3, 0], [TO[0] + W / 2, -R / 2 - 0.3, 0], LEAF, 3.5),
        center{[TO[0], -R / 2 - 0.68, 0]} Cap("half the circumference", 0.74, LEAF),
        Seg([TO[0] - W / 2 - 0.12, -R / 2, 0], [TO[0] - W / 2 - 0.12, R / 2, 0], LEAF, 3.5),
        Name("r", [TO[0] - W / 2 - 0.4, 0, 0], 0.9, LEAF),
        Seg(FROM, FROM + R * dir(rad(35)), SLATE, 3),
        Name("r", FROM + 0.5 * R * dir(rad(35)) + [-0.12, 0.25, 0], 0.9, SLATE)
    ]
    play Fade(0.7, [&labels])
    play Wait(2)

Uses the shared definitions for this lesson's figures.

Wrap a string once around a circular plate, then lay the string straight and measure it against the plate’s width. It is a bit more than three widths long, and it is the same number of widths for a coin as for a cartwheel. That number is called π. So the formula for the distance around a circle of radius $r$, which is $2\pi r$, needs no proof. It is what π means.

The formula for the area inside the circle, $\pi r^2$, is another matter. Area is measured by covering a region with unit squares, and nothing about a string wrapped around the rim says how many squares fit inside. Yet the same number π appears. Why should a number that was defined by a length also govern an area? And why does the area go with $r^2$, where the length went with $r$?

What π is

Let’s put the definition down carefully, since everything rests on it.

A circle with center $O$ and radius $r$ is the set of points in the plane at distance exactly $r$ from $O$. Its diameter is $d = 2r$, the distance across through the center. Its circumference $C$ is the distance around it.

The definition quietly assumes that $C/d$ is the same for every circle. That is true because any two circles are scaled copies of each other, and scaling a figure multiplies all of its lengths, straight or curved, by the same factor. The lesson on similar triangles looks at scaling in detail. Here I will take it as known.

One more point needs care. “The distance around” a curved line needs a meaning, because a ruler only measures straight segments. The standard meaning is this: mark evenly spaced points around the circle and join them in order by straight segments, making a polygon inside the circle. Each side is a shortcut across a piece of the curve, so the perimeter falls short of the distance around, and as the points are packed more closely the perimeters approach a limiting value without ever exceeding it. That limiting value is $C$. (That the perimeters do settle on one value is proved in calculus, and I take it as known.) We will use exactly this later.

How big should the area be?

Before looking for a formula, it helps to know roughly what answer to expect. A circle of radius $r$ fits snugly inside a square of side $2r$, and it contains a smaller square standing on its corner, whose corners touch the circle.

A circle of radius r between two squares. The outer square has side 2r and area 4r^2. The inner square is made of four right triangles with legs r, so its area is 2r^2.
A circle of radius $r$ between two squares. The outer square has side $2r$ and area $4r^2$. The inner square is made of four right triangles with legs $r$, so its area is $2r^2$.
Monocurl source
let R = 1.8
let O = [-1.6, 0, 0]
mesh outer = center{O} fill{tint(EMBER, 0.22)} stroke{EMBER, 3} Rect([2 * R, 2 * R])
mesh disc = center{O} fill{tint(AZURE, 0.35)} stroke{AZURE, 3.5} Circle(R, 128)
mesh inner = fill{tint(LEAF, 0.35)} stroke{LEAF, 3} Polygon(ring_pts(O, R, 4))
mesh cross = [
    Seg(O - [R, 0, 0], O + [R, 0, 0], SLATE, 2),
    Seg(O - [0, R, 0], O + [0, R, 0], SLATE, 2),
    Name("r", O + [R / 2, 0.22, 0], 0.85),
    Name("r", O + [0.2, R / 2, 0], 0.85)
]
mesh labels = [
    center{[2.3, 1.3, 0]} Cap("outer square", 0.76, EMBER),
    Name("4r^2", [2.3, 0.8, 0], 1.0, EMBER),
    center{[2.3, 0.1, 0]} Cap("circle", 0.76, AZURE),
    Name("?", [2.3, -0.4, 0], 1.0, AZURE),
    center{[2.3, -1.1, 0]} Cap("inner square", 0.76, LEAF),
    Name("2r^2", [2.3, -1.6, 0], 1.0, LEAF)
]

Uses the shared definitions for this lesson's figures.

The outer square has area $(2r)^2 = 4r^2$. The two diameters drawn in the figure cut it into four squares of side $r$. They cut the inner square into four right triangles, each with both legs equal to $r$, so each is half of an $r$-by-$r$ square, and the inner square has area $4 \cdot \frac{1}{2}r^2 = 2r^2$. The circle lies between the two, so

$$ 2r^2 < \text{area of the circle} < 4r^2. $$

This already answers the question about $r^2$. The area is some number between 2 and 4, times $r^2$, and that number is the same for every circle, because all circles are scaled copies of one another and scaling a figure by a factor $k$ multiplies its area by $k^2$ (also shown in the lesson on similar triangles). The question is what the number is. Halfway between 2 and 4 is 3, which is suspiciously close to π, but “close” is all we can say so far.

We can tighten the bounds by counting. Draw a circle of radius 10 on squared paper and sort the cells into those that lie completely inside the circle and those that the circle passes through.

A circle of radius 10 on a grid of unit cells. The blue cells lie entirely inside the circle, and the orange cells are the ones its edge passes through. The area of the circle is more than the blue count and less than the blue and orange counts together.
A circle of radius 10 on a grid of unit cells. The blue cells lie entirely inside the circle, and the orange cells are the ones its edge passes through. The area of the circle is more than the blue count and less than the blue and orange counts together.
Monocurl source
let N = 10
let U = 0.19
let O = [-1.6, 0, 0]
let far = |i| max(abs(i), abs(i + 1))
let near = |i| min(abs(i), abs(i + 1))
let cells = block {
    for (i in range(-N, N)) {
        for (j in range(-N, N)) {
            var kind = 0
            if (far(i) ^ 2 + far(j) ^ 2 <= N * N) {
                kind = 2
            } else if (near(i) ^ 2 + near(j) ^ 2 < N * N) {
                kind = 1
            }
            . [i, j, kind]
        }
    }
}
let inside = len(filter(cells, |c| c[2] == 2))
let edge = len(filter(cells, |c| c[2] == 1))
mesh grid = map(cells, |c| center{O + [(c[0] + 0.5) * U, (c[1] + 0.5) * U, 0]}
    fill{[PAPER, tint(EMBER, 0.5), tint(AZURE, 0.5)][c[2]]} stroke{MIST, 1} Rect([U, U]))
mesh circle = center{O} fill{alpha{0} PAPER} stroke{INK, 3} Circle(N * U, 128)
mesh labels = [
    center{[2.3, 1.45, 0]} Cap("cells inside", 0.76, AZURE),
    Name(to_string(inside), [2.3, 0.95, 0], 1.0, AZURE),
    center{[2.3, 0.3, 0]} Cap("cells on the edge", 0.76, EMBER),
    Name(to_string(edge), [2.3, -0.2, 0], 1.0, EMBER),
    center{[2.3, -0.9, 0]} Note("so the area is between", 0.74),
    Name(str_join([to_string(inside), "\text{ and }", to_string(inside + edge)]), [2.3, -1.4, 0], 0.95)
]

Uses the shared definitions for this lesson's figures.

There are 276 cells inside and 68 more on the edge, so the area is between 276 and 344 square units. Here $r^2 = 100$, so the mystery number is between 2.76 and 3.44. The value $\pi \approx 3.14$ is comfortably inside that range.

Counting will never do better than a range, though. However fine the grid, there are always cells cut by the edge, because a circle has no straight parts for the cells to line up with. To get an exact answer we need to turn the circle into a shape with straight sides, whose area we already know how to compute.

Cutting the circle into sectors

Which cuts should we make? We want pieces that can be rearranged, and whose curved edges do as little damage as possible. The only length we know on a circle, apart from $r$, is the circumference, so the pieces should keep the circumference in view. Cuts along radii do that. They divide the circle into equal slices, like a pizza, called sectors. Each sector has two straight sides of length $r$ and one curved side, which is its share of the circumference.

One sector of a circle cut into 8 equal sectors. Its curved side is one eighth of the circumference. It is nearly a triangle with that side as base and the radius as height, and the thin red sliver is the difference.
One sector of a circle cut into 8 equal sectors. Its curved side is one eighth of the circumference. It is nearly a triangle with that side as base and the radius as height, and the thin red sliver is the difference.
Monocurl source
let R = 1.7
let O = [-1.7, -0.35, 0]
let n = 8
let w = TAU / n
let a0 = PI / 2 - w / 2
let a1 = PI / 2 + w / 2
let arc = map(sample(a0, a1, 24), |t| O + R * dir(t))
mesh disc = center{O} fill{tint(SLATE, 0.08)} stroke{SLATE, 2.5} Circle(R, 128)
mesh cuts = map(range(0, n), |i| Seg(O, O + R * dir(a0 + i * w), MIST, 2))
mesh sliver = fill{tint(ROSE, 0.6)} stroke{ROSE, 1.5} Polygon(arc)
mesh tri = fill{tint(AZURE, 0.5)} stroke{AZURE, 3} Polygon([O, O + R * dir(a0), O + R * dir(a1)])
mesh rim = stroke{EMBER, 5} Polyline(arc)
mesh labels = [
    Name("r", O + 0.5 * R * dir(a0) + [0.25, 0, 0], 0.9),
    Name("r", O + 0.5 * R * dir(a1) + [-0.25, 0, 0], 0.9),
    Name("\frac{1}{8}C", O + [0, R + 0.32, 0], 0.8, EMBER),
    center{[2.2, 1.0, 0]} Note("nearly a triangle with", 0.74),
    center{[2.2, 0.45, 0]} Cap("base: an eighth of C", 0.76, EMBER),
    center{[2.2, -0.05, 0]} Cap("height: r", 0.76, AZURE),
    center{[2.2, -0.75, 0]} Note("left over", 0.74),
    center{[2.2, -1.2, 0]} Cap("a thin sliver", 0.76, ROSE)
]

Uses the shared definitions for this lesson's figures.

A sector is not a triangle, because one of its sides is curved. But it is nearly one. Its two straight sides are radii, and the curved side bulges only slightly beyond the straight line joining its ends. If we pretend the sector is a triangle whose base is its curved side and whose height is $r$, we make a small error, the sliver in the figure, and the error shrinks as the sectors get narrower.

Pause and try

Suppose the circle is cut into $n$ equal sectors and each is treated as a triangle with base equal to its share of the circumference, $C/n$, and height $r$. What total area does that give for the circle? Then substitute $C = 2\pi r$.

Show answerHide answer

Each triangle has area $\frac{1}{2} \cdot \frac{C}{n} \cdot r$. There are $n$ of them, so the total is $n \cdot \frac{1}{2} \cdot \frac{C}{n} \cdot r = \frac{1}{2} C r$. The $n$ cancels, so the estimate does not depend on how many sectors there are. With $C = 2\pi r$ it becomes $\frac{1}{2} \cdot 2\pi r \cdot r = \pi r^2$.

So the formula appears at once, and we can see where its two ingredients come from. The π comes in through the circumference, which supplies the bases of the triangles. The second factor of $r$ is their height.

That calculation treated curved pieces as straight, so it is a strong hint and no more. There are two things to do. One is to see the estimate as a picture, and the other is to deal honestly with the slivers.

Rearranging the sectors

For the picture, stand the sectors in a row, pointing alternately up and down so that they interlock.

  1. Cut the circle into 8 sectors and stand them in a row, alternately up and down. The row is a lumpy parallelogram.
  2. With 16 sectors the lumps are smaller and the ends are steeper.
  3. With 64 sectors the row is hard to tell from a rectangle.
  4. The rectangle it approaches has width πr, half the circumference, and height r. Its area is πr × r.
A circle cut into 8, then 16, then 64 sectors, each time rearranged into a row. The width of the row closes in on $\pi r$, half the circumference, and its height closes in on $r$.
Monocurl source
let R = 1.55
let MID = [0, 0.4, 0]
let Readout = |k| {
    let w = TAU / k
    return [
        center{[-1.75, -1.55, 0]} Math(str_join(["\text{width} \approx ", to_string(k * sin(w / 2), 3), "\,r"]), 0.8),
        center{[1.75, -1.55, 0]} Math(str_join(["\text{height} \approx ", to_string(cos(w / 2), 3), "\,r"]), 0.8)
    ]
}
mesh fig = Sectors(n: 8, s: 0, R, MID, MID)
mesh readout = []
mesh frame = []

slide "Cut the circle into 8 sectors and stand them in a row, alternately up and down. The row is a lumpy parallelogram."
    play Wait(0.4)
    fig.s = 1
    play Lerp(2.2, [&fig])
    readout = Readout(8)
    play Fade(0.4, [&readout])

slide "With 16 sectors the lumps are smaller and the ends are steeper."
    readout = []
    play Fade(0.3, [&readout])
    fig.n = 16
    fig.s = 0
    play Set([&fig])
    play Wait(0.5)
    fig.s = 1
    play Lerp(2.2, [&fig])
    readout = Readout(16)
    play Fade(0.4, [&readout])

slide "With 64 sectors the row is hard to tell from a rectangle."
    readout = []
    play Fade(0.3, [&readout])
    fig.n = 64
    fig.s = 0
    play Set([&fig])
    play Wait(0.5)
    fig.s = 1
    play Lerp(2.2, [&fig])
    readout = Readout(64)
    play Fade(0.4, [&readout])

slide "The rectangle it approaches has width πr, half the circumference, and height r. Its area is πr × r."
    frame = [
        fill{alpha{0} PAPER} stroke{LEAF, 4} center{MID} Rect([PI * R, R]),
        Name("\pi r", MID + [0, R / 2 + 0.3, 0], 0.9, LEAF),
        Name("r", MID + [PI * R / 2 + 0.3, 0, 0], 0.9, LEAF)
    ]
    play Fade(0.7, [&frame])

Uses the shared definitions for this lesson's figures.

The pieces are only moved, never stretched, so at every stage the row has exactly the area of the circle. What changes is its shape. The bottom edge of the row is made of the curved sides of the sectors that point down, which is half of them, so its length along the bumps is half the circumference, $\frac{1}{2}C = \pi r$. The top edge is the other half. The slanted ends are radii, so the row is about $r$ tall. As the number of sectors grows, the bumps flatten and the ends stand up straighter, and the readouts in the figure show the width and height settling toward $\pi r$ and $r$.

A rectangle of width $\pi r$ and height $r$ has area $\pi r \cdot r = \pi r^2$.

You might object that the row never becomes a rectangle. With 64 sectors it has 32 small bumps along each edge, and with a million sectors it would have half a million. That is correct, and it is the same objection as the slivers. The picture shows what the answer must be. It does not yet show that no small discrepancy survives.

Trapping the area between two polygons

To close the gap we need to control the slivers, and the way to do that is to trap the circle between two shapes with straight sides whose areas we can compute exactly. We did this once already, with the two squares. Squares have only 4 sides, and the idea is to use polygons with more.

Mark $n$ equally spaced points on the circle and join them in order. This gives a regular polygon inscribed in the circle. It is made of $n$ identical triangles with their tips at the center $O$: these are the sectors with their slivers cut off. Enlarging that polygon from the center until the midpoints of its sides touch the circle gives a regular polygon circumscribed about the circle. The circle lies between them.

Regular polygons inside and outside a circle of radius $r$, as the number of sides grows from 4 to 64. Their areas, shown in units of $r^2$, close in on the same value from below and from above.
Monocurl source
let R = 1.5
let O = [-1.55, 0, 0]
let Trap = |n| {
    let k = to_int(round(n))
    let inner = ring_pts(O, R, k)
    let side = norm(inner[1] - inner[0])
    let h = norm(0.5 * (inner[0] + inner[1]) - O)
    let outer = ring_pts(O, R * R / h, k)
    let low = 0.5 * k * side * h / (R * R)
    let high = 0.5 * k * side * R / h / R
    return [
        fill{tint(PLUM, 0.25)} stroke{PLUM, 3} Polygon(outer),
        center{O} fill{tint(AZURE, 0.3)} stroke{AZURE, 3} Circle(R, 128),
        fill{tint(LEAF, 0.4)} stroke{LEAF, 3} Polygon(inner),
        center{[2.75, 1.05, 0]} scale{1.25} color{INK} Number(k, 0),
        center{[2.45, 0.0, 0]} scale{1.25} color{PLUM} Number(high, 4),
        center{[2.45, -1.2, 0]} scale{1.25} color{LEAF} Number(low, 4)
    ]
}
mesh labels = [
    center{[2.05, 1.05, 0]} Cap("sides:", 0.78),
    center{[2.45, 0.5, 0]} Cap("outer polygon", 0.76, PLUM),
    center{[2.45, -0.7, 0]} Cap("inner polygon", 0.76, LEAF),
    center{[2.45, -1.75, 0]} Note("areas in units of r²", 0.72)
]
mesh trap = Trap(n: 4)

slide "squeeze"
    play Wait(1.2)
    trap.n = 64
    play Lerp(7, [&trap], |u| u ^ 2.2)
    play Wait(2)

Uses the shared definitions for this lesson's figures.

Here are the numbers from that animation for a few values of $n$, in units of $r^2$.

sides $n$inner polygonouter polygon
42.00004.0000
82.82843.3137
163.06153.1826
643.13653.1441
2563.14133.1418

The first row is the two squares. Each later row is a tighter trap, and by 256 sides the area of the circle is pinned between $3.1413\,r^2$ and $3.1418\,r^2$. The two columns are plainly heading for the same number. To find out what it is we need formulas for the two areas.

Pause and try

The inner polygon is made of $n$ identical triangles with their tips at $O$. Let $s$ be the length of one side of the polygon and $h$ the height of one of these triangles, measured from $O$ to the middle of the side. Write the area of the inner polygon in terms of its perimeter $p = ns$ and $h$. Then use the Pythagorean theorem to relate $h$, $s$ and $r$.

Show answerHide answer

Each triangle has base $s$ and height $h$, so its area is $\frac{1}{2}sh$, and the polygon has area $n \cdot \frac{1}{2}sh = \frac{1}{2}ph$. For the second part, the height from $O$ splits the triangle into two right triangles, each with hypotenuse $r$ (a radius) and legs $h$ and $s/2$. So $h^2 + (s/2)^2 = r^2$. When the side $s$ is short, $h$ is very nearly $r$.

The answer to that exercise has the same form as our estimate $\frac{1}{2}Cr$, with the perimeter of the polygon in place of the circumference and $h$ in place of $r$. That is the whole mechanism, and we can now state the result and prove it.

Each part of the proof is something from the pictures made exact. The triangles of the inscribed polygon are the sectors without their slivers, and the triangles of the circumscribed polygon are the sectors with a little extra. The slivers are whatever lies between, and the two bounds say that their total area is less than the gap between the bounds, which vanishes. The use of the Pythagorean theorem is the precise form of “the row is about $r$ tall”.

Some things were used without proof. The argument leans on the idea of quantities that “close in on” a value, which is the idea of a limit, and a full treatment defines it exactly and checks the rules used here, such as the fact that if $p_n$ approaches $C$ and $h_n$ approaches $r$ then $p_n h_n$ approaches $Cr$. It also assumes that the perimeters $p_n$ settle on a value $C$ in the first place, that a region with a curved edge has a definite area at all, that a shape contained in another has the smaller area, and that enlarging a figure from a point multiplies all its lengths by the same factor. The first three are settled in calculus and the last belongs to the study of similar figures. The geometric idea, trapping the circle between inscribed and circumscribed polygons, is Archimedes’, from his Measurement of a Circle, written in the third century BC.

A second way to cut: rings

A different way of cutting leads to the same formula. Sectors came from cutting along radii. The other natural way to cut a circle is into thin rings around the center, like the rings of a tree.

A thin ring at distance $x$ from the center has length about $2\pi x$, the circumference of a circle of radius $x$. Cut it and straighten it out, and it becomes a thin strip of that length. Do this to every ring and stack the strips in order.

Pause and try

Before watching the animation, predict the shape of the stack. The ring at distance $x$ from the center becomes a strip of length $2\pi x$. How long are the strips from the very center and from the outer edge, how tall is the whole stack, and what is its area?

Show answerHide answer

The strip from the center has length close to 0 and the one from the edge has length $2\pi r$. In between, the length $2\pi x$ grows in proportion to $x$, so the stack widens at a steady rate: it is a triangle. Its base is $2\pi r$ and its height is the combined thickness of the rings, $r$. Its area is $\frac{1}{2} \cdot 2\pi r \cdot r = \pi r^2$.

A disc is cut into thin rings. Each ring is cut open and straightened into a strip whose length is its circumference. Stacked in order, the strips form a triangle with base $2\pi r$ and height $r$.
Monocurl source
let R = 1.1
let N = 12
let D = R / N
let HUB = [0, 1.0, 0]
let TIP = [0, -0.5, 0]
let Band = |rho, s| {
    let theta = max(TAU * (1 - s), 0.0008)
    let rc = TAU * rho / theta
    let mid = lerp(HUB - [0, rho, 0], TIP - [0, rho, 0], s)
    let phis = sample(-theta / 2, theta / 2, 56)
    let edge = |off| map(phis, |phi| mid + [(rc + off) * sin(phi), rc - (rc + off) * cos(phi), 0])
    let col = lerp(tint(AZURE, 0.3), tint(AZURE, 0.95), rho / R)
    return fill{col} stroke{PAPER, 1} Polygon(flatten([edge(D / 2), reverse(edge(-D / 2))]))
}
let Rings = |u| block {
    for (i in range(0, N)) {
        let prog = smooth(clamp(0, u * 2.2 - 1.2 * (N - 1 - i) / (N - 1), 1))
        . Band((i + 0.5) * D, prog)
    }
}
mesh ghost = [
    center{HUB} fill{tint(SLATE, 0.08)} stroke{MIST, 2.5} Circle(R, 96),
    Seg(TIP + [-PI * R, -R, 0], TIP + [PI * R, -R, 0], MIST, 2.5)
]
mesh rings = Rings(u: 0)
mesh labels = []

slide "unroll"
    play Wait(1)
    rings.u = 1
    play Lerp(6, [&rings], linear)
    labels = [
        Outline([TIP, TIP + [-PI * R, -R, 0], TIP + [PI * R, -R, 0]], LEAF, 3.5),
        Name("2\pi r", TIP + [0, -R - 0.32, 0], 0.9, LEAF),
        Seg(TIP + [2.3, 0, 0], TIP + [2.3, -R, 0], LEAF, 3),
        Seg(TIP + [0.15, 0, 0], TIP + [2.3, 0, 0], MIST, 2),
        Name("r", TIP + [2.55, -0.4, 0], 0.9, LEAF),
        Seg(HUB, HUB + R * dir(0), SLATE, 3),
        Name("r", HUB + [0.5 * R, 0.25, 0], 0.9, SLATE),
        center{[-2.45, 1.45, 0]} Note("area of the triangle", 0.78),
        Name("\frac{1}{2}\cdot 2\pi r\cdot r", [-2.45, 0.75, 0], 1.0, LEAF),
        center{[2.45, 1.45, 0]} Note("area of the disc", 0.78),
        Name("\pi r^2", [2.45, 0.75, 0], 1.25, INK)
    ]
    play Fade(0.7, [&labels])
    play Wait(2)

Uses the shared definitions for this lesson's figures.

The innermost rings are short and the outermost is the longest, with length $2\pi r$. Because the length of a ring, $2\pi x$, is proportional to its distance $x$ from the center, the ends of the strips line up along two straight lines, and the stack is a triangle. Its base is the outer circumference $2\pi r$, and its height is the total thickness of all the rings, which is $r$. The area of a triangle is half the base times the height:

$$ \tfrac{1}{2} \cdot 2\pi r \cdot r = \pi r^2. $$

This is again $\frac{1}{2}Cr$: half the circumference times the radius. With sectors, half the circumference became the width of a rectangle of height $r$. With rings, the whole circumference became the base of a triangle of height $r$. Two different dissections lead to the same expression.

As a proof, the ring picture is a sketch, at the same stage the sector picture was in before we trapped the circle between polygons. A straightened ring is not exactly a rectangular strip, since its inner edge is slightly shorter than its outer edge, and the stack has a staircase edge that only approximates the sloping side of the triangle. Both discrepancies shrink as the rings get thinner. Making that exact is one of the first applications of integral calculus, and it is the standard way the formula is derived there.

Using the formula

Where the formula stops working

The theorem is about circles in a flat plane, and flatness was used when we took for granted that the circumference is proportional to the radius. On a curved surface it is not. Take the circle on a globe consisting of all points at a fixed walking distance from the north pole, and let that distance be a quarter of the way around the globe, so that the circle is the equator. If the globe has radius $R$, the walking radius is $r = \frac{1}{2}\pi R$ and the region enclosed is the northern hemisphere, with area $2\pi R^2 \approx 6.28\,R^2$. The flat formula $\pi r^2$ would predict $\frac{1}{4}\pi^3 R^2 \approx 7.75\,R^2$. A circle on a sphere encloses less area than a flat circle of the same radius, and its circumference is shorter too.

Looking back

The difficulty was that area is defined with squares and a circle has no straight sides. We got past it by cutting the circle into many pieces, each of which is nearly a triangle, and adding up. The formula showed itself immediately as $\frac{1}{2}Cr$. The real work was in showing that “nearly” costs nothing, and for that we trapped the circle between two polygons and watched the trap close.

This pattern, in which a curved shape is cut into many nearly straight pieces, the pieces are added, and the error is shown to vanish as the pieces shrink, is the central method of integral calculus. Archimedes used it for the circle some two thousand years before calculus existed.

Check yourself

A circular pond has a circumference of $20\pi$ meters. What is its area?

Problems

Problem 1

Find the area of a circle of radius 5.

Show solutionHide solution

$A = \pi \cdot 5^2 = 25\pi \approx 78.54$. Check: it lies between $2r^2 = 50$ and $4r^2 = 100$.

Problem 2

A circular table is 14 units across. Find its area.

Show solutionHide solution

“Across” is the diameter, so $r = 7$ and $A = \pi \cdot 7^2 = 49\pi \approx 153.94$ square units.

Problem 3

A circle has area 50. Find its radius.

Show solutionHide solution

From $\pi r^2 = 50$ we get $r^2 = 50/\pi \approx 15.915$, so $r \approx 3.99$. Check: $\pi \cdot 3.99^2 \approx 3.1416 \cdot 15.92 \approx 50.0$.

Problem 4

Which is more pizza: one pizza 16 inches across, or two pizzas each 11 inches across?

Show solutionHide solution

The radii are 8 and 5.5 inches. The large pizza has area $\pi \cdot 8^2 = 64\pi \approx 201.1$ square inches. Each small one has area $\pi \cdot 5.5^2 = 30.25\pi$, so two have $60.5\pi \approx 190.1$ square inches. The single large pizza is more, by $3.5\pi \approx 11$ square inches, even though the two small ones have a combined width of 22 inches. Area goes with the square of the width.

Problem 5

A slice of pie is a sector of a circle of radius 6 with an angle of 60° at its tip. Find its area, and explain why the method is valid.

Show solutionHide solution

A full turn is 360°, so six slices of 60° make up the whole circle. They are identical, since each can be rotated onto the next, so each has one sixth of the total area: $\frac{1}{6} \cdot \pi \cdot 6^2 = 6\pi \approx 18.85$. In general a sector with angle $\theta$ degrees has area $\frac{\theta}{360} \pi r^2$. For angles that divide 360° evenly this is the same argument, and for other angles it follows by cutting the circle into very fine equal sectors and counting how many fall within the angle.

Problem 6

A circle is drawn inside a square so that it touches all four sides. What fraction of the square does it cover? Does the answer depend on the size of the square?

Show solutionHide solution

If the circle has radius $r$, the square has side $2r$ and area $4r^2$, and the circle has area $\pi r^2$. The fraction is $\frac{\pi r^2}{4r^2} = \frac{\pi}{4} \approx 0.785$, about 78.5%. The $r^2$ cancels, so the fraction is the same for every size.

Problem 7

A polygon (not necessarily regular) is circumscribed about a circle of radius $r$: every one of its sides touches the circle. Show that its area is $\frac{1}{2}Pr$, where $P$ is its perimeter. You may use the fact that a radius drawn to the point where a side touches the circle is perpendicular to that side.

Show solutionHide solution

Join the center $O$ to every corner of the polygon. This cuts the polygon into triangles, one for each side, each with its tip at $O$ and one side of the polygon as its base. The height of such a triangle is the perpendicular distance from $O$ to that side. The radius to the point of contact is perpendicular to the side, so that distance is $r$. A triangle with base $b$ therefore has area $\frac{1}{2}br$. Adding over all the sides, with bases $b_1, b_2, \dots, b_k$,

$$ \tfrac{1}{2}b_1 r + \tfrac{1}{2}b_2 r + \dots + \tfrac{1}{2}b_k r = \tfrac{1}{2}(b_1 + b_2 + \dots + b_k)\,r = \tfrac{1}{2}Pr. $$

So every polygon wrapped around a circle satisfies the same relation as the circle itself, area equals half the perimeter times $r$. The circle’s formula $A = \frac{1}{2}Cr$ is the limiting case.

A circle of diameter d with two staircase paths drawn around it, one with 3 steps in each quarter and one with 12. Each staircase has total length exactly 4d, however fine its steps.
A circle of diameter $d$ with two staircase paths drawn around it, one with 3 steps in each quarter and one with 12. Each staircase has total length exactly $4d$, however fine its steps.
Monocurl source
let R = 1.5
let Stair = |O, m| {
    var pts = []
    for (q in range(0, 4)) {
        for (i in range(0, m)) {
            let t0 = i * PI / 2 / m
            let t1 = (i + 1) * PI / 2 / m
            pts .= O + turned(R * dir(t0), q * PI / 2)
            pts .= O + turned([R * cos(t0), R * sin(t1), 0], q * PI / 2)
        }
    }
    var total = 0
    for (i in range(0, len(pts))) {
        total = total + norm(pts[mod(i + 1, len(pts))] - pts[i])
    }
    return [
        center{O} fill{tint(AZURE, 0.3)} stroke{AZURE, 3} Circle(R, 128),
        Outline(pts, ROSE, 3),
        center{O + [0, -R - 0.42, 0]} Math(str_join(["\text{length} = ", to_string(total / (2 * R), 2), "\,d"]), 0.82, ROSE)
    ]
}
mesh left = Stair([-1.9, 0.2, 0], 3)
mesh right = Stair([1.9, 0.2, 0], 12)

Uses the shared definitions for this lesson's figures.

Problem 8

Here is an argument that $\pi = 4$. Draw a square around a circle of diameter $d$. Its perimeter is $4d$. Fold each corner inward into a step that touches the circle, as in the figure above. The staircase still has length $4d$, because every horizontal piece and every vertical piece is still there, only moved. Repeat with finer and finer steps. The staircases hug the circle more and more closely, so in the end the circle has length $4d$, and $\pi = C/d = 4$. (a) What is wrong with this argument? (b) Our proof of the area formula also used shapes that close in on a circle. Why is it not open to the same objection?

Show solutionHide solution

(a) Every staircase does have length $4d$, and the staircases do get close to the circle in the sense that every point of a staircase is near the circle. What fails is the unstated step “if curves get close to a curve, their lengths get close to its length”. That is false. A staircase stays jagged at every scale: it is always made of horizontal and vertical pieces, so it never runs in the direction of the circle, and a wiggly path can stay very near a smooth one while being much longer. Length depends on direction as well as position. This is why the circumference is defined using inscribed polygons, whose sides join points of the circle directly.

(b) The area proof never claimed that nearby shapes have nearly equal measures. It used containment: the inscribed polygon is inside the circle and the circle is inside the circumscribed polygon, and a shape contained in another has the smaller area. That gives true inequalities for every $n$, and the conclusion came from both bounds approaching the same value. Containment controls area. It does not control length, since a region can sit inside another and have a much longer boundary, as the staircases show. Indeed the staircase regions do give the right area: they contain the circle and shrink onto it, and their areas approach $\pi r^2$.

Shared definitions used by this lesson's figures
# 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 dir = |th| [cos(th), sin(th), 0]
let rad = |d| d * PI / 180
let Name = |txt, pos, size = 0.8, col = INK| center{pos} Math(txt, size, col)
let ring_pts = |c, r, n| map(sample_clopen(0, TAU, n), |t| c + r * dir(t))
let turned = |p, angle| [p[0] * cos(angle) - p[1] * sin(angle), p[0] * sin(angle) + p[1] * cos(angle), 0]
# a circle of radius r cut into n sectors. at s = 0 they form the circle at `from`,
# at s = 1 they stand in a row centered at `to`, pointing alternately up and down
let Sectors = |n, s, r, from, to| {
    let k = to_int(n)
    let w = TAU / k
    let half = r * sin(w / 2)
    let apex_y = r * cos(w / 2) / 2
    let local = block {
        . [0, 0, 0]
        for (phi in sample(PI / 2 - w / 2, PI / 2 + w / 2, to_int(max(3, 96 // k)))) {
            . r * dir(phi)
        }
    }
    return block {
        for (i in range(0, k)) {
            let start_angle = (i + 0.5) * w - PI / 2
            let base = PI * mod(i, 2)
            let end_angle = base + TAU * round((start_angle - base) / TAU)
            let angle = lerp(start_angle, end_angle, s)
            let apex_end = to + [(i - (k - 1) / 2) * half, (2 * mod(i, 2) - 1) * apex_y, 0]
            let apex = lerp(from, apex_end, s)
            let col = [AZURE, EMBER][mod(i, 2)]
            . fill{tint(col, 0.55)} stroke{PAPER, 1} Polygon(map(local, |p| apex + turned(p, angle)))
        }
    }
}