Fractal Program Synthesis

• Fractal Program Synthesis is the algorithmic extraction of recursive, symbolic rules from finite visual fractal examples using frameworks like IFS and L-systems.
• It integrates mathematical formalisms with computer vision and neural-symbolic reasoning, employing differentiable rendering and strategic restarts to enhance accuracy.
• Its practical applications span AI diagnostics, procedural content generation, and scientific modeling while addressing challenges in multi-branch recursion and code fidelity.

Fractal program synthesis is the algorithmic reconstruction or discovery of symbolic generative rules from finite (often visual) exemplars of fractal structure. The goal is typically the extraction of representations—such as Iterated Function Systems (IFS) or L‐systems—that explain the recursive, self-similar pattern and allow for synthesis of the fractal at arbitrary scale or resolution. This task is foundational in mathematical reasoning, visual abstraction, and model interpretability, spanning intersections between symbolic AI, evolutionary computation, program synthesis, and vision-language modeling.

1. Mathematical Formalisms Underlying Fractal Structure

Self-similar fractals admit concise symbolic descriptions as attractors of recursive transformation systems, most prominently the Iterated Function System framework. An IFS over a compact $S \subset \mathbb{R}^d$ is defined by a finite set of contractive affine maps $\{f_i\}_{i=1}^m$: $K = \bigcup_{i=1}^{m} f_i(K)$ where each $f_i(x) = s_i R_i x + t_i$ with $0 < s_i < 1$ (contraction), $R_i \in SO(d)$ (rotation), and $t_i \in \mathbb{R}^d$ (translation). Banach’s fixed-point theorem guarantees a unique non-empty compact attractor $K$ for contractive systems.

Fractal synthesis endeavors to infer such symbolic triples from either visual (image) or string data. For L-systems, the generative grammar recursively rewrites nonterminal symbols (typically “F” for forward-draw) using production rules mapped from a genotype vector, producing a string whose limit under infinite expansion yields the target fractal curve. The fractal (box-counting) dimension admits closed-form computation for many D0L-systems: $D = \frac{\log N}{\log d}$ where $N$ is the count of “draw” commands and $d$ the end-to-end displacement per generator string.

2. Fractal Program Synthesis Pipelines

Fractal program synthesis can be instantiated in several computational pipelines:

Visual-to-code pipelines (FractalBench (Ondras et al., 9 Nov 2025)) challenge models to infer Pythonic, executable code from fractal images. The pipeline encompasses:

• Multimodal prompting: Model receives a rendered fractal (e.g., 1024×1024 mask) and a prompt (“Write MinimalTurtle code to draw this fractal” or variants emphasizing recursion or reasoning).
• Code generation: Output is a Python function implementing recursive drawing logic (e.g., koch(turtle, length, depth)), relying on a minimal turtle-graphics API (move, turn, goto, etc.).
• Objective evaluation: Code is executed to generate a new binary mask, which is compared against ground truth via intersection-over-union (IoU ≥ 95% considered correct).
• Metrics: Fraction of code that runs without error (runnable%), and percentage of runnable code that achieves semantic correctness (IoU threshold), with product giving overall pass rate.

Image-to-IFS pipelines (“Chaotic Differentiable Point Splatting” (Djeacoumar et al., 24 Feb 2025)) fit IFS parameters to image data by optimizing the correspondence between the generated fractal point cloud and the observed image, via differentiable rendering and multi-term loss functions.

Evolutionary and grammatical pipelines (“Grammatical Evolution with Restarts” (0805.1696)) use genetic operators (recombination, mutation, fusion, elision) on integer-encoded vectors, deriving L-system production rules that are scored by how closely the resulting curve’s Hausdorff/box-counting dimension matches a target.

3. Benchmark Methodologies and Evaluation

FractalBench provides a contamination-resistant assessment of visual-mathematical reasoning across modern multimodal large-LLMs (MLLMs). Models are evaluated on their ability to regress executable code that reconstructs canonical fractals from images.

• Prompts: Three templates—Direct Code Generation (DCG), Reasoning Then Code (RTC), Recursive Structure Focus (RSF).
• Evaluation: Runnable% (76.1%), Accuracy% (IoU ≥ 95%, 4.2% overall), and per-fractal breakdown (Koch curves: 17–21%, Sierpiński carpet: 18.5%, binary trees: <2%).
• Diagnostic spectrum: Indicates proficiency with geometric transforms (fixed rotation/scaling) but nearly total failure for multi-branch recursion, evidencing a deep limitation in current MLLM mathematical abstraction.

