Perturbation Rendering

Glossary

See It First

Why Direct Deep Zoom Is So Expensive

The basic Mandelbrot iteration is simple: z_n+1 = z_n² + c, with z₀ = 0. At modest zoom levels, ordinary fixed-width arithmetic and a few hundred iterations per pixel are often enough.

But ultra-deep zooms are a different universe:

• Pixel-to-pixel coordinate differences become extremely small and sensitive to rounding errors.
• Orbits may require tens of thousands of iterations to resolve fine structure.
• Extended finite-precision arithmetic beyond one 64-bit value becomes necessary.

If we run that extended-precision pipeline independently for every pixel, the cost grows rapidly. Each pixel re-discovers essentially the same orbit structure with slightly different parameters.

Perturbation rendering observes that in a deep zoom, pixels in a small tile are clustered tightly around a common parameter c₀. That redundancy is exactly what perturbation exploits.

The Basic Perturbation Idea (and Where Taylor Series Enters)

Pick a reference parameter c₀ near the view center and compute one orbit in CPU double-double arithmetic. For any pixel in the same frame, c is extremely close to c₀, so we can represent the pixel as a small change Δc = c − c₀.

1) Compute the reference orbit once

Z₀ = 0
Z_n+1 = Z_n² + c₀

2) Express each pixel as “reference + correction”

For the pixel parameter c = c₀ + Δc, the true orbit is:

z₀ = 0
z_n+1 = z_n² + c

Write z_n = Z_n + δ_n. Substituting:

z_n+1 = (Z_n + δ_n)² + (c₀ + Δc)

Expand and use Z_n+1 = Z_n² + c₀:

δ₀ = 0
δ_n+1 = 2 Z_n δ_n + δ_n² + Δc

This recurrence is the workhorse form of perturbation. In exact arithmetic it follows algebraically from the original Mandelbrot recurrence—nothing has been approximated or dropped. The numerical approximation in an implementation comes from finite representations of Z_n, δ_n, and their operations.

3) The Taylor-series view: a local sensitivity model

For a fixed iteration index n, the value z_n(c) varies smoothly with c in a neighborhood around c₀. That means you can view z_n(c₀ + Δc) as a Taylor series in the small number Δc:

z_n(c₀ + Δc) = z_n(c₀) + a_1,n Δc + a_2,n (Δc)² + a_3,n (Δc)³ + …

Because z_n(c₀) = Z_n, the perturbation is exactly the “tail” of that series:

δ_n = z_n(c₀ + Δc) − Z_n = a_1,n Δc + a_2,n (Δc)² + a_3,n (Δc)³ + …

When Δc is small and the coefficient growth is controlled, higher powers can initially shrink rapidly. That observation motivates Taylor and series-approximation accelerators. It does not mean that truncation is automatically safe near every boundary point or for every iteration count.

4) A useful analytical coefficient (first order)

A common “Taylor-first” approximation keeps only the first-order term a_1,n Δc, where a_1,n is the sensitivity of the orbit to changes in c at c₀. It advances alongside the reference orbit via:

a_1,0 = 0
a_1,n+1 = 2 Z_n a_1,n + 1

Then the first-order perturbation estimate is:

δ_n ≈ a_1,n Δc

Implementation note: this derivative recurrence explains local sensitivity and is relevant to future series accelerators. The Version 3.0 Infinity Engine does not replace the production pixel recurrence with this first-order truncation; it retains δ_n².

5) Reconstruct the orbit for escape and coloring

For escape tests and smooth coloring formulas, the renderer reconstructs the represented orbit via z_n = Z_n + δ_n and applies the same bailout rule used by a direct per-pixel orbit. Equality is algebraic; the stored values remain finite-precision approximations.

Exact Recurrence vs. Taylor Truncation

When δ_n is very small, the quadratic term δ_n² may be much smaller than 2 Z_n δ_n. A first-order analysis can therefore drop it and study the linearized recurrence:

δ_n+1 ≈ 2 Z_n δ_n + Δc

Series renderers can precompute higher-order coefficients or blocks of linearized work, trading more setup and storage for fewer operations per pixel. Their validity depends on explicit error bounds and reference selection.

• More terms → better accuracy over more iterations, but more work per step.
• Fewer terms → faster per step, but you must re-sync sooner.

Mandelbrot Metal 3.0 takes the conservative production path: every Infinity Engine pixel retains the full nonlinear term. Its speed comes from reference reuse, the Metal execution model, and a fast-to-quad-single precision ladder—not from discarding δ_n².

