Skip to main content
2026-10-29

Interpretability Through The Lens of Fractal Plants

17 min read
Mechanistic Interpretability
interpretability mathematics llm ai

We’re now several years into the era where an artificial image, video, or piece of text can be made on command, and it looks startlingly believable. Many people, including people who aren’t in AI research at all, naturally wonder what exactly is the process that lets a sequence of mathematical operations produce such results. And yet, while we can describe the operations in a neural network easily, making the explanation of why they can mimic real-world things satisfying is still a daunting task.

That’s not to say that we haven’t seen considerable progress. In fact, I think the popular narrative that “we have no idea what’s going on inside AI models” is oversold. For example, researchers can identify many layers and nodes in neural networks that correspond to specific behaviors or output features, and there is promise in the method of deliberately steering them to change what a model does. Mapping of more complex circuits is also a developing area, as are sparse auto-encoders for tracking what features a network is identifying.

But the full picture is still much larger than what we understand now. It’s a picture that appears to be much larger than just the sum of its parts. And the view of assigning specific features to individual neurons and then adding them up is useful but consistently seems to be an oversimplification of everything a model does.

The problem in front of the mechanistic interpretability community is tantalizing in a way: there are so many instances where we can isolate very simple and appealing functions in modern neural networks, enough to hope that the whole process can be untangled. Yet there are still walls between us and the point where you can say something like “The model gave this answer because of these values in its various intermediate layers”.

But there was another thing that sent me down a rabbit hole of thinking on this topic. It happened when I was reminded of another way of systematically making surprisingly realistic images that we do understand. And the lessons I think it holds have to do with something I said above: that the full picture of interpreting a network is larger than the sum of its parts. So, what if we could understand how it becomes larger, and why?

Here’s an example of what inspired these thoughts. The image below was generated by math, but not by AI.

Figure 1: A plant made of math

When I recently looked at this “fern” that is made by essentially one mathematical rule, I immediately thought there was a lesson about the larger-scale questions that mechanistic interpretability deals with now. It’s built step by step by iteration procedure called an L-system.

Simplicity Growing Into Complexity

Scientists have long observed that fundamental mathematical patterns appear again and again in the natural world. Some of these phenomena are staples of popular science, e.g. many erroneous claims about the golden ration (and a few true ones) and the self-similar complexity of coastlines. The coastline effect was even the example Mandelbrot used in one of his landmark papers on fractals. In a way, one of the main goals of science is to reduce hugely complex systems to their basic rules.

So consider one of the fundamental patterns in mathematics: recursion. It’s hardly news that many plants grow in a way that is effectively recursive. They follow this particular pattern so much that we usually use the language of plants to describe the math: we talk about “branching” and “trees” as abstract concepts in their own right.

But in the 1960s, the biologist and botanist Aristid Lindenmayer found a very elegant way to express a large number of recursive rules that show up in nature (Lindenmayer 1968). With the real-life phenomena as his starting point, he developed what are called “L-systems”, the initial coming from his name, which can be shockingly simple rules for recursively building a drawing that nonetheless capture enough complexity to feel like drawings of real organic things.

I’ll give a full description of this L-system in the appendix for those who are interested. For now here’s a more visual overview. The first iteration already has all the important structure, and looks like the following image:

Figure 2: The first iteration, with branch points

The whole “fern” is made out of these “bent twig” shapes at varying scales. The one additional thing the L-system involves is rules for adding more scaled copies of the “twig” branching off at different points an in different directions. I’ve put a red dot at each of the branching-off points, then a small blue arrow to indicate the direction in which a new twig will grow. Note that the arrow in the direction that already has a green segment means that a new bent twig is inserted there.

Well, here’s the crucial point I’m focusing on, and the whole reason to bring up this exercise of the fractal plant: The image you just saw contains everything that’s important in the system. The whole organic-looking facsimile of a fern is made out of just the information in the level 1 image with the placeholder dots and arrows.

In the 1960s, it was a striking way of expressing how convincing natural complexity comes from simple rules. But now we live in a world where realistic images based on the world around us can be made on demand. I think it’s worth revisiting this more “analog” (for lack of a better word) way of getting a similar result and seeing what intuition we can get from its deceptive simplicity.

How The “Plant” Actually Grows

Here are the first three iterations. See if you can get a feel for how the pattern evolves.