Differentiable fractal inversion (Djeacoumar et al., 24 Feb 2025) is assessed via classic image synthesis metrics (IoU, F1, PSNR, SSIM, LPIPS) over rendered fractals and deep zooms. Comparisons with classic evolutionary, gradient, and super-resolution baselines demonstrate state-of-the-art image fidelity and parameter recovery.

Evolution time analysis (0805.1696) for grammatical methods reveals execution distributions with heavy tails ($\Pr\{T>x\}\sim Cx^{-\alpha}$), with α varying from <1 (infinite mean/variance) to 1–2 (finite mean, infinite variance), motivating aggressive restart strategies.

4. Algorithmic and Optimization Strategies

Hybrid stochastic–gradient optimization (Djeacoumar et al., 24 Feb 2025) alternates Adam-based gradient steps on a multi-scale and perceptual loss function with simulated annealing proposals over the IFS parameter space. This approach mitigates the propensity of pure gradient methods to stall in local minima and the slowness of purely stochastic search.

Restart strategies in evolutionary search (0805.1696)—fixed-threshold, universal (Luby), and geometric (Walsh)—exploit the heavy-tailed discovery time of grammatical evolution. Properly chosen restart policies yield mean runtime reductions by up to an order of magnitude and reduce variance from infinite to finite.

Prompt engineering in MLLMs (Ondras et al., 9 Nov 2025) yields surprising results: direct code generation (DCG) prompts outperform those requiring explicit multi-step mathematical reasoning for fractal synthesis accuracy, suggesting that increased cognitive load via verbose analysis does not translate to numerical/structural correctness in code.

5. Empirical Gaps and Failure Modes

A striking and consistent finding is the syntactic–semantic gap: a vast majority of model outputs produce runnable code that draws recursively, yet only a minority implement the correct IFS parameterization. For instance, MLLMs often output code that renders finite chains or loops with qualitatively correct local geometry (correct angle, segment-lengths) but fail to propagate scale, orientation, or expansion parameters across recursive calls—especially for exponentially branching structures like tree fractals. This inability to encode or maintain independent state for each recursion branch results in degenerate figures (single zigzag lines rather than full trees).

In differentiable inversion, the energy landscape exhibits numerous local minima with attractors “statistically” matching the target image but not corresponding exactly to the generating code, especially when fitting fractals with ambiguous or noisy self-similar hierarchies.

For evolutionary pipelines, the algorithm can stall at suboptimal L-systems, with the probability of rapid success balanced by a heavy right tail of extremely long runs unless managed by restarts.

6. Practical Applications and Illustrative Examples

Typical application domains are:

• Visual reasoning and AI diagnostics: FractalBench isolates vision-to-symbolic program synthesis, with code correctness providing a contamination-resistant diagnostic for the visual and mathematical abstraction capacity of neural models.
• Fractal code recovery and scientific modeling: Differentiable point-splatting methods enable automatic extraction of symbolic Render code from single images for graphics, compression, and scientific analysis (e.g., for data-driven discovery of laws in natural structures).
• Procedural content generation: L-system- and IFS-based synthesis is widely applied for scalable procedural textures and geometry in graphics, where synthesis at arbitrary detail from compact rules is essential.

The reconstructed codes for classical examples, such as the Koch snowflake (IFS: four maps, rotation ±60°, scaling 1/3; L-system: F ::= F+F–F+F), can typically be synthesized successfully. For higher-dimensional or complex curves (e.g., quadratic Koch island), evolutionary grammars recover generator strings with matched dimensions.

7. Limitations and Open Research Directions

Fractal program synthesis, as instantiated in the main benchmarks:

• Recovers symbolic codes explaining infinite self-similar structures, but the recovered code may only statistically match the data due to local minima or ambiguity in the mapping from image to code.
• Suffers when modeling real-world textures that embody only approximate or stochastic self-similarity; deterministic IFS or L-system grammars can overfit or misfit such data.
• In its current form, often assumes a fixed number of contractive maps (N) or grammar length; future directions include learning $N$, extending to non-affine or neural maps, and moving beyond 2D geometry.
• Highlights sharp boundaries in the current capabilities of MLLMs: while local geometric heuristics are accessible, abstract recursive reasoning remains a fundamental frontier.

A plausible implication is that further advances in program synthesis, neural-symbolic integration, and prompts sensitive to recursive structure are needed for substantial progress in visual-mathematical abstraction. Fractal program synthesis thus serves as a touchstone challenge for both symbolic and neural approaches aiming to bridge perception and mathematical reasoning.