Pick's Theorem

Take a sheet of graph paper. Pick any set of dots, connect them into a polygon without crossing any lines, and ask: what is the area?

The usual answer involves splitting the shape into triangles, or grinding through a formula with coordinates and cross products. But if every corner of your polygon sits exactly on a dot — a lattice point — there is a shortcut so clean it feels like a magic trick: just count dots.

In 1899, the Austrian mathematician Georg Alexander Pick proved that the area of such a polygon depends on nothing but two counts: how many dots sit strictly inside it, and how many sit on its boundary. No angles, no side lengths, no trigonometry — arithmetic on dots.

Click dots on the grid, in order, to build a simple polygon (no crossing edges). As you go, the demo tallies the interior points $i$, the boundary points $b$, and compares $i + b/2 - 1$ against the true area computed independently with the shoelace formula.

<p class="hint">{{hint_para}}</p>
<svg id="grid" class="grid" viewBox="0 0 320 320"></svg>
<div class="stats">
  <div class="stat"><span class="stat-label">{{lbl_interior}}</span><span class="stat-value" id="val-i">0</span></div>
  <div class="stat"><span class="stat-label">{{lbl_boundary}}</span><span class="stat-value" id="val-b">0</span></div>
  <div class="stat"><span class="stat-label">{{lbl_pick}}</span><span class="stat-value" id="val-pick">–</span></div>
  <div class="stat"><span class="stat-label">{{lbl_shoelace}}</span><span class="stat-value" id="val-area">–</span></div>
</div>
<div class="status" id="status">{{status_start}}</div>
<div class="btns">
  <button id="close" type="button">{{btn_close}}</button>
  <button id="random" type="button">{{btn_random}}</button>
  <button id="reset" type="button" class="ghost">{{btn_clear}}</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.grid { width: 100%; max-width: 320px; height: auto; aspect-ratio: 1 / 1; display: block;
        background: #f7f9fb; border: 1px solid #d7dee5; border-radius: 8px; touch-action: manipulation; }
.dot { fill: #adb1b8; cursor: pointer; }
.dot:hover { fill: #6d7684; }
.dot.vertex { fill: #1d3557; }
.dot.interior { fill: #0a7d33; }
.dot.boundary-extra { fill: #457b9d; }
.poly-line { fill: rgba(29, 53, 87, 0.12); stroke: #1d3557; stroke-width: 2; }
.stats { display: grid; grid-template-columns: repeat(2, 1fr); gap: .5rem; margin: .6rem 0; }
.stat { background: #eef2f5; border-radius: 8px; padding: .4rem .6rem; display: flex;
        justify-content: space-between; align-items: baseline; font-size: .85rem; }
.stat-label { color: #444; }
.stat-value { font: 700 1.05rem ui-monospace, monospace; color: #1d3557; }
.status { font-size: 1rem; font-weight: 600; margin: .5rem 0; min-height: 1.4em; }
.status.ok { color: #0a7d33; }
.status.bad { color: #c92f3c; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

// Code not found

Try a plain square first, then drag in an oddly shaped polygon. However strange the outline, as long as every vertex lands on a dot, the two numbers always agree. Random shapes picks a fresh random polygon so you can watch the identity hold over and over.

Why does something this simple ever work?

• The statement. For a simple polygon with vertices on integer lattice points, $A = i + \dfrac{b}{2} - 1$, where $i$ is the number of lattice points strictly inside and $b$ is the number of lattice points on the boundary (including all vertices).
• One proof idea: triangulate and add. Any lattice polygon can be cut into triangles whose vertices are all lattice points. Each such triangle has area exactly $\tfrac{1}{2}$ if and only if it contains no extra lattice point — and every lattice triangle can be split down to that minimal case. Summing areas over the triangulation, and separately tracking how many triangles meet at each interior versus boundary point, collapses into exactly $i + b/2 - 1$. A cleaner modern route uses Euler's formula $V - E + F = 2$ on the triangulated polygon, converting a counting argument about vertices, edges and faces directly into the area identity.
• Why "lattice" matters. The formula is exact only because coordinates are integers: the area of the smallest possible lattice triangle is pinned at $\tfrac12$, which is what anchors the whole counting argument. Move a single vertex off the grid and the identity simply has nothing to attach to.
• It does not survive in 3D. The natural guess — some formula in interior and boundary lattice points for polyhedra — is false. The Reeve tetrahedron, with vertices at $(0,0,0)$, $(1,0,0)$, $(0,1,0)$ and $(1,1,r)$ for integer $r$, has no interior or boundary lattice points beyond its four corners for any $r$, yet its volume grows with $r$. Same dot counts, different volumes — Pick's theorem is a genuinely two-dimensional phenomenon.

The reason a schoolyard dot-counting trick deserves real study is that it is an exact combinatorial identity, not an approximation — the kind of clean structural fact that convex hull algorithms and triangulation routines quietly lean on.

An exact formula connecting area to integer counts turns out to be more than a curiosity:

• Computational geometry. When a polygon's vertices are known to be integer coordinates (pixel grids, raster maps, CAD on a grid), Pick's theorem gives an alternative, purely combinatorial way to cross-check an area computed by the shoelace formula or during triangulation.
• Image processing and GIS. Counting pixels inside and on the outline of a digitized region is a natural, robust way to estimate area on a raster grid — exactly Pick's setup.
• Number theory and combinatorics. Pick's theorem is a gateway to deeper results, such as Ehrhart polynomials, which count lattice points inside integer dilations of a polytope in any dimension and encode area/volume information in their coefficients.
• Teaching geometric reasoning. Because it reduces a continuous quantity (area) to discrete counting, Pick's theorem is a favorite way to introduce students to the interplay between combinatorics and geometry.

It is a small, self-contained example of a theme that runs through algorithm design: sometimes an exact discrete count is easier — and more reliable — than a continuous measurement.

Pick's theorem turns a question about continuous area into a question about counting discrete dots — and gets the exact answer every single time, for every lattice polygon, no matter how twisted. That is a rare kind of elegance: no approximation, no calculus, just $i + b/2 - 1$.

It is also a reminder that exactness can be fragile: the same identity that holds perfectly on a 2D grid has no clean analogue in 3D. Sometimes a beautiful structural fact is beautiful precisely because of where it lives — much like the discrete, combinatorial reasoning behind convex hull constructions.