When Does Perturbation Break Down?

The full recurrence is algebraically exact, but a finite-precision evaluation can become unreliable when cancellation, dynamic range, or perturbation growth overwhelms the active representation. In practice, several things can cause trouble:

• Very long orbits at extreme zoom levels.
• Points near sensitive structures (e.g., close to the boundary of 𝓜).
• Parameters far enough from the reference that Δc or the evolving delta becomes poorly conditioned.

A robust perturbation renderer therefore:

• Monitors delta growth, non-finite values, and glitch indicators.
• Restarts difficult pixels from iteration zero in the quad-single path instead of continuing contaminated fast-path state.
• Can rebase the GPU perturbation state to the represented current orbit without implying a new CPU reference orbit in the middle of that pixel.
• Rejects an unusable Metal completion and hands the request to the established CPU deep renderer.

A committed viewport change may also trigger construction of a fresh CPU reference orbit for the new center. That is distinct from an in-kernel rebase during one pixel’s recurrence.

Why This Matters in Mandelbrot Metal

Perturbation is the central change that moves repeated deep work from a per-pixel CPU path into a Metal-first pipeline while preserving the quadratic map:

• Reference reuse — One double-double orbit supplies shared structure to millions of pixel threads.
• Adaptive GPU precision — Well-conditioned pixels use a fast path; difficult pixels receive quad-single recovery rather than forcing every pixel through the most expensive representation.
• Recovery policy — Restart, rebase, recovery, finite-value checks, and command validation address known failure modes. These checks reduce risk; they are not a proof that every finite-precision pixel is correct.
• Continuous interaction — During a gesture the retained complete image follows the pan or pinch. After commit, completed center-out regions progressively replace the initialized preview; completion is reported after the full current frame reaches presentation.

This architecture is still finite and bounded. Version 3.0 deliberately stops at 10²⁵× while later releases investigate more accurate reference coordinates and stronger series accelerators.

Where You’ll See This in Mandelbrot Metal

Perturbation is not exposed as a user toggle. The Infinity Engine activates automatically when the viewport becomes eligible for deep rendering; the HUD identifies the active quality path as Infinity.

• Full-frame progress
  For deep work, the progress indicator reports the percentage of the requested frame completed—not an internal row count.
• Pan, pinch, and double-tap
  The last complete image moves immediately with the gesture while the engine builds the newly requested fractal behind it.
• Smooth coloring and 3D Look
  Both consume the reconstructed orbit data from the same completed render. 3D Look is shading over a two-dimensional escape field, not a different fractal equation.
• Existing bookmarks
  Legacy bookmark coordinates and visual settings are restored through the same Version 3 viewport and rendering path, subject to the Version 3 scale policy.
• Automatic fallback
  If the Infinity Engine is ineligible, a Metal command fails, or completion validation rejects the result, the established CPU deep renderer takes over without treating a partial image as finished.

Free and Pro use the same numerical engine and have the same zoom fidelity. Pro unlocks the broader creative and workflow feature set; it does not buy a more accurate Mandelbrot calculation.

Render Pipeline: From Full Orbits to Perturbation

Performance at a Glance

The timing corpus used build 548, one sample per Infinity pixel, and High Quality Idle off. Each version ran once in forward order and once in reverse; those two passes do not establish a statistical confidence interval. They are not timings for the build 582 lighting implementation.

A separate historical Earth Elephants comparison matched 420,640 pixels against an all-QS control with zero differing pixels. Agreement with a related control checks adaptive routing; it is not an independent mathematical proof. Current regression evidence and reproduction requirements are documented in Revision 17 of the white paper.

Looking Ahead

Version 3.0 establishes the first production Infinity Engine within a validated 10²⁵× viewport boundary. Later work can extend the architecture without overstating the precision available today:

• Reference-coordinate precision — Preserve more exact viewport information before it becomes the CPU reference parameter and GPU pixel offset.
• Orbit reuse and smarter reference selection — Reuse compatible reference work and minimize perturbation growth across nearby committed views.
• Bounded series acceleration — Investigate Taylor or block-linear approximations only with explicit validity tests and recovery behavior.
• Diagnostics and qualification — Expand deterministic image checks and physical-device coverage before raising the public scale ceiling.

The design goal is not a larger number in the HUD by itself. A future ceiling should rise only when navigation, bookmark restoration, visual continuity, and complete-frame correctness remain trustworthy at that depth.