Library · The Fiddler: Solutions · Chapter 46
Can You Fling the Fractal Darts?
A dartboard is a unit circle (radius ) divided by an Apollonian gasket. The gasket starts from two congruent circles of radius , side by side, tangent to each other and to the rim; then, wherever three mutually tangent circles leave a gap, you draw the circle tangent to all three, for ever, filling in above, below and around the first two. On top of that, every circle on the board, however small, is itself a board of the same kind: a sub-gasket built from two side-by-side circles of half its radius, and so on inside those. A dart’s score is the sum of the areas of every circle it lands inside of or on. What is the most a single dart can score?
The Fiddler, Zach Wissner-Gross, December 5, 2025(original post)
Solution
Aim for the exact centre of the board. The two radius- circles are tangent there, so the dart is on both. Inside the right one, its two radius- children are tangent at its centre , and the left of those children, centred at , passes through the board’s centre too. The same happens inside the left radius- circle, so the centre lies on two radius- circles. Repeating, the centre lies on two circles of radius for every , together with the unit circle. No other circle passes through the centre: the remaining circles of each gasket sit in the gaps between the circles already drawn and touch the two half-size circles only at single points away from the centre, and three circles of a gasket never share a point. The score is
The computation
Build the circles themselves, on the -axis: each circle of radius centred at spawns two children of radius at . Sum the areas (in units of , so ) of every circle that actually contains the board’s centre, pruning any branch that has moved off it. The total is .
from fractions import Fraction as F
import sys; sys.setrecursionlimit(10000)
def score(c, r, depth): # area/pi of centre-covering circles below (c, r)
if depth > 200 or abs(c) > r: return F(0) # off the centre -> prune
return r*r + score(c - r/2, r/2, depth + 1) + score(c + r/2, r/2, depth + 1)
print(float(score(F(0), F(1), 0))) # 1.6667 = 5/3 -> score 5*pi/3
Extra Credit
Suppose each point on the dartboard is equally likely to be hit. On average, what score would a single dart earn?
Solution
A clean identity does the work. Each circle adds its area to the score exactly when the dart lands in it, which happens with probability , so summed over every circle on the board, the board itself included.
Self-similarity. Let for a board of radius . A circle of radius on the board is itself a board, scaled by , so the circles inside it (it included) contribute . Let be the sum of over the circles of the top-level gasket. Every circle on the board is either the board itself or lies within exactly one top-level gasket circle, so
The gasket. Descartes’ circle theorem says that four mutually tangent circles with curvatures (the enclosing circle counted negative) satisfy . So given three, the two circles tangent to all of them have curvatures and with . The board () and the two half-size circles (, ) give : the circles of radius above and below. Each new circle opens three new gaps, and the rule gives the next curvatures: in the gap between the rim, a half-size circle and a third-size circle; between the two half-size circles and a third-size one; and so on. The complex form of the theorem, due to Lagarias, Mallows and Wilks (2002), locates the centres the same way. Summing over all circles converges very fast, since there are only from the four largest: with every circle down to radius included and the rest affecting only the tenth decimal place. Therefore (The source’s extra-credit value is behind its paywall; this is my own.)
The computation
The check throws darts instead of using the identity. It draws one gasket with the Descartes rule (every circle of radius at least ) and confirms that the circles fill almost all of the board. Each dart then scores the board’s own area, finds the gasket circle it landed in, rescales that circle to a fresh board of radius and repeats, adding the areas scaled back down. Darts that fall in a gap too small to have been drawn simply stop scoring there, which lowers the estimate by a negligible amount.
import math, random
# One gasket in the unit board, by Descartes' theorem: (curvature, centre)
OUTER, A, B = (-1, 0j), (2, -0.5 + 0j), (2, 0.5 + 0j)
C1, C2 = (3, 2j/3), (3, -2j/3) # fill the gaps above and below
def fourth(c1, c2, c3, old):
"""The other circle tangent to c1, c2, c3 (old is the one already drawn)."""
k = 2*(c1[0] + c2[0] + c3[0]) - old[0]
z = (2*(c1[0]*c1[1] + c2[0]*c2[1] + c3[0]*c3[1]) - old[0]*old[1])/k
return k, z
circles, gaps = [A, B, C1, C2], []
for C in (C1, C2):
gaps += [((OUTER, A, C), B), ((OUTER, B, C), A), ((A, B, C), OUTER)]
while gaps:
(a, b, c), old = gaps.pop()
d = fourth(a, b, c, old)
if d[0] > 3000: continue # circles of radius below 1/3000
circles.append(d)
gaps += [((a, b, d), c), ((a, c, d), b), ((b, c, d), a)]
circles.sort(key=lambda c: c[0]) # biggest first
print("circles drawn:", len(circles))
print("share of the board they cover: %.4f" % sum(k**-2 for k, _ in circles))
def score(z, depth=0):
"""Score (sum of areas) of a dart at z on a board of radius 1."""
s = math.pi # the board's own circle
if depth > 12: return s
for k, c in circles:
if abs(z - c) <= 1/k: # inside a gasket circle, which is
return s + score((z - c)*k, depth + 1)/k**2 # itself a board
return s
rng = random.Random(5); N = 400_000; tot = tot2 = 0.0
for _ in range(N):
while True:
z = complex(rng.uniform(-1, 1), rng.uniform(-1, 1))
if abs(z) <= 1: break
v = score(z); tot += v; tot2 += v*v
m = tot/N
print("average score: %.4f +- %.4f" % (m, math.sqrt(tot2/N - m*m)/math.sqrt(N)))
It prints
circles drawn: 13964
share of the board they cover: 0.9971
average score: 3.7107 +- 0.0006
agreeing with the boxed value within one standard error.