The Mandelbrot Set — a dart

THE TECHNIQUE iterate · watch for escape · colour by count

For each complex point c, start at z = 0 and iterate z → z² + c. If |z| ever passes 2 it will run to infinity — c escapes, and we colour it by how many steps that took. If it never escapes (up to a cap), c is in the set — painted void. Written in real complex arithmetic, one square and one add per step. live demo

z = 0 repeat: z = z*z + c // one complex square, one complex add if |z| > 2: return step // escaped -- colour = step count return IN_SET // never escaped -- paint void

click to zoom · hover to read c and its escape count

escape count: fast

slow · black = never escaped (in the set)

HISTORY & CREDIT credit where it is due

The internet says ~~Benoit Mandelbrot discovered it~~. Not quite — the set is named for him, and he made it famous, but the first picture was drawn by two other mathematicians two years before his. Credit splits three ways. cited

1905–1920s · Pierre Fatou & Gaston Julia (France) — found the iteration theory of z²+c long before anyone could see it. The bedrock.
1978 · Robert W. Brooks & Peter Matelski — first defined and drew the set, in a study of Kleinian groups. The first picture. Rarely credited.
1 March 1980 · Benoit Mandelbrot at IBM’s T. J. Watson Research Center — first visualised it in detail and brought it to the world.
1985 · Adrien Douady & John H. Hubbard — proved its core properties (connectedness) and named it in Mandelbrot’s honour.

So the honest line: Fatou/Julia supplied the math, Brooks & Matelski drew it first (1978), Mandelbrot made it visible and famous (1980), Douady & Hubbard proved it and gave it his name (1985). What is still open: whether the boundary is locally connected (the MLC conjecture) remains unproven. open

RECOMMEND FOR I-13 a rare no-wall dart

Most darts hit a wall in I-13. This one credits its strength. A complex number is just two f64 scalars (re, im), and one Mandelbrot step is pure arithmetic:

z² + c = ( re*re − im*im + cre , 2*re*im + cim )

That uses only + − * — every operator I-13 has. Iteration is recursion, which I-13 has. So the escape test for one point compiles and runs on the real compiler — measured, not asserted:

def esc(I re, I im, I cre, I cim, I n) { if n >= MAX { -> n } if re*re + im*im > 4 { -> n } // |z|² > 4 == |z| > 2 -> esc(re*re − im*im + cre, 2*re*im + cim, cre, cim, n + 1) }

i13 run mandelbrot.i13 => RUN OK · 8196 step(s) · peak stack 7 · call depth 102 escape_count( 0.6, 0.6) = 3 (escapes in 3 steps -- outside) escape_count(-0.5, 0.0) = 100 (hits MAX -- inside the cardioid) escape_count(0.35, 0.35) = 100 (bounded to the cap -- in the set)

The compute is already there. The one wall is output: to render a grid of points you need an array or a canvas to write pixels into — and I-13 has neither. It has no array type at all:

i13 check arr.i13 => arr.i13:1:11 E0001 unexpected character `[` (no array literal) arr.i13:1:19 E0001 unexpected character `]`

Recommend: ADD nothing to the language. No new BinOp, no new alphabet symbol — the escape test is expressible today, and this dart is the counter-example that proves the counted alphabet is not always too thin. The honest gap is I/O, not compute: a whole-image render needs a framebuffer (an array the host can read back, or a pixel-write capability on the host’s side of the channel fence). That belongs to the host, not the 13-symbol core — the same split core.i13 already draws (“I-13 owns the routing law; the host owns I/O only”).
Tradeoff (honest): keeping output in the host preserves the counted-alphabet purity — the price is that I-13 alone computes one point at a time and can only hand back scalar bindings; the picture is assembled outside. For a language whose identity is a counted 12-verbs-plus-I alphabet, that is the right trade: credit the compute, name only the I/O gap.