Figure 3: The first iteration
Figure 4: The second iteration
Figure 5: The third iteration

I don’t know if the effect is the same for everyone, but to my eyes, the third step where it crosses itself is the point where it starts to look like something you could see lying in the grass. On the other hand, if you take another look at the completed image from the start of this post (Figure 1), you can see that at the top, all the branching points along the top at the end of it have exactly the same angles. Of course that’s a consequence of the fact that they all come from the same generation rule, but it slightly takes away from the illusion that this is something natural. And yet, we’re not really primed to notice that right away. The larger structure, which mimics natural plants better, is more important at a glance than the smaller-scale details.

And it turns out, that larger structure is not so hard to create. It “grows” out of simple structure much more quickly than it looks like it should.

Mechanistic Interpretability: Can We See It The Same Way?

This is only a specific case, of course, but emergent complexity in nature is a long-documented phenomenon. Lindenmayer came up with many systems to demonstrate how many plant forms can be replicated, and as I mentioned earlier, these sorts of cases of complexity emerging our of simplicity and randomness are a mainstay of both research and popular science.

Looking at the “fern” L-system, both how it starts looking organic and how you can still see that the ends of each branch look exactly the same, I can’t help but be reminded of things like diffusion model-generated images. Those can also look extremely convincing, but they also end up having rigid patterns and less overall complexity than the real-life things they are mimicking. Sometimes you can even notice the quirks visually; they famously started out having all kinds of disturbing effects on peoples’ hands, but now it’s usually more subtle things.

So now I can bring all this back to the topic of AI interpretability, especially mechanistic interpretability. In the description of this post, I gave the main question I’m asking: could we get a better sense of how modern AI models create their outputs by looking for ways in which they can “grow” more interesting complexity out of their simpler features.

I should definitely acknowledge that I’m far from the first person to suggest tackling interpretability in this way. The view that emergent complexity is key to understanding what neural networks are really doing dates back to the early years of the field, including Marvin Minsky’s application of it to both machine learning and the human mind (Minsky 1986). It’s definitely also present in foundational mechanistic interpretability frameworks. For example, (Elhage et al. 2021) transformer circuit explanations use straightforward views of latent vector components corresponding to basic features but also allow for other phenomena. An example would be that induction heads (or at least an induction task that some heads perform) can copy text or features from earlier in the sequence, and how that allows more rich representations to emerge. You can even construct iterative strings of symbols with similar copying rules, and get an effect of emergent complexity not that different from what you get with L-systems.

That said, if you’ll allow me to get a little opinionated for a moment, I think the perspective I’m talking about here is still sort of under-appreciated, especially when it comes to interpreting what the intermediate states of a neural network really mean and how they’re decided. It feels especially relevant as the interpretability community has been fiercely debating a recent claim that neural networks can be understood fully in a more “clean” way (Cammarata 2026), as well a some skepticism of it (leogao 2026).

Whichever way the debate over the clean view vs. superposition plays out, I think we will eventually be at some kind of place where we have a better idea of a neuron’s purpose but still need to see why the whole network pieces together the way it does, so that complex outputs can form. So I’m suggesting that we’ll want to know how the answer “grows” as the network progresses. Could outputs that answer complex problems, like LLM responses or generated images, be the result of emergent complexity growing, in a similar spirit to the “fractal plant” I went over here.

Specifically, looking at the surprising complexity that L-system “plants” can have made me ask: what if certain features, and ways of iterating or combining features, have much more power than others, specifically because they compound on themselves or each other into more sophisticated forms. After all, the expressiveness of neural networks as approximators comes from a similar effect itself: the repeated iteration of linear maps and a small number of activation functions leads to much more varied functions than the sum of the parts. And since we know that the real world images, text, video, etc. we’re trying to approximate very often has similar effects, then it doesn’t seem strange to wonder if models can learn to have the same emergent effects happen inside them during training.

To put it another way: could it be that in well-trained neural networks, the network performs the right iterations of some of it’s basic patterns to express more advanced features and reasoning? And if so, then exactly what form does that effect take, and how much can it help us understand?

If that is in fact the case, then maybe we could look for instances of it just like instances of more directly visible features? Since we’d be looking for the simplest parts that add up to the most complexity, maybe it could tell us more about how outputs are made than instances of “this neuron means this concept” or even “this set of concepts”. Since we’re trying to interpret such complicated networks, I think it would be useful if it turned out that some of their complex behaviors emerged in an organic way out of their basic features, like the fractal fern emerges from the twig. That would put a dent in the problem.

