Introduction

Newton's method is one of the oldest tricks in numerical mathematics. Given a polynomial like z3z^{3} − 1 = 0, you start with a guess, compute the tangent line to the curve, slide down it to the x-axis, and repeat. In most cases you home in on a root with astonishing speed — the error roughly squares each iteration. Textbooks call it the gold standard of root-finders.

But the method has a secret. If you work in the complex plane — where numbers have both a real and an imaginary part — the three roots of z3z^{3} − 1 are spread at equal angles, like three equally spaced points on a circle. Start from any complex number and iterate Newton's method: you will converge to one of those three roots. The question is — which one?

Color every starting point by the root it eventually reaches, and the picture that emerges is not three clean blobs. The boundaries between them are infinitely tangled — a fractal. Zoom in as far as you like and the same swirling confusion reappears. This is not a quirk of bad programming; it is a rigorous mathematical fact. The borders between the basins of attraction are nowhere predictable, no matter how much you know about where you started.

Try It: Explore the Basins

Each pixel on the canvas is a starting point in the complex plane. Newton's method runs from there until it lands close to one of the three roots of z3z^{3} − 1 = 0 (the cube roots of unity). The pixel is colored red, green, or blue by whichever root it reaches — darker if it takes more iterations to get there.

<p class="hint">Each pixel is a starting point in the complex plane. Newton's method iterates until it converges to one of the three cube roots of z³&nbsp;−&nbsp;1&nbsp;=&nbsp;0. Color = which root; brightness = how fast it got there. Drag to pan, scroll to zoom.</p>
<canvas id="cv" width="380" height="300"></canvas>
<div class="controls">
  <button id="btnReset" type="button">Reset view</button>
  <span class="info" id="info">z³ − 1 = 0 &nbsp;|&nbsp; 3 roots</span>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
