Introduction to Fractals

In 1975 Benoit Mandelbrot needed a word for a class of shapes that classical geometry had mostly ignored: sets that are too irregular for the smooth lines and circles of Euclid, yet not merely “random noise” either — shapes with structure at every scale. He coined fractal from the Latin fractus, meaning broken or fractured. The name stuck; so did the idea. This page is a short tour of what that idea actually is, who spent the better part of a century discovering pieces of it before Mandelbrot named the whole, and the three distinct mechanisms every fractal on this site is built from.

What is a fractal?

Most of the objects on this site share one property: zoom in, and you see (an approximate or exact copy of) the whole again. A branch of a fern looks like a small fern; a piece of a coastline looks like a small coastline; a tiny corner of the Mandelbrot set contains a distorted copy of the entire set. This property is called self-similarity, and it comes in two flavours worth distinguishing from the start:

• Exact self-similarity, produced by an Iterated Function System or an L-system: the whole is a union of smaller, exact (if rotated or reflected) copies of itself.
• Quasi self-similarity, where zoomed-in copies are similar but not identical to the whole — the hallmark of the escape-time fractals later in this site.

Ordinary curves are one-dimensional and ordinary surfaces are two-dimensional — but fractal boundaries often behave as though they have a dimension strictly between the two. For self-similar sets, the similarity dimension makes this precise: if a shape is built from $N$ copies of itself, each scaled down by a factor $r$, its dimension is

$$D = \frac{\log N}{\log(1/r)}$$

The Koch curve is built from $N=4$ copies scaled by $r=1/3$, giving $D = \log 4/\log 3 \approx 1.2619$ — a curve that is “more than a line but less than a plane.”

A short history, and its pioneers

Fractals were not discovered all at once, and not by Mandelbrot. They were assembled, piece by piece, out of what nineteenth- and early twentieth-century mathematicians considered counterexamples — deliberately pathological objects built to break some assumption that seemed obviously true. Only decades later did anyone notice the counterexamples were secretly a single family.

A CENTURY OF “MONSTERS”

The ideas did not arrive in textbook order

Select a milestone. The fair grew from counterexamples, curves, dynamics, biology, and finally computer pictures.

1874Smith 1883Cantor 1890Peano 1904Koch 1915Sierpiński 1918Julia/Fatou 1968Lindenmayer 1975Mandelbrot 1980Pixels

1874

Henry John Stephen Smith

Smith publishes an early nowhere-dense construction years before the middle-thirds set becomes associated with Cantor.

The compact timeline is only the beginning. The dedicated Pioneers of Fractals trail follows the subject as a five-act story — monsters, measurement, dynamics, growth, and synthesis — and links each person directly to the exhibit where their idea becomes mathematics.

Three families, three mechanisms

Everything on this site is generated by one of three distinct mechanisms. They look different in code, they were discovered by different people for different reasons, and each has its own chapters later — but seeing all three side by side here, before any specific fractal, makes every later chapter easier to place.

Iterated Function Systems (IFS)

Before anything else, it’s worth answering a word this book (and mathematics generally) uses constantly without pausing to define: a map. It has nothing to do with geography — a map here just means a function, with a deliberately spatial flavour: a rule that takes every point of a shape and sends it somewhere, possibly shifting it, shrinking or stretching it, rotating it, or several of these at once.

An Iterated Function System is a finite collection of contraction maps $f_1,\dots,f_n$ — maps that specifically shrink whatever you feed them, always making any two points closer together than they started (the “scaled down” panel above). Apply all $n$ maps to a starting shape $S$ and take the union of the results; repeat forever. This converges to a unique attractor $A$, no matter what shape you started from:

An attractor is just the shape this process eventually settles into, regardless of where you begin — the same idea as water finding a drain from anywhere in a sink, or a marble released anywhere in a bowl always ending up at the bottom. Start the same three maps from a triangle, a filled square, or a random round blob, and after only a few steps every one of them is converging toward the same arrangement:

Formally:

$$A = f_1(A) \cup f_2(A) \cup \cdots \cup f_n(A)$$

The name is literal: you iterate a system of functions. The figure below shows one application of three simple contraction maps to a filled triangle — each map shrinks the triangle to half size and places it in a different corner. Do this once and you get three small triangles. Do it forever and you get the Sierpinski triangle.

def build(p1, p2, depth):
    if depth == 0:
        return [p1, p2]
    mid1, mid2 = split_rule(p1, p2)     # where the contraction maps send p1, p2
    return (build(p1, mid1, depth - 1)[:-1]
            + build(mid1, mid2, depth - 1)[:-1]
            + build(mid2, p2, depth - 1))

The Cantor set, Sierpinski triangle, Koch snowflake, dragon curve, and Barnsley fern are all IFS attractors.

L-systems

An L-system (Lindenmayer system) is a string-rewriting grammar: an alphabet, a starting string (the axiom), and production rules that replace each symbol with a longer string, applied simultaneously to every symbol, generation after generation — the same “simultaneous replacement” idea an IFS uses, just written on text instead of geometry. Once the string is expanded, a turtle reads it left to right and draws: move forward, turn left or right, or (for branching shapes) push and pop its position.

def rewrite(axiom, rules, iterations):
    s = axiom
    for _ in range(iterations):
        s = "".join(rules.get(ch, ch) for ch in s)
    return s

def turtle_segments(instructions, angle, step=1.0):
    # F draws forward; +/- turn; [/] push/pop (pos, heading) for branches
    ...

One engine, wildly different pictures, depending only on the axiom and rules you supply: a branching plant with one rule set, a space-filling curve with another.

Escape-time iteration

An escape-time fractal lives in the complex plane. For every point (either a starting value $z_0$, or a parameter $c$, depending on the fractal), iterate a fixed formula — almost always $z_{n+1} = z_n^2 + c$ — and ask: does the resulting sequence, or orbit, stay bounded forever, or does it eventually escape to infinity? Colour each point by the answer, and the boundary between “stays” and “escapes” is a fractal. The name describes exactly this: you are timing how fast an orbit escapes.

z = np.zeros_like(c)
div_time = np.zeros(c.shape)
mask = np.ones(c.shape, dtype=bool)
for i in range(max_iter):
    z[mask] = z[mask] ** 2 + c[mask]
    diverged = np.abs(z) > 2
    div_time[diverged & mask] = i
    mask &= ~diverged

The Newton, Julia, and Mandelbrot sets are all escape-time fractals; only the formula being iterated, and which variable is held fixed, differs between them.

---

That’s the whole toolkit. Every chapter from here on names one specific fractal, gives its history and defining equation, and shows the Python (and Haskell) code that draws it — start with the Cantor Set, the simplest one in the book.