Fractal Structure

Part II of Latent Spaces, continued. After Constructal Geometry.

The fractal is the rule that generates the shape. The shape is what the rule looks like after enough iterations. Everything that follows turns on this distinction.

L-systems

In 1968, Aristid Lindenmayer, a botanist, wanted to model plant growth and invented a formal grammar that turned out to describe fractals. His L-system is three things: an alphabet of symbols, an axiom (the starting string), and production rules that rewrite each symbol into a string of symbols. The system runs by applying all rules simultaneously to every symbol, then repeating.

The simplest tree:

• Axiom: F
• Rule: F → F[+F]F[-F]F

F means draw forward. + means turn left. - means turn right. [ means save your position. ] means return to it.

Iterate once: F[+F]F[-F]F — a stick with two branches. Iterate twice and each F in that string gets replaced by the full rule. Now each branch has sub-branches. Iterate six times: a tree. Ten times: millions of line segments from fifteen characters of grammar.

The Kolmogorov complexity — the minimum description length — is bounded by the rule, not the output. The rule is finite. The output grows exponentially. The ratio goes to infinity. But everything the output contains was already in the rule.

Lindenmayer specified parallel rewriting for a reason. Every symbol gets rewritten at the same time. Every part of the organism grows simultaneously. Sequential rewriting (Chomsky grammars) generates trees too, but not self-similar ones. The parallel application produces self-similarity because the same rule acts at every position at once. Change the application order and you get a different geometry. The simultaneity from parallel rewriting is what makes the recursion scale-free.

Self-similarity as same-rule-at-every-scale

The branch looks like the tree because the branch IS the tree at one iteration fewer. The twig is the branch at one iteration fewer. The leaf cluster is the twig at one iteration fewer. All the way down until the rule runs out of substrate.

This is the recursive second law in formal notation. The same process at every scale produces the same structure at every scale. Convergence across domains — rivers, lungs, lightning — isn't mysterious once you see that L-systems don't care about their substrate. The rule F → F[+F]F[-F]F generates the same geometry whether F means "grow a centimeter of xylem" or "erode a meter of sandstone" or "propagate a millisecond of electrical discharge." The substrate provides the medium. The rule provides the form.

The constructal observation from Post 5 — branching everywhere, in every medium — is what it looks like when the same L-system runs on different alphabets. Bejan named the convergence. Lindenmayer wrote down the grammar that produces it.

Two smoothnesses

Post 5 planted a condition: the recursion requires differentiability at every level. That was about the geometry — the output manifold must be smooth. There may be a second smoothness, deeper, about the process itself.

Geometric smoothness. The L-system rule maps state to next state through rotations, scalings, translations — differentiable maps. The fractal they generate is smooth everywhere except at branch points, where multiple tangent directions converge. Those branch points are where the manifold folds — where two regions of the unfolded space are brought into proximity by the rule's geometry. If the rule involves discontinuities, the fractal breaks. Self-similarity fails at the scale where the discontinuity lives.

Process smoothness. The recursion itself introduces zero new information. Given the current state and the rule, the next state is entirely determined. The conditional Kolmogorov complexity is zero: K(S_n+1 | S_n, R) = 0. No surprisal at any iteration, in Shannon's precise sense. The rule absorbs everything.

This is not trivially true of all deterministic systems. Deterministic chaos is deterministic but not process-smooth — positive Lyapunov exponents mean nearby states diverge exponentially. Small perturbations produce unpredictable changes. L-systems are the opposite: deterministic AND insensitive to perturbation. The process generates no information because the rule already contains all of it.

This is the deeper reason fractals are maximally compressible. It's not just that the rule is short. It's that the iterations add nothing. Every bit of the output was already in the axiom plus the rule. The Kolmogorov complexity is bounded by the rule because the process of iteration has complexity zero.

The two smoothnesses break at the same place. Process smoothness (zero surprisal) guarantees geometric smoothness (differentiability) because a deterministic, information-preserving transformation applied to a smooth initial state cannot produce discontinuities. When one breaks, both break. The scaling range of a fractal is the domain of zero surprisal of its generating rule.