canvas { display: block; cursor: crosshair; border-radius: 8px;
         border: 1px solid #cdd9e3; max-width: 100%; touch-action: none; }
.controls { display: flex; align-items: center; gap: .6rem; margin-top: .55rem; flex-wrap: wrap; }
button { font: 600 13px system-ui, sans-serif; padding: .4rem .85rem;
         border: 1px solid #1d3557; background: #1d3557; color: #fff;
         border-radius: 8px; cursor: pointer; }
.info { font-size: .82rem; color: #555; }

// Newton's method on f(z) = z^3 - 1.
// The three roots are 1, ω = e^(2πi/3), ω² = e^(4πi/3).
// For each pixel (starting complex number z0) we iterate:
//   z_{n+1} = z_n - f(z_n)/f'(z_n) = z_n - (z_n^3 - 1)/(3*z_n^2)
//           = (2*z_n^3 + 1) / (3*z_n^2)    [simplified]
// until |z - root_k| < ε or max iterations reached.
// Color by root index; darken by iteration count.

const CV = document.getElementById('cv');
const CTX = CV.getContext('2d');
const W = CV.width, H = CV.height;
const MAX_ITER = 60;
const TOL = 1e-6;

// The three cube roots of unity in the complex plane.
const ROOTS = [
  { re: 1,      im: 0 },
  { re: -0.5,   im:  Math.sqrt(3)/2 },
  { re: -0.5,   im: -Math.sqrt(3)/2 }
];
// Base colors for each root (RGB)
const COLORS = [
  [220, 60,  60],   // red
  [60,  180, 80],   // green
  [60,  100, 220]   // blue
];

// View state: centre (cx,cy) in complex plane, scale (units per pixel)
let cx = 0, cy = 0, scale = 2.4 / Math.min(W, H);

function cmul(a, b) { return { re: a.re*b.re - a.im*b.im, im: a.re*b.im + a.im*b.re }; }
function cadd(a, b) { return { re: a.re+b.re, im: a.im+b.im }; }
function csub(a, b) { return { re: a.re-b.re, im: a.im-b.im }; }
function cabs2(z)   { return z.re*z.re + z.im*z.im; }
function cdivReal(z, r) { return { re: z.re/r, im: z.im/r }; }

// Newton step for f(z) = z^3 - 1:  z_new = (2*z^3 + 1) / (3*z^2)
function newtonStep(z) {
  const z2 = cmul(z, z);
  const z3 = cmul(z2, z);
  const num = cadd({ re: 2*z3.re+1, im: 2*z3.im }, { re: 0, im: 0 });
  // num = 2z³ + 1
  const numC = { re: 2*z3.re + 1, im: 2*z3.im };
  const den3 = { re: 3*z2.re, im: 3*z2.im };
  // divide: (a+bi)/(c+di) = ((ac+bd) + (bc-ad)i) / (c²+d²)
  const d2 = cabs2(den3);
  if (d2 < 1e-30) return z; // avoid division by zero near origin
  return {
    re: (numC.re*den3.re + numC.im*den3.im) / d2,
    im: (numC.im*den3.re - numC.re*den3.im) / d2
  };
}

function iterate(re0, im0) {
  let z = { re: re0, im: im0 };
  for (let i = 0; i < MAX_ITER; i++) {
    // Check convergence to each root
    for (let k = 0; k < 3; k++) {
      const d = csub(z, ROOTS[k]);
      if (cabs2(d) < TOL*TOL) return { root: k, iter: i };
    }
    z = newtonStep(z);
  }
  // Didn't converge — assign to nearest root
  let best = 0, bestD = Infinity;
  for (let k = 0; k < 3; k++) {
    const d = cabs2(csub(z, ROOTS[k]));
    if (d < bestD) { bestD = d; best = k; }
  }
  return { root: best, iter: MAX_ITER };
}

function draw() {
  const img = CTX.createImageData(W, H);
  const data = img.data;
  for (let py = 0; py < H; py++) {
    for (let px = 0; px < W; px++) {
      const re = cx + (px - W/2) * scale;
      const im = cy - (py - H/2) * scale;  // y flipped
      const { root, iter } = iterate(re, im);
      const bright = 1 - 0.7 * (iter / MAX_ITER);
      const [r, g, b] = COLORS[root];
      const idx = (py*W + px) * 4;
      data[idx]   = Math.round(r * bright);
      data[idx+1] = Math.round(g * bright);
      data[idx+2] = Math.round(b * bright);
      data[idx+3] = 255;
    }
  }
  CTX.putImageData(img, 0, 0);
}

// Pan via drag
let dragging = false, dragX = 0, dragY = 0;
CV.addEventListener('mousedown', e => { dragging=true; dragX=e.offsetX; dragY=e.offsetY; });
window.addEventListener('mouseup', () => dragging = false);
window.addEventListener('mousemove', e => {
  if (!dragging) return;
  cx -= (e.offsetX - dragX) * scale;
  cy += (e.offsetY - dragY) * scale;
  dragX = e.offsetX; dragY = e.offsetY;
  draw();
});

// Zoom via scroll
CV.addEventListener('wheel', e => {
  e.preventDefault();
  const factor = e.deltaY > 0 ? 1.25 : 0.8;
  // zoom toward mouse position
  const mx = cx + (e.offsetX - W/2) * scale;
  const my = cy - (e.offsetY - H/2) * scale;
  scale *= factor;
  cx = mx - (e.offsetX - W/2) * scale;
  cy = my + (e.offsetY - H/2) * scale;
  draw();
}, { passive: false });

// Touch pan
let lastTouch = null;
CV.addEventListener('touchstart', e => { e.preventDefault(); lastTouch = e.touches[0]; }, { passive: false });
CV.addEventListener('touchmove', e => {
  e.preventDefault();
  const t = e.touches[0];
  cx -= (t.clientX - lastTouch.clientX) * scale;
  cy += (t.clientY - lastTouch.clientY) * scale;
  lastTouch = t;
  draw();
}, { passive: false });

document.getElementById('btnReset').addEventListener('click', () => {
  cx = 0; cy = 0; scale = 2.4 / Math.min(W, H);
  draw();
});

draw();
Result
Console

Notice how, far from the origin, each region is a clean wedge of color. But zoom toward any boundary and the wedges break into infinite tendrils. No matter how close two starting points look, if they sit on opposite sides of the fractal boundary they can land on entirely different roots. That is sensitive dependence on initial conditions — the hallmark of chaos.

The Real Complexity

What makes Newton fractals more than a pretty picture?

  • Proven in 1879. The English mathematician Arthur Cayley was the first to notice that Newton's method on complex cubics produced strange boundaries. His 1879 paper asked which starting points lead to which root — a question that turned out to be far harder than it looked.
  • The Julia set of Newton's method. The boundary between any two basins of attraction is the Julia set of the Newton iteration function N(z) = z − f(z)/f′(z). By a theorem proved rigorously in the 1980s by mathematicians including John Hubbard, this boundary is a fractal — it has a Hausdorff dimension strictly greater than 1, meaning it is too complicated to be a smooth curve but not quite a 2D region.
  • Sensitive dependence. On the fractal boundary, every open disk — no matter how tiny — contains starting points that land on all three roots. There is no "small enough" neighborhood where the outcome is predictable. This is the precise mathematical definition of chaos in the iteration.
  • Computational complexity. Rendering the fractal pixel by pixel is straightforward — each point runs independently — so the picture itself is easy to compute. But deciding which basin a given point belongs to, when it sits near the boundary, requires arbitrarily many iterations. The boundary points themselves never converge at all; they bounce forever among the roots.
  • Connection to deeper chaos. Newton fractals are a special case of the study of iterated rational maps on the Riemann sphere, a field connecting to the Mandelbrot set, the halting problem, and the limits of predictability in dynamical systems.

The punchline is subtle: the algorithm is simple and extremely fast for most starting points, yet for the starting points that sit near the fractal boundary, no finite computation can ever tell you the answer with certainty.

Where It Matters

The fractal structure of Newton's method is not merely aesthetic — it has direct implications for any algorithm that iterates toward a solution:

  • Numerical root-finding. Real engineering and scientific codes use Newton-like iterations. Understanding the fractal basin structure tells engineers which starting guesses are safe and which can unexpectedly jump to the wrong root.
  • Optimization. Gradient descent — the engine of modern machine learning — is closely related to Newton's method. Loss landscapes have their own basins of attraction, and the fractal boundary phenomenon explains why different random starting weights can converge to very different solutions.
  • Stability analysis. In control engineering, whether a feedback system stays stable under perturbations is a basin-of-attraction question. Fractal boundaries mean that "almost stable" and "almost unstable" can be neighbors at arbitrarily fine scales.
  • Basin hopping in chemistry. Finding the lowest-energy configuration of a molecule is a global optimization problem; the energy landscape has fractal-like basins separating local minima.
  • Art and data compression. Iterated function systems — the mathematics behind Newton fractals — were the basis of early fractal image compression algorithms in the 1990s.

Whenever an iterative algorithm can converge to more than one answer, the map of "which starting point leads where" is potentially a fractal. Understanding that map is the difference between a reliable solver and a chaotic one.

Conclusion

Newton's method is a 350-year-old formula for solving equations, and for most starting points it is as reliable as clockwork. Yet color the complex plane by which root each point reaches and you get one of the most tangled objects in mathematics — a fractal boundary where the outcome is genuinely, provably unpredictable, no matter how precisely you know your starting point.

That is the lesson Newton fractals teach: simple rules do not guarantee simple outcomes. The same iteration that converges in five steps from one point may bounce chaotically from a point micrometers away. The boundary is not an artifact of numerical imprecision; it is infinitely complex in the mathematical ideal.

If you want to understand why optimization is hard, or why tiny rounding errors can send a simulation off course, start here — with a picture of three colored wedges that, on closer inspection, never actually meet cleanly at all.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/newton-fractals/Content licensed under CC BY-NC 4.0.