The Mandelbrot Set

History

Benoit Mandelbrot, at IBM, first generated crude printer plots of the set that now bears his name in 1978–1980, building on Fatou and Julia’s earlier work. Higher-resolution images by Heinz-Otto Peitgen and Peter Richter through the early 1980s turned the set into an unlikely public sensation. The name itself was coined not by Mandelbrot but by Adrien Douady and John Hubbard, in his honour.

Construction

Pick a point $c$ in the complex plane, and iterate the same rule as the Julia chapter — but starting from $z_0=0$ every time, with $c$ itself now the thing that varies from pixel to pixel:

Two concrete examples before the formal definition. Take $c=0$: every iterate is $0^2+0=0$, forever — bounded, so $c=0$ is in the set. Now take $c=1$: $z_1 = 0^2+1=1$, $z_2=1^2+1=2$, $z_3=2^2+1=5$, $z_4=5^2+1=26$ — clearly diverging, so $c=1$ is outside the set. The Mandelbrot set is exactly the collection of every $c$ that behaves like the first example rather than the second:

If $|z_n|$ ever exceeds 2, the orbit is guaranteed to diverge — so every renderer iterates until $|z_n|>2$ (colour by how long that took) or a generous cap (colour it black — presumed in the set). The Fatou–Julia theorem: the filled Julia set $K_c$ is connected iff $c \in M$ — which is why the Mandelbrot set can be read as an index of every Julia set at once, one point per parameter $c$.

From one orbit to the whole parameter plane

Every pixel in the famous image is a tiny dynamical experiment. Dark points survive the iteration cap; coloured points escape, and their colour records how quickly. The boundary is where nearby parameters can have radically different fates.

The right-hand picture answers a different question with the same recurrence. Pick a parameter in the Mandelbrot plane, then inspect the entire world of starting points for that fixed parameter. This is the most useful way to feel the Fatou–Julia connection before meeting its theorem.

Python implementation

Pseudocode first

for each pixel c {
    z = 0
    repeat until |z| > 2 or the limit is reached
        z = z*z + c
    colour c by escape time
}

The executable version keeps the same shape; shared plotting/export details live in fractalfair_helpers.py.

c = grid_of_parameters()
z = np.zeros_like(c)
for i in range(max_iter):
    z[alive] = z[alive]**2 + c[alive]
    escaped = alive & (abs(z) > 2)
    time[escaped] = i + 1
    alive &= ~escaped

escapeTime :: Int -> Complex Double -> Double
escapeTime maxIter c = go 0 0
  where
    go n z | n >= maxIter    = 0
           | magnitude z > 2 = fromIntegral n / fromIntegral maxIter
           | otherwise       = go (n+1) (z*z + c)