Next Steps For My Blog

Over the next several weeks, I’m planning to publish a series of blog pieces which go over some of the fundamental approaches to mechanistic interpretability and expand my own thoughts on the field. Here’s a breakdown of what I’m currently planning to cover:

  • A discussion of the main theories for how important information is stored in neural networks. This will include a discussion of the superposition principle and the arguments for and against “clean” networks, as well as what exactly the difference is (which I think is a subtle but very important detail to cover).

  • A discussion of transformer circuits, which after all are a core of modern mechanistic interpretability. This will also be a good time to dive further into the emergent view I’m wondering about. E.g: how can small circuits complement each other or combine in interesting ways?

  • An exercise I have in mind for understanding neural networks better: Since I mentioned that a neural network is an iteration of linear operations and activation functions, why not try to build some by hand and see what can be created? Can we choose basic, closed-form expressions for the layers that end up giving us interesting emergent results, like how the iteration rule in an L-system creates interesting pictures? Of course, the results would be vastly less complex than trained networks, but I bet that there’s some good intuition to be found.

  • An exercise in trying to reverse engineer as much interpretability as possible on a simple network, like a small transformer trained on one task.

  • A discussion of of recent results and theories on the training process itself, and how features emerge during it.

Of course, these are all very large topics by themselves, so I certainly don’t expect to be anywhere near comprehensive on them. My hope with this blog is to bring up interesting approaches and join the discussion of researchers on the problem reaching a true understanding of mechanistic interpretability. I think that de-mystifying the inner working of powerful AI models is one of the most important scientific problems we have right now. I also think that it’s more achievable than popular narratives usually say, even if there’s a lot more to go.

Citation

@online{Earle_Interpretability_2026,
  author = {Gabriel Earle},
  title  = {Interpretability Through The Lens of Fractal Plants},
  year   = {2026},
  url    = {https://gabeearle.com/blog/interpretability-1}
}

Originally published at gabeearle.com.

Appendix A: The Fern L-System In Detail

Here I’ll explain the precise steps for generating the L-system fern using a symbolic grammar.

The basic idea is that an L-system performs recursion by having a series of symbols and a rule for how each symbol “reproduces” into a new string, then concatenating the results together.

For example, one of the simplest possible cases would be when you start with “A” as your sone symbol, and then the rule “A -> AA”, so every A is doubled. Then iterating this rule the string would evolve like this:

A

AA

AAAA

AAAAAAAA

etc.

All that happens in this example is that the length of the string doubles every time. But add more symbols and more flavor to the recursive rules and suddenly things get much more interesting. Then we can give each symbol a rule for how to interpret it as a drawing step, and the whole string becomes a picture.

Here’s how to build the L-system that makes the “Fern” I showed you at the beginning. The symbols are: “X”, “F”, “+”, “-”, “[”, and ”]”.

“X” does not correspond to a drawing rule. It’s just there as a placeholder so it can generate more parts of the drawing on future iterations. So if you look at the current string and want to draw it, then you just skip the X.

“F” means drawing a line segment in a currently fixed direction by a fixed length.

As for the direction, you have a starting angle, and then “+” turns the angle to the left by 25°, and “-” to the right by 25°.

The brackets are for saving a position and angle and then returning to it later. This is important to get the branching nature of the “fern”. So as you draw an image from the string, whenever you encounter a “[”, you save the position and angle at that moment. Then the next time you encounter a ”]”, you return to the most recently saved position and angle and continue drawing from there. That way, whatever you drew in between the brackets can be left there as it’s own “branch”.

Now with that set up, these are the rules you follow to iterate the L-system and turn a string into a new string:

X → F+[[X]-X]-F[-FX]+X

F → FF

Since the second rule will just double the length of every existing line segment, you can scale the drawing by a factor of 1/2 each iteration to make its size stable.

With that in mind, the rule for replacing an “X” is now the only one that has a material effect on what the image actually shows.

The starting “-X” string means that the systems begins facing a certain direction and not having drawn any segments yet. Then after the first iteration, the string is “-F+[[X]-X]-F[-FX]+X”, by following the rule for replacing the X.