The bounds of real systems

In their pure mathematical form, L-systems are unbounded. The rule applies forever. Zero surprisal at every iteration. Infinite output from finite input. Maximally compressible.

Real systems are bounded. The rule encounters substrate, context, or mechanism that it didn't predict — and at that point, surprisal enters for the first time. New information. The fractal stops.

The specific stop conditions are multiple and system-dependent. A tree's vascular branching follows a smooth rule down below the cellular scale, where the physics changes character — the substrate introduces information the rule doesn't contain. But that's not the only bound. Cell division itself is a context-sensitive L-system: the same cell in a different position differentiates into a different type, eventually producing terminal symbols — fully differentiated cells that have no production rule. And the iteration depth itself may be bounded by mechanism rather than substrate, as telomere shortening bounds cell division independently of whether more branching would be useful.

The abstraction: real fractals operate in a window defined by multiple stop conditions — physical, informational, mechanical — that may be context-dependent and substrate-dependent. Within that window, both smoothnesses hold: the geometry is differentiable and the process generates zero surprisal. At the bounds, new information enters, and the fractal terminates.

The gap between the mathematical L-system (infinite, zero surprisal, maximally compressible) and the real system (bounded, eventually surprising, finite) is the limit of L-system mechanics. The formalism gives you the rule and the infinite unfolding. Reality gives you the window where the rule actually runs.

Walking backward

The recursion runs forward. Axiom, apply rule, apply rule, apply rule. Trunk, branches, twigs, leaves. Walk it backward. Start at a leaf. Which twig does it belong to? Trace the path. Which branch holds the twig? Which limb, which trunk? At every step upward, many details collapse into one. Hundreds of leaves map to one twig. Dozens of twigs map to one branch. A handful of limbs map to the trunk.

This is lossy compression. Each step discards information — which specific leaf, at which specific angle, with which specific area. And each step preserves information — the branching ratio, the divergence angle, the scaling factor. The rule.

The walk from leaf to trunk traces the rate-distortion curve of the fractal. At the leaf level: maximum detail, maximum bits, zero distortion. At the trunk level: minimum detail, minimum bits, maximum distortion. Between them, a stepped tradeoff — at every height along the tree you're at a specific point on the curve, having traded instance-detail for structural compression.

This is coarse-graining in Jaynes' sense. Microstates (individual leaves, each one unique) collapse into macrostates (branches, each one summarizing many leaves). The second law says this is irreversible. You cannot reconstruct which leaf you came from once you're at the branch.

But in a fractal — and only in a fractal — the rule survives the compression. You can't recover the specific leaf. But you can regenerate. Run the rule forward from the branch and new, statistically indistinguishable leaves are generated. The rule contains everything needed to reproduce the structure, because the structure IS the rule iterated. An LLM's weights are a compressed tree. A prompt is a branch point. Inference walks the rule forward — regenerating leaves, not recovering them.

The inverse problem

Walking backward from output to rule is L-system inference — given a tree, find the grammar that generates it. This is computationally hard. NP-hard in general. Given a complex branching structure, the number of candidate rules is vast, and many different rules produce superficially similar geometries.

Yet the walk is what makes the fractal useful. An engineer who sees branching in rivers AND lungs AND lightning is walking backward from three different outputs and noticing that the rules are the same. That's what Bejan did. That's what Post 5 called the constructal observation — the backward walk from multiple instances to a shared rule.

The forward direction generates. The backward direction compresses. Both follow the same path — one adding detail, one stripping it — because the path IS the fractal, and the fractal IS the rule.

The rule at every scale. The compression that preserves it. The walk from specific to general that strips the instance and keeps the pattern. This is mathematics — the geometry of recursive self-similarity made precise through L-systems and Kolmogorov complexity.

What it says about how minds walk backward from experience to understanding — extracting the rule from the instances, compressing a lifetime of specific encounters into the generative principles that survive the compression — is the next question.